mixdog 0.9.82 → 0.9.83

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.82",
+  "version": "0.9.83",
   "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/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/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;

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

@@ -45,7 +45,17 @@ export function createSessionTurnApi(deps) {
     activeToolSurface, applyResolvedCwd, resolveCwdPath, agentStatusState, notificationListeners,
     awaitInitialMcpConnect,
   } = deps;
+  const enqueueRemoteAttachedPrompt = (prompt) => {
+    const attachedSession = getSession();
+    if (!attachedSession?.remoteAttached || !attachedSession.id) return false;
+    try {
+      return Number(mgr.enqueueRemotePendingMessage?.(attachedSession.id, prompt)) > 0;
+    } catch {
+      return false;
+    }
+  };
   return {
+    enqueueRemoteAttachedPrompt,
     getTurnLiveness() {
       const sessionId = getSession()?.id;
       if (!sessionId || typeof mgr.getSessionProgressSnapshot !== 'function') return null;
@@ -65,9 +75,12 @@ export function createSessionTurnApi(deps) {
       // a normal user turn and this surface refreshes from disk.
       const attachedSession = getSession();
       if (attachedSession?.remoteAttached) {
-        try { mgr.enqueueRemotePendingMessage?.(attachedSession.id, prompt); } catch { /* best-effort */ }
+        const delivered = enqueueRemoteAttachedPrompt(prompt);
         return {
-          result: { content: 'Delivered to the live owner of this session — the reply will appear here shortly.' },
+          // This branch is only a race-safe fallback for callers that reached
+          // ask() before the live pipe was ready. Never manufacture an
+          // assistant response: the owner's mirrored transcript is authoritative.
+          result: { content: '', remoteAttached: true, delivered },
           session: attachedSession,
         };
       }
@@ -108,11 +121,9 @@ 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.
+        // Turn-review boundary: start a fresh session+turn generation. Lead
+        // patches remain transcript-derived; worker apply_patch diffs bind to
+        // this generation and cannot leak into the next turn/session.
         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

package/src/standalone/agent-tool.mjs

@@ -59,6 +59,10 @@ import {
 } from './agent-tool/worker-rows.mjs';
 import { resolveAgentTerminalReapMs } from '../session-runtime/config-helpers.mjs';
 import { createWorkerIndex } from './agent-tool/worker-index.mjs';
+import {
+  beginAgentTurnReview,
+  completeAgentTurnReview,
+} from '../runtime/shared/turn-snapshot.mjs';
 // Re-export the static tool descriptor so importers of this facade keep the
 // identical public surface (`import { AGENT_TOOL } from './agent-tool.mjs'`).
 export { AGENT_TOOL };
@@ -91,6 +95,26 @@ export function createStandaloneAgent({
     if (typeof onSubagentEvent !== 'function') return;
     try { onSubagentEvent(phase, { agent_type: agent || null, ...extra }); } catch { /* best-effort */ }
   }
+  function createTurnReviewCollector(session, tag, agent, notifyContext = {}) {
+    const ownerSessionId = clean(
+      notifyContext?.callerSessionId
+      || notifyContext?.sessionId
+      || notifyContext?.routingSessionId
+      || session?.ownerSessionId,
+    );
+    const handle = beginAgentTurnReview(ownerSessionId, session?.id, { tag, agent });
+    const patches = [];
+    return {
+      onToolResult(message) {
+        if (typeof message?.uiDiff === 'string' && message.uiDiff.trim()) {
+          patches.push(message.uiDiff);
+        }
+      },
+      complete() {
+        completeAgentTurnReview(handle, patches);
+      },
+    };
+  }
   const tags = new Map();
   const tagAgents = new Map();
   const tagCwds = new Map();
@@ -869,6 +893,7 @@ export function createStandaloneAgent({
   async function runSpawn(prepared, notifyContext = null, job = null) {
     const { args, tag, session, agent, preset, presetName, workerCwd, prompt, watchdogPolicy } = prepared;
     const watchdog = startProgressIdleWatchdog(session.id, watchdogPolicy, agent);
+    const turnReview = createTurnReviewCollector(session, tag, agent, notifyContext || {});
     let finalStatus = 'idle';
     // SubagentStart: a worker session is about to run its first turn.
     emitSubagentEvent('start', agent, { session_id: session.id, tag });
@@ -907,8 +932,10 @@ export function createStandaloneAgent({
       handoffMsgStart = resolveHandoffMessageStartIndex(mgr.getSession(session.id));
       const result = await mgr.askSession(session.id, prompt, args.context || null, null, workerCwd, null, {
         notifyFn: workerNotifyFn(session.id, notifyContext || {}),
+        onToolResult: (message) => turnReview.onToolResult(message),
         ...(job ? {
           onTerminalResult: (terminalResult) => {
+            turnReview.complete();
             const value = completionValue(terminalResult);
             if (job) job._terminalResultValue = value;
             notifyOwnerAgentCompletionEarly(job, value, notifyContext || {});
@@ -999,6 +1026,7 @@ export function createStandaloneAgent({
       }
       throw error;
     } finally {
+      turnReview.complete();
       watchdog?.stop?.();
       upsertWorkerSessionDeferred(session, tag, {
         agent,
@@ -1056,6 +1084,7 @@ export function createStandaloneAgent({
     const sendAgent = session.agent || normalizeAgentName(args.agent);
     const watchdog = startProgressIdleWatchdog(sessionId, resolveAgentWatchdogPolicy(sendAgent), sendAgent);
     const tag = tagForSession(sessionId);
+    const turnReview = createTurnReviewCollector(session, tag, sendAgent, notifyContext || {});
     let finalStatus = 'idle';
     upsertWorkerSessionDeferred(session, tag, { status: 'running', stage: 'running' });
     let handoffMsgStart = 0;
@@ -1078,8 +1107,10 @@ export function createStandaloneAgent({
       handoffMsgStart = resolveHandoffMessageStartIndex(mgr.getSession(sessionId));
       const result = await mgr.askSession(sessionId, prompt, args.context || null, null, session.cwd || defaultCwd, null, {
         notifyFn: workerNotifyFn(sessionId, notifyContext || {}),
+        onToolResult: (message) => turnReview.onToolResult(message),
         ...(job ? {
           onTerminalResult: (terminalResult) => {
+            turnReview.complete();
             const value = completionValue(terminalResult);
             if (job) job._terminalResultValue = value;
             notifyOwnerAgentCompletionEarly(job, value, notifyContext || {});
@@ -1153,6 +1184,7 @@ export function createStandaloneAgent({
       }
       throw error;
     } finally {
+      turnReview.complete();
       watchdog?.stop?.();
       upsertWorkerSessionDeferred(session, tag, {
         status: finalStatus,

package/src/tui/dist/index.mjs

@@ -29555,6 +29555,8 @@ import { unlinkSync as unlinkSync4 } from "node:fs";
 var MAX_FRAME_PATCHES = 48;
 var MAX_BUFFER_BYTES = 8 * 1024 * 1024;
 var SYNC_REQUEST_MIN_INTERVAL_MS = 500;
+var LIVE_CONNECT_RETRY_MIN_MS = 10;
+var LIVE_CONNECT_RETRY_MAX_MS = 160;
 function liveSharePipePath(sessionId, sessionFilePath) {
   return process.platform === "win32" ? `\\\\.\\pipe\\mixdog-live-${sessionId}` : `${sessionFilePath}.live.sock`;
 }
@@ -29597,9 +29599,13 @@ function createLiveShare({
   onOwnerClosed,
   viewerApply
 }) {
+  let disposed = false;
   let server = null;
   let serverId = "";
   let serverPath = "";
+  let serverRetryTimer = null;
+  let serverRetryId = "";
+  let serverRetryDelayMs = LIVE_CONNECT_RETRY_MIN_MS;
   const sockets = /* @__PURE__ */ new Set();
   let lastItems = null;
   let lastTail = null;
@@ -29735,8 +29741,36 @@ function createLiveShare({
     if (dirty) broadcast(frame);
   };
   listeners.add(onPublish);
+  const clearServerRetry = () => {
+    if (serverRetryTimer) clearTimeout(serverRetryTimer);
+    serverRetryTimer = null;
+    serverRetryId = "";
+  };
+  const scheduleServerRetry = (id) => {
+    const target = String(id || "");
+    if (disposed || !target || server || serverRetryTimer || String(ownerSessionId() || "") !== target) return;
+    const delay2 = serverRetryDelayMs;
+    serverRetryDelayMs = Math.min(LIVE_CONNECT_RETRY_MAX_MS, Math.max(
+      LIVE_CONNECT_RETRY_MIN_MS,
+      serverRetryDelayMs * 2
+    ));
+    serverRetryId = target;
+    serverRetryTimer = setTimeout(() => {
+      serverRetryTimer = null;
+      serverRetryId = "";
+      if (disposed || server || String(ownerSessionId() || "") !== target) return;
+      startServer2(target);
+    }, delay2);
+    serverRetryTimer.unref?.();
+  };
   const stopServer = () => {
-    if (!server) return;
+    clearServerRetry();
+    serverRetryDelayMs = LIVE_CONNECT_RETRY_MIN_MS;
+    if (!server) {
+      serverId = "";
+      serverPath = "";
+      return;
+    }
     try {
       broadcast({ t: "close" });
     } catch {
@@ -29764,6 +29798,8 @@ function createLiveShare({
     serverPath = "";
   };
   const startServer2 = (id) => {
+    if (disposed || server || !id) return;
+    clearServerRetry();
     const path4 = socketPathFor(id);
     const next = createServer((socket) => {
       socket.setNoDelay?.(true);
@@ -29813,12 +29849,18 @@ function createLiveShare({
         server = null;
         serverId = "";
         serverPath = "";
+        scheduleServerRetry(id);
       }
       try {
         next.close();
       } catch {
       }
     });
+    next.on("listening", () => {
+      if (server !== next) return;
+      clearServerRetry();
+      serverRetryDelayMs = LIVE_CONNECT_RETRY_MIN_MS;
+    });
     if (process.platform !== "win32") {
       try {
         unlinkSync4(path4);
@@ -29834,6 +29876,7 @@ function createLiveShare({
       server = null;
       serverId = "";
       serverPath = "";
+      scheduleServerRetry(id);
     }
   };
   let client = null;
@@ -29841,15 +29884,19 @@ function createLiveShare({
   let clientUp = false;
   let clientSyncedId = "";
   let lastSyncRequestAt = 0;
+  let clientRetryTimer = null;
+  let clientRetryId = "";
+  let clientRetryDelayMs = LIVE_CONNECT_RETRY_MIN_MS;
   const viewerSyncWaiters = /* @__PURE__ */ new Set();
   const settleViewerSync = (id, synced) => {
     for (const waiter of [...viewerSyncWaiters]) {
       if (waiter.id === id) waiter.finish(synced);
     }
   };
-  const waitForViewerSync = (id, timeoutMs = 750) => {
+  const waitForViewerSync = (id, timeoutMs = 1500) => {
     const target = String(id || "");
     if (!target) return Promise.resolve(false);
+    ensureShare();
     if (clientUp && clientId === target && clientSyncedId === target) {
       return Promise.resolve(true);
     }
@@ -29920,6 +29967,28 @@ function createLiveShare({
     } catch {
     }
   };
+  const clearClientRetry = () => {
+    if (clientRetryTimer) clearTimeout(clientRetryTimer);
+    clientRetryTimer = null;
+    clientRetryId = "";
+  };
+  const scheduleClientRetry = (id) => {
+    const target = String(id || "");
+    if (disposed || !target || client || clientRetryTimer || String(viewerSessionId() || "") !== target) return;
+    const delay2 = clientRetryDelayMs;
+    clientRetryDelayMs = Math.min(LIVE_CONNECT_RETRY_MAX_MS, Math.max(
+      LIVE_CONNECT_RETRY_MIN_MS,
+      clientRetryDelayMs * 2
+    ));
+    clientRetryId = target;
+    clientRetryTimer = setTimeout(() => {
+      clientRetryTimer = null;
+      clientRetryId = "";
+      if (disposed || client || String(viewerSessionId() || "") !== target) return;
+      startClient(target);
+    }, delay2);
+    clientRetryTimer.unref?.();
+  };
   const applyViewerFrame = (frame, socket) => {
     if (frame.t === "full") {
       viewerApply.replaceItems(Array.isArray(frame.items) ? frame.items : []);
@@ -29954,6 +30023,8 @@ function createLiveShare({
     if ("live" in frame) applyLiveState(frame.live);
   };
   const stopClient = () => {
+    clearClientRetry();
+    clientRetryDelayMs = LIVE_CONNECT_RETRY_MIN_MS;
     const closing = client;
     const closingId = clientId;
     const wasUp = clientUp;
@@ -29971,10 +30042,13 @@ function createLiveShare({
     if (wasUp) clearMirroredLiveState();
   };
   const startClient = (id) => {
+    if (disposed || client || !id) return;
+    clearClientRetry();
     let socket;
     try {
       socket = connect(socketPathFor(id));
     } catch {
+      scheduleClientRetry(id);
       return;
     }
     client = socket;
@@ -29983,14 +30057,19 @@ function createLiveShare({
     clientSyncedId = "";
     socket.setNoDelay?.(true);
     socket.on("connect", () => {
-      if (client === socket) clientUp = true;
+      if (client !== socket) return;
+      clientUp = true;
+      clearClientRetry();
+      clientRetryDelayMs = LIVE_CONNECT_RETRY_MIN_MS;
     });
     const down = (ownerClosed) => {
       const wasUp = clientUp && client === socket;
-      if (client === socket) {
+      const wasCurrent = client === socket;
+      if (wasCurrent) {
         client = null;
         clientId = "";
         clientUp = false;
+        clientSyncedId = "";
       }
       try {
         socket.destroy();
@@ -29998,6 +30077,7 @@ function createLiveShare({
       }
       if (wasUp) clearMirroredLiveState();
       if (wasUp) onOwnerClosed?.(id, ownerClosed);
+      if (wasCurrent) scheduleClientRetry(id);
     };
     socket.on("error", () => down(false));
     socket.on("close", () => down(false));
@@ -30019,17 +30099,21 @@ function createLiveShare({
       }
     }, () => down(false));
   };
+  const ensureShare = () => {
+    if (disposed) return;
+    const ownerId = String(ownerSessionId() || "");
+    const attachId = ownerId ? "" : String(viewerSessionId() || "");
+    if (serverRetryId && serverRetryId !== ownerId) clearServerRetry();
+    if (!ownerId && serverRetryTimer) clearServerRetry();
+    if (serverId && serverId !== ownerId) stopServer();
+    if (ownerId && !server && !serverRetryTimer) startServer2(ownerId);
+    if (clientRetryId && clientRetryId !== attachId) clearClientRetry();
+    if (!attachId && clientRetryTimer) clearClientRetry();
+    if (clientId && clientId !== attachId) stopClient();
+    if (attachId && !client && !clientRetryTimer) startClient(attachId);
+  };
   return {
-    // Reconciles both legs against the current session role; called from the
-    // engine share tick (also serves as the reconnect/retry cadence).
-    ensure() {
-      const ownerId = String(ownerSessionId() || "");
-      const attachId = ownerId ? "" : String(viewerSessionId() || "");
-      if (serverId && serverId !== ownerId) stopServer();
-      if (ownerId && !server) startServer2(ownerId);
-      if (clientId && clientId !== attachId) stopClient();
-      if (attachId && !client) startClient(attachId);
-    },
+    ensure: ensureShare,
     viewerConnected: () => clientUp,
     waitForViewerSync,
     sendSubmit(text) {
@@ -30051,9 +30135,11 @@ function createLiveShare({
       }
     },
     dispose() {
+      disposed = true;
       listeners.delete(onPublish);
       stopServer();
       stopClient();
+      for (const waiter of [...viewerSyncWaiters]) waiter.finish(false);
     }
   };
 }
@@ -31198,6 +31284,7 @@ async function createEngineSession({
       const timer2 = setTimeout(() => {
         if (flags.disposed || !state.sessionRemoteAttached) return;
         if (String(state.sessionId || "") !== id) return;
+        if (liveShare.viewerConnected()) return;
         void Promise.resolve(api.resume(id, { quiet: true })).catch(() => {
         });
       }, 1500);
@@ -31223,9 +31310,15 @@ async function createEngineSession({
   if (typeof api.submit === "function") {
     const baseSubmit = api.submit;
     api.submit = (prompt, options = {}) => {
-      if (state.sessionRemoteAttached && liveShare.viewerConnected()) {
+      if (state.sessionRemoteAttached) {
         const text = String(promptDisplayText(prompt, options) || "").trim();
+        if (!text) return false;
+        try {
+          liveShare.ensure();
+        } catch {
+        }
         if (text && liveShare.sendSubmit(text)) return true;
+        return runtime.enqueueRemoteAttachedPrompt?.(prompt) === true;
       }
       return baseSubmit(prompt, options);
     };
@@ -31258,6 +31351,7 @@ async function createEngineSession({
       return result;
     };
   }
+  reconcileLiveShareNow();
   let spoolWatcher = null;
   let spoolDebounce = null;
   try {

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

@@ -23,6 +23,11 @@ const MAX_BUFFER_BYTES = 8 * 1024 * 1024;
 // Desync-recovery `sync` requests are throttled so a corrupt stream cannot
 // make the owner serialize full transcripts every frame.
 const SYNC_REQUEST_MIN_INTERVAL_MS = 500;
+// Session entry is latency-sensitive: the owner pipe can be a few event-loop
+// turns behind the viewer resume. Retry locally instead of waiting for the
+// coarse 3s engine safety tick.
+const LIVE_CONNECT_RETRY_MIN_MS = 10;
+const LIVE_CONNECT_RETRY_MAX_MS = 160;
 
 export function liveSharePipePath(sessionId, sessionFilePath) {
   return process.platform === 'win32'
@@ -66,10 +71,14 @@ export function createLiveShare({
   onOwnerClosed,
   viewerApply,
 }) {
+  let disposed = false;
   // ---- owner: pipe server + delta publisher ----
   let server = null;
   let serverId = '';
   let serverPath = '';
+  let serverRetryTimer = null;
+  let serverRetryId = '';
+  let serverRetryDelayMs = LIVE_CONNECT_RETRY_MIN_MS;
   const sockets = new Set();
   let lastItems = null;
   let lastTail = null;
@@ -206,8 +215,38 @@ export function createLiveShare({
   };
   listeners.add(onPublish);
 
+  const clearServerRetry = () => {
+    if (serverRetryTimer) clearTimeout(serverRetryTimer);
+    serverRetryTimer = null;
+    serverRetryId = '';
+  };
+
+  const scheduleServerRetry = (id) => {
+    const target = String(id || '');
+    if (disposed || !target || server || serverRetryTimer || String(ownerSessionId() || '') !== target) return;
+    const delay = serverRetryDelayMs;
+    serverRetryDelayMs = Math.min(LIVE_CONNECT_RETRY_MAX_MS, Math.max(
+      LIVE_CONNECT_RETRY_MIN_MS,
+      serverRetryDelayMs * 2,
+    ));
+    serverRetryId = target;
+    serverRetryTimer = setTimeout(() => {
+      serverRetryTimer = null;
+      serverRetryId = '';
+      if (disposed || server || String(ownerSessionId() || '') !== target) return;
+      startServer(target);
+    }, delay);
+    serverRetryTimer.unref?.();
+  };
+
   const stopServer = () => {
-    if (!server) return;
+    clearServerRetry();
+    serverRetryDelayMs = LIVE_CONNECT_RETRY_MIN_MS;
+    if (!server) {
+      serverId = '';
+      serverPath = '';
+      return;
+    }
     try { broadcast({ t: 'close' }); } catch { /* sockets closing anyway */ }
     for (const socket of sockets) {
       try { socket.destroy(); } catch { /* already gone */ }
@@ -224,6 +263,8 @@ export function createLiveShare({
   };
 
   const startServer = (id) => {
+    if (disposed || server || !id) return;
+    clearServerRetry();
     const path = socketPathFor(id);
     const next = createServer((socket) => {
       socket.setNoDelay?.(true);
@@ -257,11 +298,21 @@ export function createLiveShare({
       }
     });
     next.on('error', () => {
-      // EADDRINUSE (another live owner) or a transient listen failure: give
-      // up quietly; the next ensure() tick retries.
-      if (server === next) { server = null; serverId = ''; serverPath = ''; }
+      // EADDRINUSE (another live owner) or a transient listen failure: retry
+      // with a short bounded backoff while this surface still owns the id.
+      if (server === next) {
+        server = null;
+        serverId = '';
+        serverPath = '';
+        scheduleServerRetry(id);
+      }
       try { next.close(); } catch { /* already closed */ }
     });
+    next.on('listening', () => {
+      if (server !== next) return;
+      clearServerRetry();
+      serverRetryDelayMs = LIVE_CONNECT_RETRY_MIN_MS;
+    });
     if (process.platform !== 'win32') {
       try { unlinkSync(path); } catch { /* no stale socket */ }
     }
@@ -272,6 +323,7 @@ export function createLiveShare({
       server = null;
       serverId = '';
       serverPath = '';
+      scheduleServerRetry(id);
     }
   };
 
@@ -281,6 +333,9 @@ export function createLiveShare({
   let clientUp = false;
   let clientSyncedId = '';
   let lastSyncRequestAt = 0;
+  let clientRetryTimer = null;
+  let clientRetryId = '';
+  let clientRetryDelayMs = LIVE_CONNECT_RETRY_MIN_MS;
   const viewerSyncWaiters = new Set();
 
   const settleViewerSync = (id, synced) => {
@@ -289,9 +344,10 @@ export function createLiveShare({
     }
   };
 
-  const waitForViewerSync = (id, timeoutMs = 750) => {
+  const waitForViewerSync = (id, timeoutMs = 1500) => {
     const target = String(id || '');
     if (!target) return Promise.resolve(false);
+    ensureShare();
     if (clientUp && clientId === target && clientSyncedId === target) {
       return Promise.resolve(true);
     }
@@ -363,6 +419,30 @@ export function createLiveShare({
     } catch { /* viewer store already disposed */ }
   };
 
+  const clearClientRetry = () => {
+    if (clientRetryTimer) clearTimeout(clientRetryTimer);
+    clientRetryTimer = null;
+    clientRetryId = '';
+  };
+
+  const scheduleClientRetry = (id) => {
+    const target = String(id || '');
+    if (disposed || !target || client || clientRetryTimer || String(viewerSessionId() || '') !== target) return;
+    const delay = clientRetryDelayMs;
+    clientRetryDelayMs = Math.min(LIVE_CONNECT_RETRY_MAX_MS, Math.max(
+      LIVE_CONNECT_RETRY_MIN_MS,
+      clientRetryDelayMs * 2,
+    ));
+    clientRetryId = target;
+    clientRetryTimer = setTimeout(() => {
+      clientRetryTimer = null;
+      clientRetryId = '';
+      if (disposed || client || String(viewerSessionId() || '') !== target) return;
+      startClient(target);
+    }, delay);
+    clientRetryTimer.unref?.();
+  };
+
   const applyViewerFrame = (frame, socket) => {
     if (frame.t === 'full') {
       viewerApply.replaceItems(Array.isArray(frame.items) ? frame.items : []);
@@ -400,6 +480,8 @@ export function createLiveShare({
   };
 
   const stopClient = () => {
+    clearClientRetry();
+    clientRetryDelayMs = LIVE_CONNECT_RETRY_MIN_MS;
     const closing = client;
     const closingId = clientId;
     const wasUp = clientUp;
@@ -422,22 +504,39 @@ export function createLiveShare({
   };
 
   const startClient = (id) => {
+    if (disposed || client || !id) return;
+    clearClientRetry();
     let socket;
-    try { socket = connect(socketPathFor(id)); } catch { return; }
+    try { socket = connect(socketPathFor(id)); } catch {
+      scheduleClientRetry(id);
+      return;
+    }
     client = socket;
     clientId = id;
     clientUp = false;
     clientSyncedId = '';
     socket.setNoDelay?.(true);
-    socket.on('connect', () => { if (client === socket) clientUp = true; });
+    socket.on('connect', () => {
+      if (client !== socket) return;
+      clientUp = true;
+      clearClientRetry();
+      clientRetryDelayMs = LIVE_CONNECT_RETRY_MIN_MS;
+    });
     const down = (ownerClosed) => {
       const wasUp = clientUp && client === socket;
-      if (client === socket) { client = null; clientId = ''; clientUp = false; }
+      const wasCurrent = client === socket;
+      if (wasCurrent) {
+        client = null;
+        clientId = '';
+        clientUp = false;
+        clientSyncedId = '';
+      }
       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);
+      if (wasCurrent) scheduleClientRetry(id);
     };
     socket.on('error', () => down(false));
     socket.on('close', () => down(false));
@@ -459,17 +558,25 @@ export function createLiveShare({
     }, () => down(false));
   };
 
+  // Reconciles both legs against the current session role. Failed pipe opens
+  // continue through the local retry timers; the engine's 3s call is only a
+  // safety net, never the normal connection cadence.
+  const ensureShare = () => {
+    if (disposed) return;
+    const ownerId = String(ownerSessionId() || '');
+    const attachId = ownerId ? '' : String(viewerSessionId() || '');
+    if (serverRetryId && serverRetryId !== ownerId) clearServerRetry();
+    if (!ownerId && serverRetryTimer) clearServerRetry();
+    if (serverId && serverId !== ownerId) stopServer();
+    if (ownerId && !server && !serverRetryTimer) startServer(ownerId);
+    if (clientRetryId && clientRetryId !== attachId) clearClientRetry();
+    if (!attachId && clientRetryTimer) clearClientRetry();
+    if (clientId && clientId !== attachId) stopClient();
+    if (attachId && !client && !clientRetryTimer) startClient(attachId);
+  };
+
   return {
-    // Reconciles both legs against the current session role; called from the
-    // engine share tick (also serves as the reconnect/retry cadence).
-    ensure() {
-      const ownerId = String(ownerSessionId() || '');
-      const attachId = ownerId ? '' : String(viewerSessionId() || '');
-      if (serverId && serverId !== ownerId) stopServer();
-      if (ownerId && !server) startServer(ownerId);
-      if (clientId && clientId !== attachId) stopClient();
-      if (attachId && !client) startClient(attachId);
-    },
+    ensure: ensureShare,
     viewerConnected: () => clientUp,
     waitForViewerSync,
     sendSubmit(text) {
@@ -491,9 +598,11 @@ export function createLiveShare({
       }
     },
     dispose() {
+      disposed = true;
       listeners.delete(onPublish);
       stopServer();
       stopClient();
+      for (const waiter of [...viewerSyncWaiters]) waiter.finish(false);
     },
   };
 }

package/src/tui/engine.mjs

@@ -899,6 +899,7 @@ export async function createEngineSession({
       const timer = setTimeout(() => {
         if (flags.disposed || !state.sessionRemoteAttached) return;
         if (String(state.sessionId || '') !== id) return;
+        if (liveShare.viewerConnected()) return;
         void Promise.resolve(api.resume(id, { quiet: true })).catch(() => { /* tick retries */ });
       }, 1500);
       timer.unref?.();
@@ -928,9 +929,16 @@ export async function createEngineSession({
   if (typeof api.submit === 'function') {
     const baseSubmit = api.submit;
     api.submit = (prompt, options = {}) => {
-      if (state.sessionRemoteAttached && liveShare.viewerConnected()) {
+      if (state.sessionRemoteAttached) {
         const text = String(promptDisplayText(prompt, options) || '').trim();
+        if (!text) return false;
+        // Reconcile first so a session that became attachable this event-loop
+        // turn uses the instant pipe path. If the pipe is still opening, write
+        // directly to the durable owner spool instead of starting a fake local
+        // turn that renders an error/synthetic assistant message.
+        try { liveShare.ensure(); } catch { /* durable fallback below */ }
         if (text && liveShare.sendSubmit(text)) return true;
+        return runtime.enqueueRemoteAttachedPrompt?.(prompt) === true;
       }
       return baseSubmit(prompt, options);
     };
@@ -973,6 +981,9 @@ export async function createEngineSession({
       return result;
     };
   }
+  // Cover engines whose runtime already has a session at construction time;
+  // do not wait for a lifecycle method or the 3s safety pulse to open the pipe.
+  reconcileLiveShareNow();
   // Instant input pickup: watch the shared pending spool so an attached
   // surface's fallback submit reaches this owner immediately instead of on
   // the 3s tick. Best-effort — the tick below remains the safety net.