mixdog 0.9.82 → 0.9.84

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.82",
+  "version": "0.9.84",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/scripts/runtime-dependency-cache-key.mjs

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+import { createHash } from 'node:crypto'
+import { readFile } from 'node:fs/promises'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+import { embeddingRuntimeTarget } from './prune-embedding-runtime.mjs'
+
+export const RUNTIME_DEPENDENCY_CACHE_SCHEMA = 1
+
+function sha256(value) {
+  return createHash('sha256').update(value).digest('hex')
+}
+
+export function normalizeRuntimeLockfile(lockfile) {
+  const normalized = structuredClone(
+    typeof lockfile === 'string' || Buffer.isBuffer(lockfile)
+      ? JSON.parse(String(lockfile))
+      : lockfile,
+  )
+  // Deploy updates the package identity before every release, but that does
+  // not change the production dependency tree cached by native packagers.
+  delete normalized.name
+  delete normalized.version
+  if (normalized.packages?.['']) {
+    delete normalized.packages[''].name
+    delete normalized.packages[''].version
+  }
+  return normalized
+}
+
+export function runtimeDependencyFingerprint({
+  lockfile,
+  prunerSource,
+  target,
+  host = `${process.platform}-${process.arch}`,
+  nodeAbi = process.versions.modules,
+}) {
+  return sha256(JSON.stringify({
+    schemaVersion: RUNTIME_DEPENDENCY_CACHE_SCHEMA,
+    target,
+    host,
+    nodeAbi,
+    lockfile: normalizeRuntimeLockfile(lockfile),
+    prunerSha256: sha256(prunerSource),
+  }))
+}
+
+export async function runtimeDependencyCacheIdentity(rootDir, target) {
+  const [lockfile, prunerSource] = await Promise.all([
+    readFile(join(rootDir, 'package-lock.json')),
+    readFile(join(rootDir, 'scripts', 'prune-embedding-runtime.mjs')),
+  ])
+  const host = `${process.platform}-${process.arch}`
+  const nodeAbi = process.versions.modules
+  return {
+    schemaVersion: RUNTIME_DEPENDENCY_CACHE_SCHEMA,
+    target: target.key,
+    host,
+    nodeAbi,
+    fingerprint: runtimeDependencyFingerprint({
+      lockfile,
+      prunerSource,
+      target: target.key,
+      host,
+      nodeAbi,
+    }),
+  }
+}
+
+export function runtimeDependencyCacheKey(identity) {
+  return `runtime-deps-v${identity.schemaVersion}-${identity.target}-${identity.fingerprint}`
+}
+
+const invokedPath = process.argv[1] ? pathToFileURL(resolve(process.argv[1])).href : ''
+if (invokedPath === import.meta.url) {
+  const optionValue = (name) => {
+    const prefix = `--${name}=`
+    const argument = process.argv.find((value) => value.startsWith(prefix))
+    return argument ? argument.slice(prefix.length) : ''
+  }
+  const rootDir = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+  const target = embeddingRuntimeTarget({
+    platform: optionValue('platform') || undefined,
+    arch: optionValue('arch') || undefined,
+  })
+  runtimeDependencyCacheIdentity(rootDir, target)
+    .then((identity) => process.stdout.write(`${runtimeDependencyCacheKey(identity)}\n`))
+    .catch((error) => {
+      process.stderr.write(`Runtime dependency cache key failed: ${error?.message || error}\n`)
+      process.exitCode = 1
+    })
+}

package/src/runtime/agent/orchestrator/providers/media-normalization.mjs

@@ -203,8 +203,11 @@ export function contentToText(content, fallback = '') {
 
 function storedHistoryImagePlaceholder(part) {
     const info = imageInfo(part) || geminiInlineInfo(part);
-    const url = imageUrlFromPart(part);
-    const fileUri = imageFileUriFromPart(part);
+    // Inline base64 already gives us its MIME type. Do not call
+    // imageUrlFromPart in that case: it would manufacture a second
+    // `data:...;base64,<entire payload>` string merely to discard it.
+    const url = info ? null : imageUrlFromPart(part);
+    const fileUri = info ? null : imageFileUriFromPart(part);
     const mimeType = info?.mimeType || imageMimeFromDataUrl(url) || fileUri?.mimeType || (part?.type === 'image' ? DEFAULT_IMAGE_MIME : '');
     return `[Image omitted from stored history${mimeType ? `: ${mimeType}` : ''}]`;
 }

package/src/runtime/agent/orchestrator/session/manager/idle-cleanup.mjs

@@ -2,7 +2,7 @@
 // Periodic idle-session + tombstone sweep extracted verbatim from manager.mjs.
 // Drives sweepStaleSessions on an unref'd interval; closeSession is imported
 // from session-close.mjs (one-way dependency, no cycle).
-import { sweepStaleSessions, evictIdleLiveSessions } from '../store.mjs';
+import { sweepStaleSessions, sweepStaleSessionsCooperative, evictIdleLiveSessions } from '../store.mjs';
 import { sweepOrphanedPendingMessages } from './pending-messages.mjs';
 import {
     _getRuntimeEntry,
@@ -23,6 +23,7 @@ const CLEANUP_SLOW_LOG_MS = nonNegativeIntEnv('MIXDOG_SESSION_CLEANUP_SLOW_LOG_M
 const TOMBSTONE_MAX_AGE_MS = 60 * 60 * 1000; // 1h
 let _cleanupTimer = null;
 let _cleanupInitialTimer = null;
+let _cleanupRun = null;
 
 // A session is "live" when it still owns a non-closed runtime entry. Passed to
 // the retention cap so the active/current and any in-flight session is never
@@ -65,10 +66,10 @@ const _sweepLog = (line) => {
     if (process.env.MIXDOG_DEBUG_SESSION_LOG) process.stderr.write(line);
 };
 
-function sweepIdleSessions({ includeTombstones = true, sweepIdle = true } = {}) {
+async function sweepIdleSessions({ includeTombstones = true, sweepIdle = true } = {}) {
     const startedAt = Date.now();
     try {
-        const result = sweepStaleSessions({
+        const result = await sweepStaleSessionsCooperative({
             sweepIdle,
             tombstoneMaxAgeMs: includeTombstones ? TOMBSTONE_MAX_AGE_MS : 0,
             isSessionLive: _isSessionLive,
@@ -144,33 +145,43 @@ export function sweepTombstones() {
 }
 
 export function _runCleanupCycle() {
-    // Drain every settled runtime entry on each pass, not just the one or two
-    // sessions whose on-disk idle TTL happened to expire in this interval.
-    _sweepTerminalSessionRuntimes();
-    sweepOrphanedPendingMessages();
-    sweepIdleSessions({ includeTombstones: true });
-    // Reclaim same-process session snapshots whose state is durable on disk
-    // (memory-leak guard: _liveSessions used to grow for process lifetime).
-    try { evictIdleLiveSessions({ isSessionLive: _isSessionLive }); } catch { /* best-effort */ }
+    if (_cleanupRun) return _cleanupRun;
+    const run = (async () => {
+        // Drain every settled runtime entry on each pass, not just the one or two
+        // sessions whose on-disk idle TTL happened to expire in this interval.
+        _sweepTerminalSessionRuntimes();
+        sweepOrphanedPendingMessages();
+        await sweepIdleSessions({ includeTombstones: true });
+        // Reclaim same-process session snapshots whose state is durable on disk
+        // (memory-leak guard: _liveSessions used to grow for process lifetime).
+        try { evictIdleLiveSessions({ isSessionLive: _isSessionLive }); } catch { /* best-effort */ }
+    })().catch((error) => {
+        try { process.stderr.write(`[agent-session] cleanup cycle failed: ${error?.message || error}\n`); } catch {}
+    });
+    const tracked = run.finally(() => {
+        if (_cleanupRun === tracked) _cleanupRun = null;
+    });
+    _cleanupRun = tracked;
+    return tracked;
 }
 
 function _startCleanupInterval() {
     if (_cleanupTimer) return;
     if (CLEANUP_INTERVAL_MS <= 0) return;
-    _cleanupTimer = setInterval(_runCleanupCycle, CLEANUP_INTERVAL_MS);
+    _cleanupTimer = setInterval(() => { void _runCleanupCycle(); }, CLEANUP_INTERVAL_MS);
     if (_cleanupTimer.unref) _cleanupTimer.unref(); // don't block process exit
 }
 
 export function startIdleCleanup() {
     if (_cleanupTimer || _cleanupInitialTimer) return;
     if (CLEANUP_INITIAL_DELAY_MS <= 0) {
-        _runCleanupCycle();
+        void _runCleanupCycle();
         _startCleanupInterval();
         return;
     }
     _cleanupInitialTimer = setTimeout(() => {
         _cleanupInitialTimer = null;
-        _runCleanupCycle();
+        void _runCleanupCycle();
         _startCleanupInterval();
     }, CLEANUP_INITIAL_DELAY_MS);
     if (_cleanupInitialTimer.unref) _cleanupInitialTimer.unref();

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

@@ -244,7 +244,7 @@ export function getStoredSessionsRaw() {
  * Background sweep: delete session files idle longer than ttlMs.
  * Returns { cleaned, remaining, details } for logging.
  */
-export function sweepStaleSessions(ttlMs, options = {}) {
+function* sweepStaleSessionSteps(ttlMs, options = {}) {
     if (ttlMs && typeof ttlMs === 'object') {
         options = ttlMs;
         ttlMs = options.ttlMs;
@@ -302,6 +302,9 @@ export function sweepStaleSessions(ttlMs, options = {}) {
     let openPruned = 0;
     const openPrunedDetails = [];
     for (const row of summaries) {
+        // Cooperative callers pause between records so large stores never hold
+        // an interactive host's event loop for the full directory scan.
+        yield undefined;
         try {
             if (!row?.id) continue;
             const jsonPath = sessionPath(row.id);
@@ -593,6 +596,7 @@ export function sweepStaleSessions(ttlMs, options = {}) {
     // session mid-create whose .json write has not landed yet.
     try {
         for (const h of readdirSync(dir).filter(f => f.endsWith('.hb') || f.endsWith('.own'))) {
+            yield undefined;
             if (existsSync(join(dir, h.replace(/\.(hb|own)$/, '.json')))) continue;
             let hbMtime = 0;
             try { hbMtime = statSync(join(dir, h)).mtimeMs; } catch { continue; }
@@ -613,3 +617,36 @@ export function sweepStaleSessions(ttlMs, options = {}) {
     }
     return { cleaned, remaining, details, tombstonesCleaned, tombstoneDetails, tombstoneErrors, openPruned, openPrunedDetails };
 }
+
+/** Synchronous compatibility surface for explicit maintenance commands/tests. */
+export function sweepStaleSessions(ttlMs, options = {}) {
+    const steps = sweepStaleSessionSteps(ttlMs, options);
+    let next = steps.next();
+    while (!next.done) next = steps.next();
+    return next.value;
+}
+
+/**
+ * Interactive-host sweep: preserve the exact synchronous lifecycle decisions
+ * while yielding between records. A single large session remains atomic, but a
+ * directory worth of reads/parses can no longer become one multi-second task.
+ */
+export async function sweepStaleSessionsCooperative(ttlMs, options = {}) {
+    const cooperativeOptions = ttlMs && typeof ttlMs === 'object' ? ttlMs : options;
+    const configuredSliceMs = Number(cooperativeOptions?.cooperativeSliceMs);
+    const sliceMs = Number.isFinite(configuredSliceMs)
+        ? Math.min(50, Math.max(0, configuredSliceMs))
+        : 8;
+    const steps = sweepStaleSessionSteps(ttlMs, options);
+    let next = steps.next();
+    while (!next.done) {
+        const sliceStartedAt = performance.now();
+        do {
+            next = steps.next();
+        } while (!next.done && performance.now() - sliceStartedAt < sliceMs);
+        if (!next.done) {
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+    }
+    return next.value;
+}

package/src/runtime/agent/orchestrator/session/store/save-worker.mjs

@@ -1,6 +1,6 @@
 import { Worker } from 'worker_threads';
 import { guardedSaveOptions as _guardedSaveOptions } from './write-guards.mjs';
-import { _ensureLifecycleFields } from './serialize.mjs';
+import { _ensureLifecycleFields, _sessionForDisk } from './serialize.mjs';
 import { setLiveSession, _droppedSaveIds, clearSessionSaveError } from './live-state.mjs';
 import { _cacheSessionSummary, _rollbackCachedSessionSummary, _queueSessionSummaryUpsert } from './summary-cache.mjs';
 
@@ -23,6 +23,17 @@ let _saveWorkerRefCount = 0;
 let _deferredSaveReqId = 0;
 export const _deferredSessionSaves = new Map();
 
+/**
+ * Build the exact payload the worker will persist BEFORE Worker.postMessage
+ * structured-clones it on the caller's thread. Inline image/document bytes and
+ * transient live-turn aliases are disk-ineligible already; removing them here
+ * prevents a multi-megabyte duplicate allocation and long clone pause while
+ * preserving canonical text/tool history byte-for-byte.
+ */
+export function _sessionPayloadForSaveWorker(session) {
+    return _sessionForDisk(session);
+}
+
 function _getOrSpawnWorker() {
     if (_saveWorker) return _saveWorker;
     _saveWorker = new Worker(new URL('../save-session-worker.mjs', import.meta.url), {
@@ -179,19 +190,10 @@ export function saveSessionAsync(session, opts) {
     const id = session.id;
     const summaryVersion = _cacheSessionSummary(session);
     const safeOpts = opts?._sessionWriteGuard ? opts : _guardedSaveOptions(id, opts);
-    // The Worker `postMessage` below structured-clones the whole session on the
-    // main thread. `session.liveTurnMessages` (live working transcript) and
-    // `session.toolApprovalHook` (askOpts.onToolApproval callback) are transient
-    // in-flight aliases askSession sets for the turn duration; both carry
-    // non-cloneable values (a function, and raw messages that can hold functions),
-    // which makes structuredClone throw "could not be cloned" for every mid-turn
-    // iteration save. The worker strips both via _sessionForDisk anyway, so drop
-    // them from the cloned payload here WITHOUT mutating the live session object.
-    const clonePayload = (session && typeof session === 'object'
-        && (Object.prototype.hasOwnProperty.call(session, 'liveTurnMessages')
-            || Object.prototype.hasOwnProperty.call(session, 'toolApprovalHook')))
-        ? (() => { const { liveTurnMessages: _dropLTM, toolApprovalHook: _dropTAH, ...rest } = session; return rest; })()
-        : session;
+    // Worker.postMessage clones on THIS thread. Project to the canonical disk
+    // shape first so media bytes and duplicate live-turn aliases never enter
+    // that clone. setLiveSession above deliberately retains the rich original.
+    const clonePayload = _sessionPayloadForSaveWorker(session);
     return new Promise((resolve, reject) => {
         const waiter = { resolve, reject };
         if (_saveAsyncInflight.has(id)) {

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

@@ -757,5 +757,6 @@ export {
     listStoredSessionSummaries,
     getStoredSessionsRaw,
     sweepStaleSessions,
+    sweepStaleSessionsCooperative,
 } from './store/listing.mjs';
 export { _savePending };

package/src/runtime/shared/turn-snapshot.mjs

@@ -1,184 +1,121 @@
-// Turn-scoped worktree snapshots over a SHADOW git repository.
+// Turn-scoped review registry.
 //
-// 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.
+// The public function names retain the original shadow-snapshot API so desktop
+// capability callers stay compatible. The tracked data now follows Codex's
+// attribution rule instead: only successful apply_patch UI diffs are recorded,
+// each worker keeps its own review, and a Lead turn may read its child reviews
+// without reassigning them to the Lead.
 //
-// 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';
+// Lead patches already live in the Lead transcript. Worker patches are
+// delivered through agentLoop.onToolResult and frozen here against the owning
+// Lead turn generation. Shell/background/external-editor writes are excluded.
 
 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 TURN_CACHE_MAX = 32;
 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
+const _turnsBySession = new Map();
+let _agentTurnSeq = 0;
 
-function _worktreeKey(worktree) {
-  const raw = String(worktree || '').trim();
-  if (!raw) return '';
-  const full = resolve(raw);
-  return process.platform === 'win32' ? full.toLowerCase() : full;
+function clean(value) {
+  return typeof value === 'string' ? value.trim() : '';
 }
 
-function _gitDirFor(worktreeKey) {
-  const hash = createHash('sha1').update(worktreeKey).digest('hex').slice(0, 20);
-  return join(resolvePluginData(), 'turn-snapshots', hash);
+function trimTurnCache() {
+  while (_turnsBySession.size > TURN_CACHE_MAX) {
+    const oldest = _turnsBySession.keys().next().value;
+    if (oldest === undefined) break;
+    _turnsBySession.delete(oldest);
+  }
 }
 
-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 || '') });
-    });
-  });
+function mergePatches(values) {
+  let merged = '';
+  for (const value of Array.isArray(values) ? values : [values]) {
+    const patch = typeof value === 'string' ? value.trim() : '';
+    if (!patch) continue;
+    const next = merged ? `${merged}\n${patch}` : patch;
+    if (next.length > MAX_PATCH_BYTES) break;
+    merged = next;
+  }
+  return merged;
 }
 
-// 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;
+function publicAgentReviews(sessionId) {
+  const turn = _turnsBySession.get(clean(sessionId));
+  if (!turn) return [];
+  return [...turn.agents.values()].map((review) => ({ ...review }));
 }
 
-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;
-}
+/** Compatibility no-op: apply_patch tracking has no project warmup cost. */
+export function prewarmTurnSnapshot() {}
 
-// 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;
+/** Start a new user turn and invalidate the prior turn's child review group. */
+export async function beginTurnSnapshot(_worktree, sessionId) {
+  const ownerSessionId = clean(sessionId);
+  if (DISABLED || !ownerSessionId) return;
+  const generation = (_turnsBySession.get(ownerSessionId)?.generation || 0) + 1;
+  _turnsBySession.delete(ownerSessionId);
+  _turnsBySession.set(ownerSessionId, {
+    generation,
+    agents: new Map(),
   });
+  trimTurnCache();
 }
 
-/** 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(() => {});
+/** Bind one worker execution to the Lead turn that launched it. */
+export function beginAgentTurnReview(ownerSessionId, childSessionId, meta = {}) {
+  if (DISABLED) return null;
+  const owner = clean(ownerSessionId);
+  const child = clean(childSessionId);
+  const turn = _turnsBySession.get(owner);
+  if (!owner || !child || !turn) return null;
+  _agentTurnSeq += 1;
+  return {
+    id: `agent-review-${_agentTurnSeq}`,
+    ownerSessionId: owner,
+    generation: turn.generation,
+    sessionId: child,
+    agent: clean(meta.agent) || null,
+    tag: clean(meta.tag) || null,
+    completed: false,
+  };
 }
 
-/** 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?.(); })]);
+/** Freeze successful worker apply_patch diffs into their owning Lead turn. */
+export function completeAgentTurnReview(handle, patches = []) {
+  if (!handle || handle.completed === true) return false;
+  handle.completed = true;
+  const turn = _turnsBySession.get(clean(handle.ownerSessionId));
+  if (!turn || turn.generation !== handle.generation) return false;
+  const patch = mergePatches(patches);
+  if (!patch) return false;
+  const key = clean(handle.sessionId) || handle.id;
+  const prior = turn.agents.get(key);
+  turn.agents.set(key, {
+    sessionId: key,
+    agent: handle.agent || prior?.agent || null,
+    tag: handle.tag || prior?.tag || null,
+    patch: mergePatches([prior?.patch, patch]),
+  });
+  return true;
 }
 
-/** 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 };
+/** Return only attributed child reviews; Lead review is transcript-derived. */
+export async function getTurnReviewDiff(_worktree, sessionId) {
+  if (DISABLED) return { supported: false, files: [], patch: '', agents: [] };
+  const ownerSessionId = clean(sessionId);
+  const turn = _turnsBySession.get(ownerSessionId);
+  return {
+    supported: true,
+    files: [],
+    patch: '',
+    agents: publicAgentReviews(ownerSessionId),
+    ...(turn ? { generation: turn.generation } : { reason: 'no-turn' }),
+  };
 }
 
 export function _resetTurnSnapshotForTest() {
-  _queues.clear();
-  _baseBySession.clear();
-  _failedUntil.clear();
+  _turnsBySession.clear();
+  _agentTurnSeq = 0;
 }

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

@@ -1227,18 +1227,21 @@ export async function createMixdogSessionRuntime({
     const startedAt = performance.now();
     bootProfile('session:create:start', { mode, reason });
     const promise = (async () => {
+      // Demand-only: this starts only after the user submits (unless an
+      // explicitly enabled prewarm caller asks for a session). Core-memory
+      // startup does not depend on keychain/provider readiness, so overlap the
+      // two cold paths instead of paying their bounded waits serially.
+      const coreMemoryContextPromise = loadCoreMemoryContext();
       await awaitKeychainPrewarm();
       ensureConfigForRouteProvider();
       await resolveMissingRouteModelForFirstTurn();
       requireModelRoute();
       bootProfile('session:create:route-ready', { ms: (performance.now() - startedAt).toFixed(1) });
-      // refreshRouteEffort (effort/model-meta) and loadCoreMemoryContext (memory
-      // files) are independent — refreshRouteEffort only touches route effort/
-      // display fields, never provider/model that the memory load reads — so run
-      // them concurrently instead of serially on the boot path.
+      // Route effort waits on provider readiness while the already-started
+      // memory load continues independently.
       const [, coreMemoryContext] = await Promise.all([
         refreshRouteEffort(),
-        loadCoreMemoryContext(),
+        coreMemoryContextPromise,
       ]);
       bootProfile('session:create:effort-ready', { ms: (performance.now() - startedAt).toFixed(1) });
       const providerImpl = reg.getProvider(route.provider);
@@ -1846,8 +1849,8 @@ export async function createMixdogSessionRuntime({
     ...channelConfigApi,
     ...providerAuthApi,
     ...mediaApi,
-    // Turn-scoped worktree diff (shadow snapshot): everything changed since
-    // the current turn's base tree, regardless of which agent/process wrote it.
+    // Turn-scoped attributed review: child apply_patch diffs for this Lead turn.
+    // Lead patches are read from its transcript by the renderer.
     getTurnReviewDiff: () => getTurnSnapshotReviewDiff(currentCwd, session?.id),
     get id() {
       return session?.id || null;