mixdog 0.9.64 → 0.9.65

package/package.json

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

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/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/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/dist/index.mjs

@@ -23604,7 +23604,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false }) {
           StatusLine,
           {
             sessionId: state.sessionId,
-            clientHostPid: state.clientHostPid,
+            clientHostPid: state.ownerClientHostPid || state.clientHostPid,
             provider: state.provider,
             model: state.model,
             effort: state.effort,
@@ -28049,6 +28049,9 @@ function createEngineApiB(bag) {
     getUsageDashboard: async (options = {}) => {
       return await runtime.getUsageDashboard?.(options);
     },
+    getTurnReviewDiff: async () => {
+      return await runtime.getTurnReviewDiff?.() ?? { supported: false, files: [], patch: "" };
+    },
     getOnboardingStatus: () => {
       return runtime.getOnboardingStatus?.() || { completed: true, workflowRoutes: {} };
     },
@@ -29341,6 +29344,7 @@ function createLiveShare({
   getPublishedState,
   listeners,
   onRemoteSubmit,
+  onRemoteAbort,
   onOwnerClosed,
   viewerApply
 }) {
@@ -29351,6 +29355,7 @@ function createLiveShare({
   let lastItems = null;
   let lastTail = null;
   let lastSpinner = null;
+  let lastLiveSig = "";
   const broadcast = (frame) => {
     if (sockets.size === 0) return;
     const line = frameLine(frame);
@@ -29361,12 +29366,50 @@ function createLiveShare({
       }
     }
   };
+  const LIVE_STATS_KEYS = [
+    "currentContextSource",
+    "currentContextTokens",
+    "currentEstimatedContextTokens",
+    "currentContextUpdatedAt",
+    "costUsd",
+    "turns",
+    "inputTokens",
+    "outputTokens",
+    "latestInputTokens",
+    "latestPromptTokens",
+    "contextTokens"
+  ];
+  const liveStateOf = (st) => {
+    const stats = st.stats && typeof st.stats === "object" ? st.stats : {};
+    const statsSubset = {};
+    for (const key of LIVE_STATS_KEYS) {
+      if (stats[key] !== void 0) statsSubset[key] = stats[key];
+    }
+    return {
+      busy: st.busy === true,
+      commandBusy: st.commandBusy === true,
+      queued: (Array.isArray(st.queued) ? st.queued : []).map((entry) => ({
+        id: entry?.id,
+        text: String(entry?.displayText ?? entry?.text ?? entry?.message ?? "").slice(0, 2e3),
+        ...entry?.enqueuedAt ? { enqueuedAt: entry.enqueuedAt } : {}
+      })),
+      activeToolSummary: st.activeToolSummary || null,
+      agentWorkers: Array.isArray(st.agentWorkers) ? st.agentWorkers : [],
+      agentJobs: Array.isArray(st.agentJobs) ? st.agentJobs : [],
+      ownerClientHostPid: Number(st.clientHostPid) || process.pid,
+      displayContextWindow: Number(st.displayContextWindow) || 0,
+      compactBoundaryTokens: Number(st.compactBoundaryTokens) || 0,
+      autoCompactTokenLimit: Number(st.autoCompactTokenLimit) || 0,
+      stats: statsSubset
+    };
+  };
   const fullFrame = (st) => ({
     t: "full",
     sessionId: serverId,
     items: Array.isArray(st.items) ? st.items : [],
     tail: st.streamingTail || null,
-    spinner: st.spinner || null
+    spinner: st.spinner || null,
+    live: liveStateOf(st)
   });
   const onPublish = () => {
     const st = getPublishedState();
@@ -29374,6 +29417,7 @@ function createLiveShare({
       lastItems = st.items;
       lastTail = st.streamingTail;
       lastSpinner = st.spinner;
+      lastLiveSig = "";
       return;
     }
     const frame = { t: "delta" };
@@ -29432,6 +29476,13 @@ function createLiveShare({
       lastSpinner = st.spinner;
       dirty = true;
     }
+    const live = liveStateOf(st);
+    const liveSig = JSON.stringify(live);
+    if (liveSig !== lastLiveSig) {
+      frame.live = live;
+      lastLiveSig = liveSig;
+      dirty = true;
+    }
     if (dirty) broadcast(frame);
   };
   listeners.add(onPublish);
@@ -29480,6 +29531,8 @@ function createLiveShare({
       attachLineReader(socket, (frame) => {
         if (frame.t === "submit" && typeof frame.text === "string" && frame.text.trim()) {
           onRemoteSubmit(frame.text);
+        } else if (frame.t === "abort") {
+          onRemoteAbort?.();
         } else if (frame.t === "sync") {
           try {
             socket.write(frameLine(fullFrame(getPublishedState())));
@@ -29497,6 +29550,7 @@ function createLiveShare({
         lastItems = st.items;
         lastTail = st.streamingTail;
         lastSpinner = st.spinner;
+        lastLiveSig = JSON.stringify(liveStateOf(st));
         socket.write(frameLine(fullFrame(st)));
       } catch {
         try {
@@ -29582,11 +29636,47 @@ function createLiveShare({
     if (exists) viewerApply.patchItem(item.id, item);
     else viewerApply.appendItems([item]);
   };
+  const applyLiveState = (live) => {
+    if (!live || typeof live !== "object") return;
+    const patch = {
+      busy: live.busy === true,
+      commandBusy: live.commandBusy === true,
+      queued: Array.isArray(live.queued) ? live.queued : [],
+      activeToolSummary: live.activeToolSummary || null,
+      agentWorkers: Array.isArray(live.agentWorkers) ? live.agentWorkers : [],
+      agentJobs: Array.isArray(live.agentJobs) ? live.agentJobs : [],
+      ownerClientHostPid: Number(live.ownerClientHostPid) || 0
+    };
+    for (const key of ["displayContextWindow", "compactBoundaryTokens", "autoCompactTokenLimit"]) {
+      if (Number(live[key]) > 0) patch[key] = Number(live[key]);
+    }
+    if (live.stats && typeof live.stats === "object" && Object.keys(live.stats).length > 0) {
+      const current = viewerApply.getState().stats;
+      patch.stats = { ...current && typeof current === "object" ? current : {}, ...live.stats };
+    }
+    viewerApply.set(patch);
+  };
+  const clearMirroredLiveState = () => {
+    try {
+      viewerApply?.set?.({
+        busy: false,
+        commandBusy: false,
+        spinner: null,
+        queued: [],
+        activeToolSummary: null,
+        agentWorkers: [],
+        agentJobs: [],
+        ownerClientHostPid: 0
+      });
+    } catch {
+    }
+  };
   const applyViewerFrame = (frame, socket) => {
     if (frame.t === "full") {
       viewerApply.replaceItems(Array.isArray(frame.items) ? frame.items : []);
       if (frame.tail) viewerApply.updateStreamingTail(frame.tail.id, frame.tail);
       viewerApply.set({ spinner: frame.spinner || null });
+      applyLiveState(frame.live);
       return;
     }
     if (frame.t !== "delta") return;
@@ -29612,6 +29702,7 @@ function createLiveShare({
       else viewerApply.clearStreamingTail();
     }
     if ("spinner" in frame) viewerApply.set({ spinner: frame.spinner || null });
+    if ("live" in frame) applyLiveState(frame.live);
   };
   const stopClient = () => {
     const closing = client;
@@ -29654,6 +29745,7 @@ function createLiveShare({
         socket.destroy();
       } catch {
       }
+      if (wasUp) clearMirroredLiveState();
       if (wasUp) onOwnerClosed?.(id, ownerClosed);
     };
     socket.on("error", () => down(false));
@@ -29698,6 +29790,15 @@ function createLiveShare({
         return false;
       }
     },
+    sendAbort() {
+      if (!clientUp || !client) return false;
+      try {
+        client.write(frameLine({ t: "abort" }));
+        return true;
+      } catch {
+        return false;
+      }
+    },
     dispose() {
       listeners.delete(onPublish);
       stopServer();
@@ -30667,6 +30768,10 @@ async function createEngineSession({
   lifecycle.runtimePulseTimer = setInterval(() => {
     if (flags.disposed) return;
     if (flags.pendingSessionReset) return;
+    if (bag.liveShareMirroring?.()) {
+      set({ ...routeState() });
+      return;
+    }
     syncContextStats({ allowEstimated: true });
     set({
       ...routeState(),
@@ -30812,6 +30917,13 @@ async function createEngineSession({
       bag.enqueue(text);
       void bag.drain();
     },
+    onRemoteAbort: () => {
+      if (flags.disposed || state.sessionRemoteAttached) return;
+      try {
+        api.abort?.();
+      } catch {
+      }
+    },
     onOwnerClosed: (id) => {
       const timer2 = setTimeout(() => {
         if (flags.disposed || !state.sessionRemoteAttached) return;
@@ -30837,6 +30949,7 @@ async function createEngineSession({
     } catch {
     }
   };
+  bag.liveShareMirroring = () => state.sessionRemoteAttached && liveShare.viewerConnected();
   if (typeof api.submit === "function") {
     const baseSubmit = api.submit;
     api.submit = (prompt, options = {}) => {
@@ -30847,6 +30960,15 @@ async function createEngineSession({
       return baseSubmit(prompt, options);
     };
   }
+  if (typeof api.abort === "function") {
+    const baseAbort = api.abort;
+    api.abort = (...args) => {
+      if (state.sessionRemoteAttached && liveShare.viewerConnected() && liveShare.sendAbort()) {
+        return true;
+      }
+      return baseAbort(...args);
+    };
+  }
   const reconcileLiveShareNow = () => {
     try {
       liveShare.ensure();

package/src/tui/engine/live-share.mjs

@@ -62,6 +62,7 @@ export function createLiveShare({
   getPublishedState,
   listeners,
   onRemoteSubmit,
+  onRemoteAbort,
   onOwnerClosed,
   viewerApply,
 }) {
@@ -73,6 +74,7 @@ export function createLiveShare({
   let lastItems = null;
   let lastTail = null;
   let lastSpinner = null;
+  let lastLiveSig = '';
 
   const broadcast = (frame) => {
     if (sockets.size === 0) return;
@@ -82,12 +84,49 @@ export function createLiveShare({
     }
   };
 
+  // Live-state mirror (attach parity): the transcript alone left an attached
+  // viewer blind to the owner's activity — busy/stop state, the queued
+  // follow-up list, the Explore/Search summary, agent workers/jobs, and the
+  // context gauge stats all live in owner process state. Mirror a compact
+  // subset so viewer surfaces render them natively. queued entries are
+  // projected to display fields only (content parts may carry images).
+  const LIVE_STATS_KEYS = [
+    'currentContextSource', 'currentContextTokens', 'currentEstimatedContextTokens',
+    'currentContextUpdatedAt', 'costUsd', 'turns', 'inputTokens', 'outputTokens',
+    'latestInputTokens', 'latestPromptTokens', 'contextTokens',
+  ];
+  const liveStateOf = (st) => {
+    const stats = st.stats && typeof st.stats === 'object' ? st.stats : {};
+    const statsSubset = {};
+    for (const key of LIVE_STATS_KEYS) {
+      if (stats[key] !== undefined) statsSubset[key] = stats[key];
+    }
+    return {
+      busy: st.busy === true,
+      commandBusy: st.commandBusy === true,
+      queued: (Array.isArray(st.queued) ? st.queued : []).map((entry) => ({
+        id: entry?.id,
+        text: String(entry?.displayText ?? entry?.text ?? entry?.message ?? '').slice(0, 2000),
+        ...(entry?.enqueuedAt ? { enqueuedAt: entry.enqueuedAt } : {}),
+      })),
+      activeToolSummary: st.activeToolSummary || null,
+      agentWorkers: Array.isArray(st.agentWorkers) ? st.agentWorkers : [],
+      agentJobs: Array.isArray(st.agentJobs) ? st.agentJobs : [],
+      ownerClientHostPid: Number(st.clientHostPid) || process.pid,
+      displayContextWindow: Number(st.displayContextWindow) || 0,
+      compactBoundaryTokens: Number(st.compactBoundaryTokens) || 0,
+      autoCompactTokenLimit: Number(st.autoCompactTokenLimit) || 0,
+      stats: statsSubset,
+    };
+  };
+
   const fullFrame = (st) => ({
     t: 'full',
     sessionId: serverId,
     items: Array.isArray(st.items) ? st.items : [],
     tail: st.streamingTail || null,
     spinner: st.spinner || null,
+    live: liveStateOf(st),
   });
 
   // Runs on every frame-batched publish. With no viewers it only re-baselines
@@ -98,6 +137,7 @@ export function createLiveShare({
       lastItems = st.items;
       lastTail = st.streamingTail;
       lastSpinner = st.spinner;
+      lastLiveSig = '';
       return;
     }
     const frame = { t: 'delta' };
@@ -155,6 +195,13 @@ export function createLiveShare({
       lastSpinner = st.spinner;
       dirty = true;
     }
+    const live = liveStateOf(st);
+    const liveSig = JSON.stringify(live);
+    if (liveSig !== lastLiveSig) {
+      frame.live = live;
+      lastLiveSig = liveSig;
+      dirty = true;
+    }
     if (dirty) broadcast(frame);
   };
   listeners.add(onPublish);
@@ -190,6 +237,10 @@ export function createLiveShare({
       attachLineReader(socket, (frame) => {
         if (frame.t === 'submit' && typeof frame.text === 'string' && frame.text.trim()) {
           onRemoteSubmit(frame.text);
+        } else if (frame.t === 'abort') {
+          // Viewer stop button: interrupt the owner's active turn here — the
+          // viewer process has no turn of its own to cancel.
+          onRemoteAbort?.();
         } else if (frame.t === 'sync') {
           try { socket.write(frameLine(fullFrame(getPublishedState()))); } catch { /* close handles */ }
         }
@@ -199,6 +250,7 @@ export function createLiveShare({
         lastItems = st.items;
         lastTail = st.streamingTail;
         lastSpinner = st.spinner;
+        lastLiveSig = JSON.stringify(liveStateOf(st));
         socket.write(frameLine(fullFrame(st)));
       } catch {
         try { socket.destroy(); } catch { /* already gone */ }
@@ -275,11 +327,48 @@ export function createLiveShare({
     else viewerApply.appendItems([item]);
   };
 
+  // Mirror the owner's live-state subset into the viewer store. Context stats
+  // merge over the local stats object so unmirrored accumulator fields keep
+  // their last local values instead of vanishing.
+  const applyLiveState = (live) => {
+    if (!live || typeof live !== 'object') return;
+    const patch = {
+      busy: live.busy === true,
+      commandBusy: live.commandBusy === true,
+      queued: Array.isArray(live.queued) ? live.queued : [],
+      activeToolSummary: live.activeToolSummary || null,
+      agentWorkers: Array.isArray(live.agentWorkers) ? live.agentWorkers : [],
+      agentJobs: Array.isArray(live.agentJobs) ? live.agentJobs : [],
+      ownerClientHostPid: Number(live.ownerClientHostPid) || 0,
+    };
+    for (const key of ['displayContextWindow', 'compactBoundaryTokens', 'autoCompactTokenLimit']) {
+      if (Number(live[key]) > 0) patch[key] = Number(live[key]);
+    }
+    if (live.stats && typeof live.stats === 'object' && Object.keys(live.stats).length > 0) {
+      const current = viewerApply.getState().stats;
+      patch.stats = { ...(current && typeof current === 'object' ? current : {}), ...live.stats };
+    }
+    viewerApply.set(patch);
+  };
+
+  // Owner gone (clean close, crash, or pipe drop): the mirrored activity is
+  // no longer authoritative — clear it so the viewer never shows a frozen
+  // spinner/queue while the promotion path takes over.
+  const clearMirroredLiveState = () => {
+    try {
+      viewerApply?.set?.({
+        busy: false, commandBusy: false, spinner: null, queued: [],
+        activeToolSummary: null, agentWorkers: [], agentJobs: [], ownerClientHostPid: 0,
+      });
+    } catch { /* viewer store already disposed */ }
+  };
+
   const applyViewerFrame = (frame, socket) => {
     if (frame.t === 'full') {
       viewerApply.replaceItems(Array.isArray(frame.items) ? frame.items : []);
       if (frame.tail) viewerApply.updateStreamingTail(frame.tail.id, frame.tail);
       viewerApply.set({ spinner: frame.spinner || null });
+      applyLiveState(frame.live);
       return;
     }
     if (frame.t !== 'delta') return;
@@ -307,6 +396,7 @@ export function createLiveShare({
       else viewerApply.clearStreamingTail();
     }
     if ('spinner' in frame) viewerApply.set({ spinner: frame.spinner || null });
+    if ('live' in frame) applyLiveState(frame.live);
   };
 
   const stopClient = () => {
@@ -335,6 +425,7 @@ export function createLiveShare({
       const wasUp = clientUp && client === socket;
       if (client === socket) { client = null; clientId = ''; clientUp = false; }
       try { socket.destroy(); } catch { /* already gone */ }
+      if (wasUp) clearMirroredLiveState();
       // A live link that dropped means the owner ended or crashed: nudge the
       // promotion path instead of waiting for the next store-mtime change.
       if (wasUp) onOwnerClosed?.(id, ownerClosed);
@@ -381,6 +472,15 @@ export function createLiveShare({
         return false;
       }
     },
+    sendAbort() {
+      if (!clientUp || !client) return false;
+      try {
+        client.write(frameLine({ t: 'abort' }));
+        return true;
+      } catch {
+        return false;
+      }
+    },
     dispose() {
       listeners.delete(onPublish);
       stopServer();

package/src/tui/engine/session-api-ext.mjs

@@ -515,6 +515,9 @@ export function createEngineApiB(bag) {
     getUsageDashboard: async (options = {}) => {
       return await runtime.getUsageDashboard?.(options);
     },
+    getTurnReviewDiff: async () => {
+      return (await runtime.getTurnReviewDiff?.()) ?? { supported: false, files: [], patch: '' };
+    },
     getOnboardingStatus: () => {
       return runtime.getOnboardingStatus?.() || { completed: true, workflowRoutes: {} };
     },

package/src/tui/engine.mjs

@@ -695,6 +695,13 @@ export async function createEngineSession({
   lifecycle.runtimePulseTimer = setInterval(() => {
     if (flags.disposed) return;
     if (flags.pendingSessionReset) return;
+    // Attached viewer with a live pipe: the owner's frames are authoritative
+    // for stats/agent/tool state. Recomputing them locally here would stomp
+    // the mirror with this process's empty registries every 2s.
+    if (bag.liveShareMirroring?.()) {
+      set({ ...routeState() });
+      return;
+    }
     syncContextStats({ allowEstimated: true });
     set({
       ...routeState(),
@@ -822,6 +829,11 @@ export async function createEngineSession({
       bag.enqueue(text);
       void bag.drain();
     },
+    onRemoteAbort: () => {
+      // Forwarded viewer stop: interrupt OUR active turn (we are the owner).
+      if (flags.disposed || state.sessionRemoteAttached) return;
+      try { api.abort?.(); } catch { /* abort is best-effort */ }
+    },
     onOwnerClosed: (id) => {
       // Owner left (clean close or crash): promote via the normal quiet
       // re-resume once its final save/presence-clear has landed.
@@ -849,6 +861,9 @@ export async function createEngineSession({
   // resume() calls this right after installing the restored items so the
   // owner's full frame lands at the entry boundary instead of seconds later.
   bag.ensureLiveShare = () => { try { liveShare.ensure(); } catch { /* share tick retries */ } };
+  // Pulse guard: while this surface is an attached viewer with a live pipe,
+  // owner frames own stats/agent/tool state (see runtimePulseTimer above).
+  bag.liveShareMirroring = () => state.sessionRemoteAttached && liveShare.viewerConnected();
   // Live viewer submits ride the owner's pipe (instant user bubble + shared
   // streaming); the durable spool path below remains the fallback.
   if (typeof api.submit === 'function') {
@@ -861,6 +876,18 @@ export async function createEngineSession({
       return baseSubmit(prompt, options);
     };
   }
+  // Viewer stop button: the local engine has no in-flight turn to cancel —
+  // forward the interrupt to the owner over the pipe. Falls back to the local
+  // abort (no-op safe) when the pipe is down.
+  if (typeof api.abort === 'function') {
+    const baseAbort = api.abort;
+    api.abort = (...args) => {
+      if (state.sessionRemoteAttached && liveShare.viewerConnected() && liveShare.sendAbort()) {
+        return true;
+      }
+      return baseAbort(...args);
+    };
+  }
   // Attach-time pipe fast-path: session entry (resume) reconciles the live
   // pipe IMMEDIATELY instead of waiting for the 3s share tick. The attach
   // render comes from the last disk save WITHOUT the in-flight turn, so that