mixdog 0.9.95 → 0.9.96

package/src/standalone/engine-daemon-client.mjs

@@ -13,7 +13,13 @@ import { fileURLToPath } from 'node:url';
 import {
   ENGINE_DAEMON_PROTOCOL,
 } from './engine-daemon-protocol.mjs';
-import { engineDaemonLocalBridge } from './engine-daemon-local-bridge.mjs';
+import {
+  createSessionProtocolClient,
+  SESSION_CONFIGURE_ACTIONS,
+  SESSION_CONFIGURE_ACTION_SET,
+  SESSION_READ_ACTIONS,
+  SESSION_READ_ACTION_SET,
+} from './session-protocol.mjs';
 
 function runtimeRoot() {
   return process.env.MIXDOG_RUNTIME_ROOT
@@ -34,8 +40,31 @@ function daemonEntry() {
 // Data calls and lifecycle control must never share a socket pool. A burst of
 // long /call requests can occupy every data socket; health/register/deregister
 // still need a reserved lane so a new terminal can always attach or recover.
-const daemonCallAgent = new http.Agent({ keepAlive: true, keepAliveMsecs: 5_000, maxSockets: 8 });
-const daemonControlAgent = new http.Agent({ keepAlive: true, keepAliveMsecs: 5_000, maxSockets: 4 });
+const daemonCallAgent = new http.Agent({
+  keepAlive: true, keepAliveMsecs: 5_000, maxSockets: 64, maxFreeSockets: 8,
+});
+const daemonUrgentAgent = new http.Agent({
+  keepAlive: true, keepAliveMsecs: 5_000, maxSockets: 8, maxFreeSockets: 2,
+});
+const daemonControlAgent = new http.Agent({
+  keepAlive: true, keepAliveMsecs: 5_000, maxSockets: 4, maxFreeSockets: 2,
+});
+const URGENT_CALLS = new Set([
+  'session.submit',
+  'session.abort',
+  'session.approve',
+  'session.unsubscribe',
+  'desktop.control',
+  'desktop.unsubscribe',
+]);
+const EVENT_STREAM_RECONNECT_BASE_MS = 100;
+const EVENT_STREAM_RECONNECT_MAX_MS = 1_000;
+const EVENT_STREAM_HEALTH_GRACE_MS = 750;
+// A daemon that restarted needs a moment to rebind its port, so one immediate
+// re-attach often lands in the same gap the first call died in. Mirror the
+// event-stream policy above with a short bounded ladder; `callId` keeps a
+// retried submit idempotent on the daemon side, so replaying is safe.
+const CALL_RECOVERY_BACKOFF_MS = Object.freeze([0, 150, 600]);
 
 function request({
   port,
@@ -45,6 +74,7 @@ function request({
   body = null,
   timeoutMs = 120_000,
   control = false,
+  urgent = false,
 }) {
   return new Promise((resolve, reject) => {
     const payload = body ? JSON.stringify(body) : null;
@@ -53,7 +83,7 @@ function request({
       port,
       path: urlPath,
       method,
-      agent: control ? daemonControlAgent : daemonCallAgent,
+      agent: control ? daemonControlAgent : urgent ? daemonUrgentAgent : daemonCallAgent,
       headers: {
         'X-Mixdog-Daemon-Token': token,
         ...(payload ? { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) } : {}),
@@ -221,6 +251,11 @@ export async function attachEngineDaemon({
   registrationId = randomUUID(),
   onFrame = () => {},
   onFatal = () => {},
+  onStreamDisconnect = () => {},
+  onStreamReconnect = () => {},
+  streamReconnectBaseMs = EVENT_STREAM_RECONNECT_BASE_MS,
+  streamReconnectMaxMs = EVENT_STREAM_RECONNECT_MAX_MS,
+  streamReconnectHealthGraceMs = EVENT_STREAM_HEALTH_GRACE_MS,
   log = () => {},
 } = {}) {
   if (!discovery?.port || !discovery?.token) throw new Error('daemon discovery {port, token} required');
@@ -254,9 +289,62 @@ export async function attachEngineDaemon({
 
   let closed = false;
   let streamRequest = null;
+  let reconnectTimer = null;
+  let reconnectAttempt = 0;
+  let disconnectedAt = 0;
+  let lastLossReason = '';
+  let streamWasReady = false;
+  let fatalSignalled = false;
+  const reconnectBaseMs = Math.max(1, Number(streamReconnectBaseMs) || EVENT_STREAM_RECONNECT_BASE_MS);
+  const reconnectMaxMs = Math.max(
+    reconnectBaseMs,
+    Number(streamReconnectMaxMs) || EVENT_STREAM_RECONNECT_MAX_MS,
+  );
+  const healthGraceMs = Math.max(
+    reconnectBaseMs,
+    Number(streamReconnectHealthGraceMs) || EVENT_STREAM_HEALTH_GRACE_MS,
+  );
+
+  function signalFatal(reason) {
+    if (closed || fatalSignalled) return;
+    fatalSignalled = true;
+    if (reconnectTimer) clearTimeout(reconnectTimer);
+    reconnectTimer = null;
+    try { onFatal(reason); } catch {}
+  }
+
+  function scheduleStreamReconnect(reason) {
+    if (closed || fatalSignalled || reconnectTimer) return;
+    const now = Date.now();
+    if (!disconnectedAt) {
+      disconnectedAt = now;
+      lastLossReason = String(reason || 'sse disconnected');
+      try { onStreamDisconnect({ reason: lastLossReason }); } catch {}
+    }
+    const attempt = reconnectAttempt + 1;
+    reconnectAttempt = attempt;
+    const delayMs = Math.min(reconnectMaxMs, reconnectBaseMs * (2 ** Math.min(attempt - 1, 8)));
+    log(`engine daemon event stream reconnecting attempt=${attempt} delayMs=${delayMs} reason=${lastLossReason}`);
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      void (async () => {
+        if (closed || fatalSignalled) return;
+        const downtimeMs = Math.max(0, Date.now() - disconnectedAt);
+        if (downtimeMs >= healthGraceMs) {
+          const health = await probeEngineDaemonHealth({ port, token: serverToken, timeoutMs: 500 });
+          if (!health || Number(health.pid) !== Number(discovery.pid)) {
+            signalFatal(`${lastLossReason}; daemon unavailable or replaced`);
+            return;
+          }
+        }
+        openStream();
+      })().catch(() => signalFatal(`${lastLossReason}; daemon health check failed`));
+    }, delayMs);
+    reconnectTimer.unref?.();
+  }
 
   function openStream() {
-    if (closed) return;
+    if (closed || fatalSignalled || streamRequest) return;
     const req = http.request({
       hostname: '127.0.0.1',
       port,
@@ -267,9 +355,24 @@ export async function attachEngineDaemon({
       if (req !== streamRequest || closed) { res.resume(); return; }
       if (res.statusCode !== 200) {
         res.resume();
-        if (!closed) { try { onFatal(`bad sse status ${res.statusCode}`); } catch {} }
+        streamRequest = null;
+        if (res.statusCode === 401 || res.statusCode === 403 || res.statusCode === 404) {
+          signalFatal(`bad sse status ${res.statusCode}`);
+        } else {
+          scheduleStreamReconnect(`bad sse status ${res.statusCode}`);
+        }
         return;
       }
+      const reconnected = streamWasReady && disconnectedAt > 0;
+      const reconnectInfo = reconnected ? {
+        reason: lastLossReason,
+        attempt: reconnectAttempt,
+        downtimeMs: Math.max(0, Date.now() - disconnectedAt),
+      } : null;
+      streamWasReady = true;
+      reconnectAttempt = 0;
+      disconnectedAt = 0;
+      lastLossReason = '';
       res.setEncoding('utf8');
       let buffer = '';
       res.on('data', (chunk) => {
@@ -289,14 +392,31 @@ export async function attachEngineDaemon({
           }
         }
       });
+      let lossHandled = false;
       const lost = (reason) => {
         if (req !== streamRequest || closed) return;
-        try { onFatal(reason); } catch {}
+        if (lossHandled) return;
+        lossHandled = true;
+        streamRequest = null;
+        scheduleStreamReconnect(reason);
       };
       res.on('end', () => lost('sse ended'));
       res.on('error', () => lost('sse error'));
+      res.on('aborted', () => lost('sse aborted'));
+      res.on('close', () => lost('sse closed'));
+      if (reconnectInfo) {
+        log(
+          `engine daemon event stream reconnected attempt=${reconnectInfo.attempt}`
+          + ` downtimeMs=${reconnectInfo.downtimeMs}`,
+        );
+        try { onStreamReconnect(reconnectInfo); } catch {}
+      }
+    });
+    req.on('error', () => {
+      if (req !== streamRequest || closed) return;
+      streamRequest = null;
+      scheduleStreamReconnect('sse request error');
     });
-    req.on('error', () => { if (req === streamRequest && !closed) { try { onFatal('sse request error'); } catch {} } });
     streamRequest = req;
     req.end();
   }
@@ -309,6 +429,7 @@ export async function attachEngineDaemon({
         port, token: serverToken, method: 'POST', path: '/call',
         body: { token: clientToken, name, args: args || {}, ...(callId ? { callId } : {}) },
         timeoutMs,
+        urgent: URGENT_CALLS.has(name),
       });
     } catch (err) {
       // Transport death (daemon restarted/unreachable) is recoverable by
@@ -323,6 +444,8 @@ export async function attachEngineDaemon({
   async function close(reason = 'client close') {
     if (closed) return;
     closed = true;
+    if (reconnectTimer) clearTimeout(reconnectTimer);
+    reconnectTimer = null;
     try { streamRequest?.destroy?.(); } catch {}
     try {
       await request({
@@ -401,12 +524,7 @@ async function ensureSharedAttachment({ cwd, log }) {
   if (shared?.client) return shared;
   if (shared?.pending) return shared.pending;
   const pending = (async () => {
-    const localBridge = process.env.MIXDOG_ENGINE_DAEMON_HOST === '1'
-      ? engineDaemonLocalBridge()
-      : null;
-    const discovery = localBridge
-      ? { pid: process.pid, local: true }
-      : await ensureEngineDaemon({ cwd, log });
+    const discovery = await ensureEngineDaemon({ cwd, log });
     const views = new Map();
     const state = { client: null, views, discovery, refs: liveViews.size, log, cwd };
     const attachmentOptions = {
@@ -416,7 +534,7 @@ async function ensureSharedAttachment({ cwd, log }) {
         const bucket = views.get(String(frame?.sessionId || ''));
         if (!bucket) return;
         for (const view of [...bucket]) {
-          if (frame.type === 'session-state') view.applyFrame(frame);
+          if (frame.type === 'session-state') view.applyFrame(frame, state);
           else if (frame.type === 'session-gone') view.applyGone(frame.reason || 'session unloaded');
         }
       },
@@ -429,9 +547,8 @@ async function ensureSharedAttachment({ cwd, log }) {
         scheduleReattach({ cwd: state.cwd, log });
       },
     };
-    state.client = localBridge
-      ? await localBridge.attach(attachmentOptions)
-      : await attachEngineDaemon({ discovery, ...attachmentOptions });
+    const rawTransport = await attachEngineDaemon({ discovery, ...attachmentOptions });
+    state.client = createSessionProtocolClient(rawTransport);
     shared = state;
     for (const view of liveViews) {
       addSessionView(views, view.sessionId(), view);
@@ -450,11 +567,6 @@ async function ensureSharedAttachment({ cwd, log }) {
   }
 }
 
-const LOCAL_ENGINE_KEYS = new Set([
-  'getState', 'subscribe', 'dispose', 'isRemoteEngine', 'disposedView',
-  'then', 'catch', 'finally', 'toJSON', 'inspect', Symbol.toStringTag,
-]);
-
 /** Remote counterpart of createEngineSession(): this is a session projection,
  *  while execution and durable intake stay in the backend daemon. */
 export async function createRemoteEngineSession(options = {}) {
@@ -469,16 +581,24 @@ export async function createRemoteEngineSession(options = {}) {
     desktopSession: options.desktopSession ?? null,
   };
   let attachment = await ensureSharedAttachment({ cwd, log });
-  const created = await attachment.client.call('session.create', openParams, {
+  const created = await attachment.client.create(openParams, {
     callId: `session-create:${process.pid}:${randomUUID()}`,
   });
   let sessionId = String(created?.sessionId || '');
   if (!sessionId) throw new Error('session.create returned no sessionId');
   let state = created?.full ?? {};
   let revision = Number(created?.revision) || 0;
-  let sync = created?.sync ?? {};
+  // A revision belongs to one session projection on one daemon attachment. It
+  // detects a missing patch on that stream; it is not session history and
+  // never crosses a session rebind or daemon restart. This mirrors Codex
+  // thread/resume: seed a full thread snapshot, then consume notifications
+  // from the newly attached listener.
+  let revisionAttachment = attachment;
+  let revisionSessionId = sessionId;
+  let reservedOnly = created?.reservedOnly === true;
   let disposed = false;
   const listeners = new Set();
+  const resultAttachments = new WeakMap();
 
   function emit() {
     for (const listener of [...listeners]) {
@@ -486,11 +606,29 @@ export async function createRemoteEngineSession(options = {}) {
     }
   }
 
-  function applyBody(body) {
+  function applyBody(body, sourceAttachment = resultAttachments.get(body) || attachment) {
     if (disposed || !body) return false;
+    // A response from the dead attachment may finish after recovery. It cannot
+    // repaint the session that is now subscribed to a replacement daemon.
+    if (sourceAttachment !== attachment) return true;
+    if (Object.hasOwn(body, 'reservedOnly')) reservedOnly = body.reservedOnly === true;
+    const incomingRevision = Number(body.revision);
+    if (revisionAttachment !== sourceAttachment || revisionSessionId !== sessionId) {
+      // A fresh attachment/session projection has no patch baseline. Only its
+      // authoritative full snapshot may establish the new epoch; numeric
+      // revisions from another projection are deliberately incomparable.
+      if (body.full === undefined || body.full === null) return false;
+      state = body.full;
+      revision = Number.isFinite(incomingRevision) ? incomingRevision : 0;
+      revisionAttachment = sourceAttachment;
+      revisionSessionId = sessionId;
+      emit();
+      return true;
+    }
+    if (Number.isFinite(incomingRevision) && incomingRevision < revision) return true;
     if (body.full !== undefined && body.full !== null) {
       state = body.full;
-      revision = Number(body.revision) || revision;
+      revision = Number.isFinite(incomingRevision) ? incomingRevision : revision;
       emit();
       return true;
     }
@@ -514,16 +652,28 @@ export async function createRemoteEngineSession(options = {}) {
     return false;
   }
 
+  function baseRevisionFor(
+    sourceAttachment = attachment,
+    targetSessionId = sessionId,
+  ) {
+    return revisionAttachment === sourceAttachment && revisionSessionId === targetSessionId
+      ? revision
+      : null;
+  }
+
   let resyncing = false;
   function resync(reason) {
     if (disposed || resyncing) return;
     resyncing = true;
-    void attachment.client.call('session.read', {
-      sessionId, open: openParams, baseRevision: revision,
+    const requestAttachment = attachment;
+    void requestAttachment.client.read({
+      sessionId,
+      open: openParams,
+      baseRevision: baseRevisionFor(requestAttachment),
     }).then((result) => {
-      if (disposed) return;
-      if (result?.sync) sync = result.sync;
-      if (!applyBody(result) && result?.revision !== undefined) {
+      if (disposed || requestAttachment !== attachment) return;
+      if (result && typeof result === 'object') resultAttachments.set(result, requestAttachment);
+      if (!applyBody(result, requestAttachment) && result?.revision !== undefined) {
         log(`session ${sessionId} resync returned an unusable body`);
       }
     }).catch((err) => {
@@ -542,19 +692,49 @@ export async function createRemoteEngineSession(options = {}) {
         removeSessionView(previousAttachment.views, sessionId, view);
         attachment = nextAttachment;
       }
+      const recoveryAttachment = attachment;
+      // Route notifications before asking the daemon to subscribe. The
+      // session.subscribe response is the full baseline; frames racing after
+      // server-side subscription are either full themselves or trigger a
+      // baseline read, never disappear between the response and local wiring.
+      addSessionView(recoveryAttachment.views, sessionId, view);
+      revisionAttachment = null;
+      revisionSessionId = '';
       let result;
       try {
-        result = await attachment.client.call('session.subscribe', {
-          sessionId, open: openParams, baseRevision: revision,
+        result = await recoveryAttachment.client.subscribe({
+          sessionId, open: openParams, baseRevision: null,
+        });
+      } catch (error) {
+        // A reserved New task has no durable transcript until its first
+        // accepted submit. If the daemon dies before then, recreate the same
+        // durable address instead of silently switching the pane to another
+        // session. A submitted session always retries subscribe first so an
+        // accepted-but-unacknowledged prompt can never be shadowed.
+        if (!reservedOnly || !/session .* is not available/i.test(String(error?.message || error))) {
+          throw error;
+        }
+        result = await recoveryAttachment.client.create({
+          ...openParams,
+          sessionId,
+        }, {
+          callId: `session-recover-reservation:${sessionId}`,
         });
-      } catch {
-        result = await attachment.client.call('session.create', {
-          ...openParams, sessionId,
-        }, { callId: `session-recreate:${sessionId}` });
       }
-      addSessionView(attachment.views, sessionId, view);
-      if (result?.sync) sync = result.sync;
-      if (!applyBody(result) && result?.revision !== undefined) resync('recovery body gap');
+      if (disposed || recoveryAttachment !== attachment) return;
+      if (result && typeof result === 'object') resultAttachments.set(result, recoveryAttachment);
+      if (!applyBody(result, recoveryAttachment)) {
+        const baseline = await recoveryAttachment.client.read({
+          sessionId, open: openParams, baseRevision: null,
+        });
+        if (disposed || recoveryAttachment !== attachment) return;
+        if (baseline && typeof baseline === 'object') {
+          resultAttachments.set(baseline, recoveryAttachment);
+        }
+        if (!applyBody(baseline, recoveryAttachment)) {
+          throw new Error(`session ${sessionId} recovery returned no full snapshot`);
+        }
+      }
       log(`session ${sessionId} projection recovered`);
     })();
     try {
@@ -566,15 +746,13 @@ export async function createRemoteEngineSession(options = {}) {
 
   view = {
     sessionId: () => sessionId,
-    applyFrame(frame) {
+    applyFrame(frame, sourceAttachment = attachment) {
       if (disposed) return;
-      if (!applyBody(frame)) resync('revision gap');
+      if (!applyBody(frame, sourceAttachment)) resync('revision gap');
     },
     applyGone(reason) {
       if (disposed) return;
-      void recover(attachment).catch((err) => {
-        log(`session ${sessionId} reload after ${reason} failed: ${err?.message || err}`);
-      });
+      log(`session ${sessionId} is no longer available (${reason})`);
     },
     applyDetached(reason) {
       log(`session ${sessionId} projection detached (${reason})`);
@@ -586,21 +764,51 @@ export async function createRemoteEngineSession(options = {}) {
   liveViews.add(view);
 
   async function sendCall(route, payload, callId) {
-    const send = () => attachment.client.call(route, payload, { callId });
-    try {
-      return await send();
-    } catch (err) {
-      const recoverable = err?.daemonTransportError
-        || /unknown client token/i.test(String(err?.message || ''));
-      if (!recoverable || disposed) throw err;
-      if (shared === attachment) shared = null;
-      const next = await ensureSharedAttachment({ cwd, log });
-      await recover(next);
-      return await send();
+    const send = async () => {
+      const sourceAttachment = attachment;
+      let result;
+      if (route === 'session.create') result = await sourceAttachment.client.create(payload, { callId });
+      else if (route === 'session.read') result = await sourceAttachment.client.read(payload, { callId });
+      else if (route === 'session.subscribe') result = await sourceAttachment.client.subscribe(payload, { callId });
+      else if (route === 'session.submit') result = await sourceAttachment.client.submit(payload, { callId });
+      else if (route === 'session.abort') result = await sourceAttachment.client.abort(payload, { callId });
+      else if (route === 'session.approve') result = await sourceAttachment.client.approve(payload, { callId });
+      else if (route === 'session.configure') result = await sourceAttachment.client.configure(payload, { callId });
+      else if (route === 'project.list') result = await sourceAttachment.client.projectList(payload, { callId });
+      else if (route === 'project.inspect') result = await sourceAttachment.client.projectInspect(payload, { callId });
+      else if (route === 'project.add') result = await sourceAttachment.client.projectAdd(payload, { callId });
+      else if (route === 'project.touch') result = await sourceAttachment.client.projectTouch(payload, { callId });
+      else if (route === 'project.rename') result = await sourceAttachment.client.projectRename(payload, { callId });
+      else if (route === 'project.remove') result = await sourceAttachment.client.projectRemove(payload, { callId });
+      else if (route === 'project.ensureDirectory') {
+        result = await sourceAttachment.client.projectEnsureDirectory(payload, { callId });
+      }
+      else throw new TypeError(`session route ${route} is unavailable`);
+      if (result && typeof result === 'object') {
+        resultAttachments.set(result, sourceAttachment);
+      }
+      return result;
+    };
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        return await send();
+      } catch (err) {
+        const recoverable = err?.daemonTransportError
+          || /unknown client token/i.test(String(err?.message || ''));
+        if (!recoverable || disposed || attempt >= CALL_RECOVERY_BACKOFF_MS.length) throw err;
+        const waitMs = CALL_RECOVERY_BACKOFF_MS[attempt];
+        if (waitMs > 0) await new Promise((resolve) => { setTimeout(resolve, waitMs); });
+        if (disposed) throw err;
+        if (shared === attachment) shared = null;
+        const next = await ensureSharedAttachment({ cwd, log });
+        await recover(next);
+        if (attempt > 0) log(`session ${sessionId} call ${route} re-attached (attempt ${attempt + 1})`);
+      }
     }
   }
 
   async function applyResult(result, reason) {
+    const sourceAttachment = resultAttachments.get(result) || attachment;
     const nextSessionId = String(result?.sessionId || sessionId);
     if (nextSessionId && nextSessionId !== sessionId) {
       const previousSessionId = sessionId;
@@ -608,42 +816,44 @@ export async function createRemoteEngineSession(options = {}) {
       removeSessionView(attachment.views, previousSessionId, view);
       sessionId = nextSessionId;
     }
-    if (result?.sync) sync = result.sync;
-    if (!applyBody(result) && result?.revision !== undefined) resync(`${reason} body gap`);
+    if (!applyBody(result, sourceAttachment) && result?.revision !== undefined) {
+      resync(`${reason} body gap`);
+    }
     return result;
   }
 
-  let callChain = Promise.resolve();
-  function serialize(task) {
-    const run = callChain.then(task);
-    callChain = run.then(() => {}, () => {});
+  let transitionChain = Promise.resolve();
+  function serializeTransition(task) {
+    const run = transitionChain.then(task);
+    transitionChain = run.then(() => {}, () => {});
     return run;
   }
 
   function remoteCall(method, args, callOptions = {}) {
-    return serialize(async () => {
-      if (disposed) throw new Error('This session view is disposed.');
-      const stableCallId = typeof callOptions.callId === 'string' && callOptions.callId.trim()
-        ? callOptions.callId.trim()
-        : randomUUID();
-      const result = await sendCall('session.invoke', {
-        sessionId,
-        method,
-        args,
-        open: openParams,
-        baseRevision: revision,
-      }, stableCallId);
-      await applyResult(result, method);
+    if (disposed) return Promise.reject(new Error('This session view is disposed.'));
+    const route = SESSION_READ_ACTION_SET.has(method)
+      ? 'session.read'
+      : SESSION_CONFIGURE_ACTION_SET.has(method)
+        ? 'session.configure'
+        : null;
+    if (!route) return Promise.reject(new TypeError(`session action ${method} is unavailable`));
+    const targetSessionId = sessionId;
+    const baseRevision = baseRevisionFor(attachment, targetSessionId);
+    const stableCallId = typeof callOptions.callId === 'string' && callOptions.callId.trim()
+      ? callOptions.callId.trim()
+      : randomUUID();
+    return sendCall(route, {
+      sessionId: targetSessionId,
+      action: method,
+      args,
+      open: openParams,
+      baseRevision,
+    }, stableCallId).then(async (result) => {
+      if (!disposed && sessionId === targetSessionId) await applyResult(result, method);
       return result?.value ?? null;
     });
   }
 
-  function dispatch(method, args) {
-    void remoteCall(method, args).catch((err) => {
-      log(`session ${method} failed: ${err?.message || err}`);
-    });
-  }
-
   async function rebindTo(result, previousSessionId) {
     const nextSessionId = String(result?.sessionId || '');
     if (!nextSessionId) throw new Error('session route returned no sessionId');
@@ -651,11 +861,10 @@ export async function createRemoteEngineSession(options = {}) {
     addSessionView(attachment.views, nextSessionId, view);
     removeSessionView(attachment.views, previousSessionId, view);
     sessionId = nextSessionId;
-    if (result?.sync) sync = result.sync;
     if (!applyBody(result) && result?.revision !== undefined) resync('session rebind body gap');
     if (previousSessionId && previousSessionId !== nextSessionId && lastLocalView) {
       try {
-        await attachment.client.call('session.unsubscribe', { sessionId: previousSessionId });
+        await attachment.client.unsubscribe({ sessionId: previousSessionId });
       } catch (err) {
         log(`session ${previousSessionId} unsubscribe failed: ${err?.message || err}`);
       }
@@ -664,7 +873,7 @@ export async function createRemoteEngineSession(options = {}) {
   }
 
   async function createReservedSession() {
-    return serialize(async () => {
+    return serializeTransition(async () => {
       if (disposed) throw new Error('This session view is disposed.');
       const previousSessionId = sessionId;
       const result = await sendCall('session.create', openParams,
@@ -676,11 +885,13 @@ export async function createRemoteEngineSession(options = {}) {
   async function resumeSession(targetSessionId, resumeOptions) {
     const target = String(targetSessionId || '');
     if (!target) return false;
-    return serialize(async () => {
+    return serializeTransition(async () => {
       if (disposed) throw new Error('This session view is disposed.');
       if (target === sessionId) {
         const result = await sendCall('session.read', {
-          sessionId, open: openParams, baseRevision: revision,
+          sessionId,
+          open: openParams,
+          baseRevision: baseRevisionFor(),
         }, randomUUID());
         await applyResult(result, 'resume');
         return true;
@@ -701,17 +912,26 @@ export async function createRemoteEngineSession(options = {}) {
     if (disposed) throw new Error('This session view is disposed.');
     const submissionId = String(options?.id || '').trim()
       || `session-submit-${process.pid}-${Date.now()}-${(submitSeq += 1)}`;
-    return serialize(async () => {
-      const result = await sendCall('session.submit', {
-        sessionId,
-        prompt,
-        options: { ...(options || {}), id: submissionId },
-        open: openParams,
-        baseRevision: revision,
-      }, `session-submit:${sessionId}:${submissionId}`);
-      await applyResult(result, 'submit');
-      return result?.accepted === true;
-    });
+    const targetSessionId = sessionId;
+    const baseRevision = baseRevisionFor(attachment, targetSessionId);
+    const result = await sendCall('session.submit', {
+      sessionId: targetSessionId,
+      prompt,
+      options: { ...(options || {}), id: submissionId },
+      open: openParams,
+      baseRevision,
+    }, `session-submit:${targetSessionId}:${submissionId}`);
+    if (!disposed && sessionId === targetSessionId) await applyResult(result, 'submit');
+    return result?.accepted === true;
+  }
+
+  async function abortAsync(options = {}) {
+    if (disposed) return { aborted: false };
+    const result = await sendCall('session.abort', {
+      sessionId, open: openParams, options,
+      baseRevision: baseRevisionFor(),
+    }, randomUUID());
+    return await applyResult(result, 'abort');
   }
 
   const base = {
@@ -722,14 +942,49 @@ export async function createRemoteEngineSession(options = {}) {
       listeners.add(listener);
       return () => listeners.delete(listener);
     },
-    listSessions(options) {
-      if (options?.refreshFromStorage) dispatch('listSessions', [options]);
-      return Array.isArray(sync.sessions) ? sync.sessions : [];
+    async listSessions(options = {}) {
+      const result = await attachment.client.list(options, { callId: randomUUID() });
+      return Array.isArray(result?.sessions) ? result.sessions : [];
+    },
+    async listProjects() {
+      const result = await sendCall('project.list', {}, randomUUID());
+      return Array.isArray(result?.projects) ? result.projects : [];
+    },
+    async inspectProjectPath(projectPath) {
+      return await sendCall('project.inspect', { path: projectPath }, randomUUID());
+    },
+    async addProject(projectPath) {
+      const result = await sendCall('project.add', { path: projectPath }, randomUUID());
+      return result?.project ?? null;
+    },
+    async touchProjectSelected(projectPath) {
+      const result = await sendCall('project.touch', { path: projectPath }, randomUUID());
+      return result?.project ?? null;
+    },
+    async renameProject(projectPath, name) {
+      const result = await sendCall('project.rename', {
+        path: projectPath,
+        name,
+      }, randomUUID());
+      return result?.project ?? null;
     },
-    sessionStoreDir() {
-      return typeof sync.sessionStoreDir === 'string' ? sync.sessionStoreDir : null;
+    async removeProject(projectPath) {
+      const result = await sendCall('project.remove', { path: projectPath }, randomUUID());
+      return result?.removed === true;
     },
-    async newSession() {
+    async ensureProjectDirectory(projectPath) {
+      const result = await sendCall('project.ensureDirectory', {
+        path: projectPath,
+      }, randomUUID());
+      return String(result?.path || '');
+    },
+    async newSession(options = {}) {
+      // A newly-created daemon view already owns a durable reserved address.
+      // New-task setup may ask for a fresh session before the first submit;
+      // reusing that reservation avoids a second session.create round trip and
+      // duplicate provider/session prewarm. Explicit route/workflow changes
+      // omit this flag and retain the ordinary new-session boundary.
+      if (options?.reuseReservation === true && reservedOnly) return true;
       await createReservedSession();
       return true;
     },
@@ -737,13 +992,10 @@ export async function createRemoteEngineSession(options = {}) {
     async prefetchSession(targetSessionId) {
       const target = String(targetSessionId || '');
       if (!target) return false;
-      await callDaemonSession({
+      await attachment.client.read({
         sessionId: target,
-        method: 'read',
         open: openParams,
-        cwd,
-        log,
-        attempts: 1,
+        baseRevision: null,
       });
       return true;
     },
@@ -755,26 +1007,28 @@ export async function createRemoteEngineSession(options = {}) {
       });
       return true;
     },
-    abort() {
-      void serialize(async () => {
-        const result = await sendCall('session.abort', {
-          sessionId, open: openParams, baseRevision: revision,
-        }, randomUUID());
-        await applyResult(result, 'abort');
-      }).catch((err) => log(`session abort failed: ${err?.message || err}`));
+    abortAsync,
+    abort(options = {}) {
+      // Cancellation must bypass this view's ordered mutation chain. A slow
+      // capability/read call ahead of it must never delay the user's ESC.
+      void abortAsync(options).catch((err) => log(`session abort failed: ${err?.message || err}`));
       return true;
     },
     resolveToolApproval(id, decision) {
-      void serialize(async () => {
+      // Approval unblocks a live turn and has the same priority requirement as
+      // abort. Revision gaps caused by an overlapping ordinary call self-heal
+      // through applyResult()/resync().
+      void (async () => {
+        if (disposed) return;
         const result = await sendCall('session.approve', {
           sessionId,
           approvalId: id,
           decision,
           open: openParams,
-          baseRevision: revision,
+          baseRevision: baseRevisionFor(),
         }, randomUUID());
         await applyResult(result, 'approval');
-      }).catch((err) => log(`session approval failed: ${err?.message || err}`));
+      })().catch((err) => log(`session approval failed: ${err?.message || err}`));
       return true;
     },
     async dispose(reason = 'view dispose') {
@@ -785,7 +1039,7 @@ export async function createRemoteEngineSession(options = {}) {
       const lastLocalView = sessionViewCount(attachment.views, releasedSessionId) <= 1;
       if (lastLocalView) {
         try {
-          await attachment.client.call('session.unsubscribe', { sessionId: releasedSessionId });
+          await attachment.client.unsubscribe({ sessionId: releasedSessionId });
         } catch (err) {
           log(`session ${releasedSessionId} unsubscribe failed: ${err?.message || err}`);
         }
@@ -798,97 +1052,18 @@ export async function createRemoteEngineSession(options = {}) {
         // Last view gone: drop pooled keep-alive sockets so an idle connection
         // cannot keep the process (or a test runner) alive.
         try { daemonCallAgent.destroy(); } catch {}
+        try { daemonUrgentAgent.destroy(); } catch {}
         try { daemonControlAgent.destroy(); } catch {}
         if (shared === attachment) shared = null;
       }
     },
   };
 
-  return new Proxy(base, {
-    get(target, property, receiver) {
-      if (property in target || LOCAL_ENGINE_KEYS.has(property)) {
-        return Reflect.get(target, property, receiver);
-      }
-      if (typeof property === 'symbol') return undefined;
-      return (...args) => remoteCall(property, args);
-    },
-    has(target, property) {
-      return typeof property === 'string' ? true : Reflect.has(target, property);
-    },
-  });
-}
-
-/** Session-addressed backend request from a view that holds NO engine for that
- *  session. The daemon owns the engine pool, so a renderer (desktop pane, TUI
- *  tab) hands it the request and the daemon resolves — or loads — the session's
- *  engine. This is what makes "no live engine here" impossible to hit.
- *  Only a dead transport is retried; an engine-side verdict comes straight back. */
-export async function callDaemonSession({
-  sessionId,
-  method,
-  args = [],
-  open: openHints = {},
-  cwd = process.cwd(),
-  log = () => {},
-  attempts = 3,
-} = {}) {
-  const id = String(sessionId || '');
-  if (!id) throw new TypeError('sessionId is required');
-  const name = String(method || '');
-  if (!name) throw new TypeError('method is required');
-  let route = 'session.invoke';
-  let payload = { sessionId: id, method: name, args, open: openHints || {} };
-  if (name === 'submit') {
-    route = 'session.submit';
-    payload = {
-      sessionId: id,
-      prompt: args?.[0],
-      options: args?.[1] || {},
-      open: openHints || {},
-    };
-  } else if (name === 'abort') {
-    route = 'session.abort';
-    payload = { sessionId: id, open: openHints || {} };
-  } else if (name === 'resolveToolApproval') {
-    route = 'session.approve';
-    payload = {
-      sessionId: id,
-      approvalId: args?.[0],
-      decision: args?.[1],
-      open: openHints || {},
-    };
-  } else if (name === 'read') {
-    // Prefetch/peek: WARM (or load) the session's engine. This is a daemon
-    // route, not an engine method — sending it as session.invoke asked the
-    // engine for a `read()` that the store contract has never had, so every
-    // prefetch failed with "engine method read is unavailable".
-    route = 'session.read';
-    payload = { sessionId: id, open: openHints || {}, baseRevision: null };
+  for (const action of SESSION_READ_ACTIONS) {
+    if (!Object.hasOwn(base, action)) base[action] = (...args) => remoteCall(action, args);
   }
-  // One id for the whole retry sequence. In particular, a submit whose HTTP
-  // response was lost must hit the transport cache instead of being accepted
-  // twice by the daemon.
-  const submissionId = name === 'submit' ? String(args?.[1]?.id || '').trim() : '';
-  const callId = submissionId
-    ? `session-submit:${id}:${submissionId}`
-    : randomUUID();
-  let lastError = null;
-  for (let attempt = 0; attempt < Math.max(1, attempts); attempt += 1) {
-    const attachment = await ensureSharedAttachment({ cwd, log });
-    try {
-      const result = await attachment.client.call(route, payload, { callId });
-      if (name === 'submit') return { ...result, value: result?.accepted === true };
-      if (name === 'abort') return { ...result, value: result?.aborted === true };
-      if (name === 'resolveToolApproval') return { ...result, value: result?.approved === true };
-      return result;
-    } catch (err) {
-      if (!err?.daemonTransportError) throw err;
-      lastError = err;
-      // The attachment died under us; drop it so the next attempt re-discovers
-      // (or respawns) the daemon instead of calling into a closed socket.
-      if (shared === attachment) shared = null;
-      await delay(200 * (attempt + 1));
-    }
+  for (const action of SESSION_CONFIGURE_ACTIONS) {
+    if (!Object.hasOwn(base, action)) base[action] = (...args) => remoteCall(action, args);
   }
-  throw lastError || new Error('engine daemon session call failed');
+  return base;
 }