mixdog 0.9.63 → 0.9.65

package/src/runtime/shared/workspace-router.mjs

@@ -91,7 +91,7 @@ function projectFromRoot(root, marker) {
   };
 }
 
-export function findNearestProjectRoot(start) {
+function findNearestProjectRoot(start) {
   const initial = safeResolve(start);
   if (!initial || !safeIsDirectory(initial)) return null;
   let cur = initial;
@@ -108,7 +108,7 @@ function shouldIgnoreDir(name) {
   return IGNORE_DIRS.has(name) || name.startsWith('$') || name.endsWith('.tmp');
 }
 
-export function discoverProjectCandidates(base, {
+function discoverProjectCandidates(base, {
   maxDepth = DEFAULT_MAX_DEPTH,
   maxDirs = DEFAULT_MAX_DIRS,
   maxCandidates = DEFAULT_MAX_CANDIDATES,
@@ -179,7 +179,7 @@ function scanBaseFor(currentCwd, activeProject) {
   return currentCwd;
 }
 
-export function createWorkspaceRouter({
+function createWorkspaceRouter({
   entryCwd = process.cwd(),
   maxDepth = DEFAULT_MAX_DEPTH,
   maxDirs = DEFAULT_MAX_DIRS,
@@ -227,7 +227,7 @@ export function createWorkspaceRouter({
   return { snapshot };
 }
 
-export function formatWorkspaceSessionContext(snapshot) {
+function formatWorkspaceSessionContext(snapshot) {
   if (!snapshot) return '';
   const candidates = (snapshot.candidates || []).slice(0, 20);
   const lines = ['# Workspace'];
@@ -252,7 +252,7 @@ export function formatWorkspaceSessionContext(snapshot) {
   return lines.join('\n');
 }
 
-export function resolveWorkspaceCwd(baseCwd, value) {
+function resolveWorkspaceCwd(baseCwd, value) {
   const raw = String(value || '').trim();
   if (!raw) return resolve(baseCwd || process.cwd());
   return isAbsolute(raw) ? resolve(raw) : resolve(baseCwd || process.cwd(), raw);

package/src/session-runtime/config-helpers.mjs

@@ -138,10 +138,9 @@ export const AUTO_CLEAR_PROVIDER_IDLE_MS = Object.freeze({
   'mistral': 60 * 60 * 1000,
   'default': AUTO_CLEAR_DEFAULT_IDLE_MS,
 });
-export const AUTO_CLEAR_PROVIDER_IDS = Object.freeze(Object.keys(AUTO_CLEAR_PROVIDER_IDLE_MS));
-export const AUTO_CLEAR_UNKNOWN_PROVIDER_IDLE_MS = AUTO_CLEAR_PROVIDER_IDLE_MS.default;
+const AUTO_CLEAR_PROVIDER_IDS = Object.freeze(Object.keys(AUTO_CLEAR_PROVIDER_IDLE_MS));
 
-export function normalizeAutoClearProviderIdleMs(value = {}) {
+function normalizeAutoClearProviderIdleMs(value = {}) {
   const raw = value && typeof value === 'object' ? value : {};
   const out = {};
   for (const [key, ms] of Object.entries(raw)) {

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

@@ -16,7 +16,7 @@
 //                   only serializes agent-section fields, so a top-level
 //                   outputStyle would never reach disk via that path)
 
-export const CONFIG_SAVE_DEBOUNCE_MS = 150;
+const CONFIG_SAVE_DEBOUNCE_MS = 150;
 
 export function createConfigLifecycle({
   // config mutable-state injection

package/src/session-runtime/hitch-profile.mjs

@@ -10,7 +10,7 @@ function positiveNumberEnv(name, fallback) {
 
 // The histogram and sampling timer are never constructed unless explicitly
 // enabled, leaving the normal runtime with no event-loop profiling work.
-export function installHitchProfiler() {
+function installHitchProfiler() {
   if (!HITCH_PROFILE_ENABLED) return null;
 
   const thresholdMs = positiveNumberEnv('MIXDOG_HITCH_THRESHOLD_MS', 100);

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

@@ -94,10 +94,12 @@ export function createLifecycleApi(deps) {
       provider: s.provider,
       messageCount,
       preview,
-      heartbeatAt: Math.max(
-        Number(s.lastHeartbeatAt) || 0,
-        Number(heartbeatMtimes.get(s.id)) || 0,
-      ),
+      // Working indicator: the .hb sidecar ALONE is the liveness signal. Its
+      // deletion at turn end IS the completion signal, so the persisted
+      // lastHeartbeatAt JSON field (refreshed by the final save) must not be
+      // folded in — it pinned desktop spinners on for the full 2-minute TTL
+      // after a turn had already finished.
+      heartbeatAt: Number(heartbeatMtimes.get(s.id)) || 0,
       desktopSession: s.desktopSession || null,
     };
     }).filter(Boolean);

package/src/session-runtime/model-recency.mjs

@@ -3,7 +3,7 @@
 // injected route provider (for sort priority) and searchCapableFor predicate.
 import { clean } from './session-text.mjs';
 
-export function parsedProviderModelVersion(id) {
+function parsedProviderModelVersion(id) {
   const text = clean(id).toLowerCase();
   const claude = text.match(/^claude-[a-z]+-(\d+)(?:[-.](\d+))?/);
   if (claude) return [Number(claude[1]) || 0, Number(claude[2]) || 0];
@@ -13,7 +13,7 @@ export function parsedProviderModelVersion(id) {
   return generic ? generic.slice(1).filter((v) => v != null).map((v) => Number(v) || 0) : [];
 }
 
-export function compareProviderModelVersion(a, b) {
+function compareProviderModelVersion(a, b) {
   const va = parsedProviderModelVersion(a.id || a.display || a.name);
   const vb = parsedProviderModelVersion(b.id || b.display || b.name);
   if (va.length === 0 && vb.length === 0) return 0;
@@ -26,7 +26,7 @@ export function compareProviderModelVersion(a, b) {
   return 0;
 }
 
-export function providerModelReleaseTime(model) {
+function providerModelReleaseTime(model) {
   if (model?.releaseDate) {
     const t = Date.parse(model.releaseDate);
     if (Number.isFinite(t)) return t;
@@ -39,12 +39,12 @@ export function providerModelReleaseTime(model) {
   return dated ? (Date.parse(`${dated[1]}-${dated[2]}-${dated[3]}`) || 0) : 0;
 }
 
-export function isClaudeProviderModel(model) {
+function isClaudeProviderModel(model) {
   return clean(model?.provider).toLowerCase().includes('anthropic')
     && /^claude-[a-z]+-/.test(clean(model?.id).toLowerCase());
 }
 
-export function compareProviderModelRecency(a, b) {
+function compareProviderModelRecency(a, b) {
   if (isClaudeProviderModel(a) && isClaudeProviderModel(b)) {
     if (a.latest !== b.latest) return a.latest ? -1 : 1;
     const versionDelta = compareProviderModelVersion(a, b);

package/src/session-runtime/plugin-mcp.mjs

@@ -131,7 +131,7 @@ function isSkillMdFile(name) {
   return /^(SKILL|skill)\.md$/i.test(name);
 }
 
-export const PLUGIN_INLINE_MCP_SCRIPT = 'plugin.json';
+const PLUGIN_INLINE_MCP_SCRIPT = 'plugin.json';
 
 export function countSkillFiles(root) {
   let count = 0;

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

@@ -0,0 +1,338 @@
+// Provider request-tool resolution + JSON-safe snapshot machinery, extracted from tool-catalog.mjs.
+import { clean, LATE_TOOL_ANNOUNCEMENT_SENTINEL } from './session-text.mjs';
+import { estimateToolSchemaTokens, toolSchemaSignature } from '../runtime/agent/orchestrator/session/context-utils.mjs';
+import {
+  applyInitialDeferredToolManifestToBp1,
+  buildDeferredToolManifest,
+  stripDeferredToolManifestBlock,
+} from '../runtime/agent/orchestrator/context/collect.mjs';
+import { getMcpServerInstructionsMap } from '../runtime/agent/orchestrator/mcp/client.mjs';
+import {
+  isResponsesFreeformTool,
+  toResponsesCustomTool,
+} from '../runtime/agent/orchestrator/providers/custom-tool-wire.mjs';
+import {
+  finalizeProviderRequestTools,
+  providerNativeToolPrefixCount,
+} from './provider-request-tools.mjs';
+import {
+  DEFERRED_DEFAULT_FULL_TOOLS,
+  DEFERRED_DEFAULT_LEAD_TOOLS,
+  DEFERRED_DEFAULT_READONLY_TOOLS,
+  DEFERRED_SELECT_ALIASES,
+  MEASURED_TOOL_ORDER,
+  MEASURED_TOOL_USAGE,
+  READONLY_TOOL_NAMES,
+} from './tool-catalog-data.mjs';
+import { parseToolSelection, ANTHROPIC_NATIVE_PROVIDERS } from './tool-catalog-schema.mjs';
+
+export function resolveProviderRequestTools({
+  provider,
+  tools,
+  messages,
+  session,
+} = {}) {
+  const activeTools = Array.isArray(tools) ? tools : [];
+  const normalizedProvider = clean(provider || session?.provider).toLowerCase();
+  if (!ANTHROPIC_NATIVE_PROVIDERS.has(normalizedProvider)
+    || session?.deferredNativeTools !== true
+    || activeTools.length === 0) {
+    return activeTools;
+  }
+  const discovered = new Set(
+    parseToolSelection(session?.deferredDiscoveredTools),
+  );
+  for (const message of Array.isArray(messages) ? messages : []) {
+    const native = message?.nativeToolSearch;
+    const source = clean(native?.provider).toLowerCase();
+    if (source && source !== normalizedProvider
+      && !(ANTHROPIC_NATIVE_PROVIDERS.has(source)
+        && ANTHROPIC_NATIVE_PROVIDERS.has(normalizedProvider))) continue;
+    for (const name of parseToolSelection(native?.toolReferences)) discovered.add(name);
+  }
+  if (discovered.size === 0) return activeTools;
+  const activeNames = new Set(activeTools.map((tool) => clean(tool?.name)).filter(Boolean));
+  const catalog = Array.isArray(session?.deferredToolCatalog) ? session.deferredToolCatalog : [];
+  const deferredTools = catalog
+    .filter((tool) => {
+      const name = clean(tool?.name);
+      return name && discovered.has(name) && !activeNames.has(name);
+    })
+    .map((tool) => ({ ...tool, deferLoading: true }));
+  return deferredTools.length ? [...activeTools, ...deferredTools] : activeTools;
+}
+
+const OMIT_REQUEST_TOOL_VALUE = Symbol('omit-request-tool-value');
+const MAX_PROVIDER_SNAPSHOT_ARRAY_LENGTH = 1_000_000;
+
+function defineEnumerableDataProperty(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    configurable: false,
+    writable: false,
+  });
+}
+
+function boxedJsonPrimitive(value) {
+  try { return { matched: true, value: Number.prototype.valueOf.call(value) }; } catch {}
+  try { return { matched: true, value: String.prototype.valueOf.call(value) }; } catch {}
+  try { return { matched: true, value: Boolean.prototype.valueOf.call(value) }; } catch {}
+  try { return { matched: true, value: BigInt.prototype.valueOf.call(value) }; } catch {}
+  return { matched: false, value: null };
+}
+
+function providerSnapshotLengthPrimitive(value) {
+  if ((typeof value !== 'object' || value === null) && typeof value !== 'function') return value;
+  const exotic = value[Symbol.toPrimitive];
+  if (exotic !== undefined && exotic !== null) {
+    if (typeof exotic !== 'function') throw new TypeError('invalid length primitive');
+    const primitive = exotic.call(value, 'number');
+    if ((typeof primitive === 'object' && primitive !== null) || typeof primitive === 'function') {
+      throw new TypeError('invalid length primitive');
+    }
+    return primitive;
+  }
+  for (const methodName of ['valueOf', 'toString']) {
+    const method = value[methodName];
+    if (typeof method !== 'function') continue;
+    const primitive = method.call(value);
+    if ((typeof primitive !== 'object' || primitive === null) && typeof primitive !== 'function') {
+      return primitive;
+    }
+  }
+  throw new TypeError('invalid length primitive');
+}
+
+function providerSnapshotArrayLength(rawLength) {
+  let primitive;
+  let numeric;
+  try {
+    primitive = providerSnapshotLengthPrimitive(rawLength);
+    if (typeof primitive === 'bigint' || typeof primitive === 'symbol') {
+      throw new TypeError('invalid length primitive');
+    }
+    numeric = Number(primitive);
+  } catch {
+    throw new TypeError('provider tool snapshot: invalid array length');
+  }
+  if (Number.isNaN(numeric) || numeric <= 0) return 0;
+  if (!Number.isFinite(numeric)) {
+    throw new RangeError(
+      `provider tool snapshot: array length exceeds safe limit ${MAX_PROVIDER_SNAPSHOT_ARRAY_LENGTH}`,
+    );
+  }
+  const effectiveLength = Math.floor(numeric);
+  if (effectiveLength > MAX_PROVIDER_SNAPSHOT_ARRAY_LENGTH) {
+    throw new RangeError(
+      `provider tool snapshot: array length exceeds safe limit ${MAX_PROVIDER_SNAPSHOT_ARRAY_LENGTH}`,
+    );
+  }
+  return effectiveLength;
+}
+
+function normalizeRequestToolJson(value, state, {
+  arrayEntry = false,
+  key = '',
+  applyToJSON = true,
+  seededProperties = null,
+} = {}) {
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return value;
+  if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+  if (typeof value === 'bigint') {
+    throw new TypeError('provider tool snapshot: BigInt is not JSON-serializable');
+  }
+  if (value === undefined || typeof value === 'function' || typeof value === 'symbol') {
+    return arrayEntry ? null : OMIT_REQUEST_TOOL_VALUE;
+  }
+  if (typeof value !== 'object') {
+    throw new TypeError(`provider tool snapshot: unsupported JSON value type ${typeof value}`);
+  }
+  if (state.active.has(value)) {
+    throw new TypeError('provider tool snapshot: cyclic value is not JSON-serializable');
+  }
+  if (state.memo.has(value)) return state.memo.get(value);
+
+  let capturedProperties = seededProperties;
+  if (applyToJSON) {
+    // JSON reads `toJSON` once before serializing an object. Preserve that
+    // single observation for an own-enumerable non-function (and for a
+    // callable that returns `this`) so property traversal cannot invoke a
+    // stateful accessor a second time.
+    const toJSONDescriptor = Object.getOwnPropertyDescriptor(value, 'toJSON');
+    const toJSON = value.toJSON;
+    if (typeof toJSON === 'function') {
+      // Keep the source guarded through both hook execution and replacement
+      // normalization. A hook returning itself, or any replacement graph that
+      // points back to its source, is a JSON cycle rather than another hook
+      // invocation.
+      state.active.add(value);
+      try {
+        const replacement = toJSON.call(value, key);
+        const normalized = normalizeRequestToolJson(replacement, state, {
+          arrayEntry,
+          key,
+          applyToJSON: false,
+          seededProperties: null,
+        });
+        state.memo.set(value, normalized);
+        return normalized;
+      } finally {
+        state.active.delete(value);
+      }
+    }
+    if (toJSONDescriptor?.enumerable) {
+      capturedProperties = { ...(seededProperties || {}), toJSON };
+    }
+  }
+  const boxed = boxedJsonPrimitive(value);
+  if (boxed.matched) {
+    return normalizeRequestToolJson(boxed.value, state, { arrayEntry, key });
+  }
+
+  const isArray = Array.isArray(value);
+  const normalized = isArray ? [] : {};
+  state.active.add(value);
+  try {
+    if (isArray) {
+      // JSON.stringify captures array length once. Accessors may mutate the
+      // source array, but they cannot extend or shorten this iteration bound.
+      const rawLength = value.length;
+      const length = providerSnapshotArrayLength(rawLength);
+      for (let index = 0; index < length; index += 1) {
+        const entry = value[index];
+        normalized.push(normalizeRequestToolJson(entry, state, {
+          arrayEntry: true,
+          key: String(index),
+        }));
+      }
+    } else {
+      // JSON-compatible request schemas are own-enumerable data. Normalize class
+      // instances/accessors to a plain record, ignore inherited mutable fields,
+      // and define keys explicitly so an own "__proto__" remains ordinary data.
+      for (const key of Reflect.ownKeys(value)) {
+        if (typeof key !== 'string') continue;
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor?.enumerable) continue;
+        // Deferred catalog selection captures `name` once before touching the
+        // candidate schema. Seed that captured value here so a stateful/throwing
+        // getter is never observed a second time during JSON normalization.
+        const entry = capturedProperties && Object.hasOwn(capturedProperties, key)
+          ? capturedProperties[key]
+          : value[key];
+        const child = normalizeRequestToolJson(entry, state, { key });
+        if (child !== OMIT_REQUEST_TOOL_VALUE) defineEnumerableDataProperty(normalized, key, child);
+      }
+    }
+  } finally {
+    state.active.delete(value);
+  }
+  Object.freeze(normalized);
+  state.memo.set(value, normalized);
+  return normalized;
+}
+
+// Establish one immutable request-attempt snapshot. Nested schema records are
+// cloned before freezing, so a catalog refresh or in-place schema mutation
+// after this boundary cannot change either provider bytes or their signature.
+export function snapshotProviderRequestTools(options = {}) {
+  const {
+    provider,
+    tools,
+    nativeTools,
+    messages,
+    session,
+  } = options;
+  const activeTools = Array.isArray(tools) ? tools : [];
+  const state = { active: new WeakSet(), memo: new WeakMap() };
+  const snapshots = [];
+  const names = new Set();
+  const activeCandidateRefs = new WeakSet();
+  // Anthropic native definitions are already provider-wire objects. Preserve
+  // their prior prepend order and duplicate behavior, but freeze the exact
+  // bytes into the same request snapshot used for accounting and retries.
+  if (ANTHROPIC_NATIVE_PROVIDERS.has(clean(provider || session?.provider).toLowerCase())) {
+    for (const nativeTool of Array.isArray(nativeTools) ? nativeTools : []) {
+      if (!nativeTool || typeof nativeTool !== 'object') continue;
+      const normalized = normalizeRequestToolJson(nativeTool, state);
+      if (normalized && typeof normalized === 'object' && !Array.isArray(normalized)) {
+        snapshots.push(normalized);
+      }
+    }
+  }
+  const nativePrefixCount = snapshots.length;
+  const finish = () => finalizeProviderRequestTools(snapshots, nativePrefixCount);
+  const appendSnapshot = (candidate, selectedName = null, deferred = false) => {
+    const normalized = normalizeRequestToolJson(candidate, state, {
+      seededProperties: selectedName === null ? null : { name: selectedName },
+    });
+    if (deferred && (
+      !normalized
+      || typeof normalized !== 'object'
+      || Array.isArray(normalized)
+      || typeof normalized.name !== 'string'
+      || !clean(normalized.name)
+      || normalized.name !== selectedName
+    )) {
+      throw new TypeError(`provider tool snapshot: selected tool identity mismatch for ${JSON.stringify(selectedName)}`);
+    }
+    if (!normalized || typeof normalized !== 'object' || Array.isArray(normalized)) return;
+    const name = clean(normalized.name);
+    if (!name || names.has(name)) return;
+    names.add(name);
+    if (!deferred) {
+      snapshots.push(normalized);
+      return;
+    }
+    const deferredSnapshot = {};
+    for (const key of Object.keys(normalized)) {
+      if (key === 'deferLoading' || key === 'defer_loading') continue;
+      defineEnumerableDataProperty(deferredSnapshot, key, normalized[key]);
+    }
+    defineEnumerableDataProperty(deferredSnapshot, 'deferLoading', true);
+    snapshots.push(Object.freeze(deferredSnapshot));
+  };
+
+  // Active candidates are provider-visible by definition: normalize each once,
+  // then perform all validation/dedupe from the plain snapshot only.
+  for (const tool of activeTools) {
+    if (tool && typeof tool === 'object') activeCandidateRefs.add(tool);
+    appendSnapshot(tool);
+  }
+
+  const normalizedProvider = clean(provider || session?.provider).toLowerCase();
+  if (!ANTHROPIC_NATIVE_PROVIDERS.has(normalizedProvider)
+    || session?.deferredNativeTools !== true
+    // Native definitions preserve their historical prepend behavior, but they
+    // do not make an otherwise all-deferred catalog eligible for expansion.
+    || names.size === 0) {
+    return finish();
+  }
+  const discovered = new Set(parseToolSelection(session?.deferredDiscoveredTools));
+  for (const message of Array.isArray(messages) ? messages : []) {
+    const native = message?.nativeToolSearch;
+    const source = clean(native?.provider).toLowerCase();
+    if (source && source !== normalizedProvider
+      && !(ANTHROPIC_NATIVE_PROVIDERS.has(source)
+        && ANTHROPIC_NATIVE_PROVIDERS.has(normalizedProvider))) continue;
+    for (const name of parseToolSelection(native?.toolReferences)) discovered.add(name);
+  }
+  if (discovered.size === 0) return finish();
+
+  // Catalog arrays have no separate key map, so `name` is their explicit
+  // selection key contract: capture it once, skip undiscovered/duplicate
+  // entries without touching schemas, and seed selected normalization with the
+  // captured value to avoid a second getter evaluation.
+  const seenCatalogRefs = new WeakSet();
+  for (const tool of Array.isArray(session?.deferredToolCatalog) ? session.deferredToolCatalog : []) {
+    if (tool && typeof tool === 'object') {
+      if (activeCandidateRefs.has(tool) || seenCatalogRefs.has(tool)) continue;
+      seenCatalogRefs.add(tool);
+    }
+    const capturedName = tool?.name;
+    const selectionName = typeof capturedName === 'string' ? clean(capturedName) : '';
+    if (!selectionName || !discovered.has(selectionName) || names.has(selectionName)) continue;
+    appendSnapshot(tool, capturedName, true);
+  }
+  return finish();
+}

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-text.mjs

@@ -42,14 +42,14 @@ const SYNTHETIC_SESSION_TEXT_PATTERNS = Object.freeze([
   /^the async (?:agent|shell) task\b/i,
 ]);
 
-export function stripSessionDisplayEnvelope(value) {
+function stripSessionDisplayEnvelope(value) {
   return String(value ?? '')
     .replace(/^# Session\r?\n(?:(?:Cwd|Model|Workflow):[^\r\n]*(?:\r?\n|$))+(?:\r?\n)?/i, '')
     .replace(/^#\s*Session\s+Cwd:\s+.*?\s+Model:\s+.*?\s+Workflow:\s+\S+\s*/i, '')
     .replace(/^#\s*Session\s+Cwd:\s+\S+(?:\s+Model:\s+\S*)?(?:\s+Workflow:\s+\S*)?\s*/i, '');
 }
 
-export function stripInjectedSessionText(value) {
+function stripInjectedSessionText(value) {
   let text = String(value ?? '');
   for (const tag of INJECTED_DISPLAY_BLOCK_TAGS) {
     const block = new RegExp(`<${tag}\\b[^>]*>[\\s\\S]*?(?:<\\/${tag}\\s*>|$)`, 'gi');
@@ -59,7 +59,7 @@ export function stripInjectedSessionText(value) {
   return text;
 }
 
-export function isSyntheticSessionText(text) {
+function isSyntheticSessionText(text) {
   const value = String(text || '').trim();
   return SYNTHETIC_SESSION_TEXT_PATTERNS.some((pattern) => pattern.test(value));
 }
@@ -102,7 +102,7 @@ export function isLateToolAnnouncement(text) {
 // "MCP tools available: UnityMCP (12 tools)". MCP tool entries in the manifest
 // are `- mcp__<server>__<tool>: ...` lines; the server name is the segment
 // after the `mcp__` prefix. Returns '' for non-announcement text.
-export function summarizeLateToolAnnouncement(text) {
+function summarizeLateToolAnnouncement(text) {
   const value = String(text || '');
   if (!isLateToolAnnouncement(value)) return '';
   const block = value.match(/<available-deferred-tools>([\s\S]*?)<\/available-deferred-tools>/i);

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