mixdog 0.9.95 → 0.9.97

package/src/tui/hooks/useSession.mjs

@@ -0,0 +1,16 @@
+/**
+ * src/tui/hooks/useSession.mjs — subscribe React to the session store.
+ *
+ * The store (session-local.mjs) lives outside React and emits immutable snapshots;
+ * useSyncExternalStore re-renders the tree whenever a snapshot changes. This
+ * keeps the agentLoop fully decoupled from React's lifecycle.
+ */
+import { useSyncExternalStore } from 'react';
+
+/**
+ * @param {object} store returned by createSessionRuntime()
+ * @returns the current session runtime state snapshot
+ */
+export function useSession(store) {
+  return useSyncExternalStore(store.subscribe, store.getState, store.getState);
+}

package/src/tui/index.jsx

@@ -1,7 +1,7 @@
 /**
  * src/tui/index.jsx — entry that mounts the React/ink TUI.
  *
- * Creates the engine session (runs OUR agentLoop outside React) and ink-renders
+ * Creates the session runtime session (runs OUR agentLoop outside React) and ink-renders
  * <App store={...}/>. Resolves when the app exits (/exit or /quit).
  */
 import React from 'react';
@@ -13,8 +13,8 @@ import { performance } from 'node:perf_hooks';
 import { format } from 'node:util';
 import { App } from './App.jsx';
 import { cancelPendingMouseTrackingRestores } from './app/use-mouse-input.mjs';
-import { createEngineSession } from './engine.mjs';
-import { scheduleRenderFrameAck, TUI_RENDER_FPS } from './engine/render-timing.mjs';
+import { createSessionRuntime } from './session.mjs';
+import { scheduleRenderFrameAck, TUI_RENDER_FPS } from './session/render-timing.mjs';
 import { installProcessSignalCleanup } from '../runtime/shared/process-shutdown.mjs';
 import { finishProcessLifecycle } from '../runtime/shared/process-lifecycle.mjs';
 import { rgbSgr } from '../ui/ansi.mjs';
@@ -30,7 +30,6 @@ import { POP_KITTY, DISABLE_MODIFY_OTHER_KEYS } from './keyboard-protocol.mjs';
 import { displayWidth } from './display-width.mjs';
 import { rotateBoundedLog, PLUGIN_LOG_MAX_BYTES, PLUGIN_LOG_KEEP_BYTES } from '../lib/mixdog-debug.cjs';
 import { localPackageVersion } from '../runtime/shared/update-checker.mjs';
-import { touchProjectSelected } from '../standalone/projects.mjs';
 
 // Trailing `\x1b[>0s` restores XTSHIFTESCAPE (shift-to-select-extend) to its
 // terminal default; MOUSE_TRACKING_ON opts into `\x1b[>1s`, so every mouse/alt
@@ -473,7 +472,7 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
 
   // Enter the alternate screen buffer before session/runtime boot so no stale
   // shell rows are visible while the statusline/TUI data warms up. The first
-  // real Ink frame may still arrive after createEngineSession(), but the user
+  // real Ink frame may still arrive after createSessionRuntime(), but the user
   // sees a clean fullscreen surface immediately instead of the previous terminal
   // contents bleeding through the bottom status area.
   process.stdout.write(`${TERMINAL_MODE_RESET_HIDDEN_CURSOR}\x1b[?1049h${TERMINAL_MODE_RESET_HIDDEN_CURSOR}\x1b[2J\x1b[H`);
@@ -489,10 +488,10 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
 
   process.on('exit', restoreTerminal);
 
-  // Engine startup is independent from palette selection. Start it now and
+  // Session runtime startup is independent from palette selection. Start it now and
   // overlap its runtime import/config work with the theme read, while still
   // awaiting the theme before the first React frame.
-  const storeOutcomePromise = createEngineSession({ provider, model, toolMode, remote })
+  const storeOutcomePromise = createSessionRuntime({ provider, model, toolMode, remote })
     .then((store) => ({ store, error: null }), (error) => ({ store: null, error }));
 
   // Apply the persisted UI theme (ui.theme in mixdog-config.json) before the
@@ -502,7 +501,7 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
   try { await loadThemeSettingFromConfig(); } catch { /* default theme stays */ }
   emitTerminalBackground(theme.background);
 
-  // Static splash + loading spinner while createEngineSession() warms up
+  // Static splash + loading spinner while createSessionRuntime() warms up
   // (config, providers, sessions). Without this the user stares at an empty
   // alt screen for the whole boot, then the UI "pops in" — the splash makes
   // the first ink frame an in-place repaint instead.
@@ -517,15 +516,15 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
     // this, a project entered straight from the shell never moved in the
     // picker's most-recent-first order. Unregistered folders are ignored.
     try {
-      touchProjectSelected(store.getState?.()?.cwd || process.cwd());
+      await store.touchProjectSelected(store.getState?.()?.cwd || process.cwd());
     } catch { /* best-effort recency */ }
-    // The palette lives in THIS process: on a daemon-backed store the engine's
+    // The palette lives in THIS process: on a daemon-backed store the session runtime's
     // theme methods would run inside the daemon, so the picker saw a promise
     // instead of the list and a switch repainted nothing here. Bind the three
     // theme methods locally (same pattern as the ink selection helpers below)
-    // and mirror the switch to the engine with persist:false, purely so its
+    // and mirror the switch to the session runtime with persist:false, purely so its
     // themeEpoch bump re-renders this tree.
-    if (store.isRemoteEngine === true) {
+    if (store.isRemoteSession === true) {
       const remoteSetTheme = store.setTheme;
       store.listThemes = () => listThemes();
       store.getTheme = () => getThemeSetting();
@@ -548,7 +547,7 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
     process.stderr.write(`mixdog: ${error?.message || error}\n`);
     return 1;
   }
-  // The engine store is a daemon-backed Proxy: every method it does not
+  // The session runtime store is a daemon-backed Proxy: every method it does not
   // implement locally comes back as an ASYNC remote call. A synchronous
   // getOnboardingStatus() probe inside App therefore sees a Promise, never
   // `.completed`, and re-opens the finished wizard on every launch. Resolve

package/src/tui/{engine → session}/agent-envelope.mjs

@@ -1,8 +1,8 @@
 /**
- * src/tui/engine/agent-envelope.mjs - parse agent/background-task/shell
+ * src/tui/session/agent-envelope.mjs - parse agent/background-task/shell
  * notification envelopes into synthetic tool-item shapes, and derive
- * status/result text. Extracted from engine.mjs; parseBackgroundTaskEnvelope
- * remains part of engine.mjs's public surface.
+ * status/result text. Extracted from session-local.mjs; parseBackgroundTaskEnvelope
+ * remains part of session-local.mjs's public surface.
  */
 import { isBackgroundErrorOnlyBody } from '../../runtime/shared/err-text.mjs';
 

package/src/tui/{engine → session}/agent-job-feed.mjs

@@ -1,6 +1,6 @@
 /**
- * src/tui/engine/agent-job-feed.mjs — agent-job / runtime-notification plumbing
- * extracted from createEngineSession (engine.mjs) as a dependency-injection
+ * src/tui/session/agent-job-feed.mjs — agent-job / runtime-notification plumbing
+ * extracted from the session runtime as a dependency-injection
  * factory.
  *
  * Owns: the agent-job card result patch (updateAgentJobCard), the
@@ -11,7 +11,7 @@
  * These handlers mutate live session state and drive the queue, so
  * state/set/enqueue/drain/pushUserOrSyntheticItem/patchItem/etc are threaded via
  * the factory argument (getters/callbacks) — never stale snapshots. Every body
- * is the original engine.mjs logic verbatim.
+ * is the original session-local.mjs logic verbatim.
  */
 import {
   parseAgentJob,
@@ -314,7 +314,7 @@ export function createAgentJobFeed({
         if (firstDelivery && !successfulPreview && !bodyAlreadyDisplayed) {
           if (cardKey) rememberDisplayedExecutionNotificationKey(cardKey, terminal, executionId);
           if (executionId) rememberDisplayedExecutionResponseState(executionId, hasBody ? 'body' : 'preview', terminal);
-          // Execution completions are inbound agent responses. The engine keeps
+          // Execution completions are inbound agent responses. The session runtime keeps
           // their aggregation tail-safe (only an immediately-adjacent inbound
           // response of the same preview/body phase can merge); the fallback
           // preserves the standalone path for minimal/test harnesses.

package/src/tui/{engine → session}/boot-profile.mjs

@@ -1,7 +1,7 @@
 /**
- * src/tui/engine/boot-profile.mjs - opt-in boot timing trace.
+ * src/tui/session/boot-profile.mjs - opt-in boot timing trace.
  *
- * Extracted from engine.mjs. Emits `[mixdog-boot]` stderr lines when
+ * Extracted from session-local.mjs. Emits `[mixdog-boot]` stderr lines when
  * MIXDOG_BOOT_PROFILE is truthy; a no-op otherwise.
  */
 import { performance } from 'node:perf_hooks';

package/src/tui/{engine → session}/context-state.mjs

@@ -1,7 +1,7 @@
 /**
- * src/tui/engine/context-state.mjs - route/context/agent-status derivations.
+ * src/tui/session/context-state.mjs - route/context/agent-status derivations.
  *
- * Extracted from engine.mjs unchanged. These read the live runtime + store
+ * Extracted from session-local.mjs unchanged. These read the live runtime + store
  * snapshot. The two sync helpers stage immutable draft patches through
  * updateState; callers still follow with set(...) to schedule publication.
  */
@@ -24,7 +24,7 @@ export function createContextState({ runtime, getState, updateState, getPendingS
   };
   const baseRouteState = () => ({
     sessionId: runtime.id,
-    // Fork-on-resume marker: when the engine opened a live session as a fork
+    // Fork-on-resume marker: when the session runtime opened a live session as a fork
     // (fresh id, copied transcript), hosts validating "resume returned the
     // requested session" must accept the fork by its origin id.
     sessionForkedFrom: runtime.session?.forkedFrom || null,

package/src/tui/{engine → session}/labels.mjs

@@ -1,6 +1,6 @@
 /**
- * src/tui/engine/labels.mjs - spinner verbs, elapsed formatting, and compact
- * event label/detail helpers. Extracted from engine.mjs.
+ * src/tui/session/labels.mjs - spinner verbs, elapsed formatting, and compact
+ * event label/detail helpers. Extracted from session-local.mjs.
  */
 import { SPINNER_VERBS } from '../spinner-verbs.mjs';
 

package/src/tui/{engine → session}/live-share.mjs

@@ -1,12 +1,12 @@
 /**
- * src/tui/engine/live-share.mjs — real-time cross-surface session mirroring.
+ * src/tui/session/live-share.mjs — real-time cross-surface session mirroring.
  *
  * OWNER leg: hosts a local named-pipe (win32) / unix-socket server for the
  * session it owns and pushes frame-batched transcript deltas (items /
  * streaming tail / spinner) to attached viewers. Push-only: zero polling,
  * idle cost is one open listener.
  * VIEWER leg: connects to the owner's pipe and mirrors those deltas into the
- * local engine store, so streaming output appears live on every co-open
+ * local session runtime store, so streaming output appears live on every co-open
  * surface (desktop <-> terminal). Viewer submits travel over the same pipe
  * into the owner's normal submit queue (concurrent input from both sides is
  * serialized there); the durable pending spool remains the fallback when the
@@ -25,7 +25,7 @@ const MAX_BUFFER_BYTES = 8 * 1024 * 1024;
 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.
+// coarse 3s session runtime safety tick.
 const LIVE_CONNECT_RETRY_MIN_MS = 10;
 const LIVE_CONNECT_RETRY_MAX_MS = 160;
 
@@ -640,7 +640,7 @@ export function createLiveShare({
   };
 
   // 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
+  // continue through the local retry timers; the session runtime's 3s call is only a
   // safety net, never the normal connection cadence.
   const ensureShare = () => {
     if (disposed) return;
@@ -709,3 +709,37 @@ export function createLiveShare({
     },
   };
 }
+
+/**
+ * ONE viewer-submit intake for EVERY session runtime entry point. The TUI store calls
+ * submit(); the daemon awaits submitAsync() (session-service prefers it).
+ * Wrapping only one of them let the other path enqueue the prompt on the VIEWER
+ * session runtime, so that surface rendered its own local user row beside the owner's
+ * mirrored one — the same message twice on screen
+ * (user: 데스크탑에서만 입력이 두 개로 들어간다).
+ *
+ * `spool(submissionId)` is the durable fallback. The submission id is minted
+ * here when the caller has none, so the pipe frame and the spool entry carry
+ * the SAME identity and the owner reuses it for the settled user row — which is
+ * what releases the submitting surface's optimistic bubble.
+ */
+export function forwardViewerSubmit({ text, options = {}, share, spool, pid = process.pid }) {
+  const value = String(text || '').trim();
+  if (!value) return false;
+  // Reconcile first so a session that became attachable this event-loop turn
+  // takes the instant pipe path instead of the durable detour.
+  try { share.ensure?.(); } catch { /* durable fallback below */ }
+  const submissionId = options.id != null && String(options.id).trim()
+    ? String(options.id).trim()
+    : `view-submit-${pid}-${Date.now()}`;
+  const deliverDurably = () => spool?.(submissionId) === true;
+  // A pipe WRITE is not a delivery: the owner may refuse the prompt and the
+  // socket may die between write and read, so an unacknowledged submit is
+  // re-delivered through the spool — late, never lost.
+  if (share.sendSubmit(value, {
+    id: submissionId,
+    submittedAt: options.submittedAt,
+    onUndelivered: deliverDurably,
+  })) return true;
+  return deliverDurably();
+}

package/src/tui/{engine → session}/notice-text.mjs

@@ -1,6 +1,6 @@
 /**
- * src/tui/engine/notice-text.mjs - polish user-facing failure/notice text.
- * Extracted from engine.mjs.
+ * src/tui/session/notice-text.mjs - polish user-facing failure/notice text.
+ * Extracted from session-local.mjs.
  */
 const FAILED_NOTICE_ACTIONS = new Map([
   ['api key save', 'save API key'],

package/src/tui/{engine → session}/notification-plan.mjs

@@ -1,9 +1,9 @@
 /**
- * src/tui/engine/notification-plan.mjs - pure runtime.onNotification delivery plan.
+ * src/tui/session/notification-plan.mjs - pure runtime.onNotification delivery plan.
  *
- * Extracted from engine.mjs (no behavior change). These are stateless helpers
+ * Extracted from session-local.mjs (no behavior change). These are stateless helpers
  * that decide how a runtime notification envelope should be delivered to the
- * TUI store (dedupe key + display/model routing). No closures over engine state.
+ * TUI store (dedupe key + display/model routing). No closures over session runtime state.
  */
 import {
   isStatusOnlyAgentCompletionNotification,

package/src/tui/session/oauth-flows.mjs

@@ -0,0 +1,140 @@
+// Daemon-owned provider OAuth flows. The provider runtime returns live
+// promises/functions, so the session surface must retain them locally and
+// expose only serializable status records to desktop clients.
+const DEFAULT_FLOW_TTL_MS = 10 * 60 * 1_000;
+
+export function oauthFlowStatus(flow) {
+  return {
+    flowId: flow.id,
+    provider: flow.provider,
+    url: flow.url,
+    manualUrl: flow.manualUrl,
+    state: flow.state,
+    completed: flow.state === 'complete',
+    error: flow.error,
+    manualCodeSupported: typeof flow.completeCode === 'function',
+  };
+}
+
+function requiredFlowId(value) {
+  const id = String(value || '').trim();
+  if (!/^oauth_[a-z0-9_]+$/i.test(id)) throw new TypeError('OAuth flow id is invalid.');
+  return id;
+}
+
+function cancelFlow(flow, reason) {
+  try {
+    const result = flow.cancel?.();
+    if (result && typeof result.then === 'function') {
+      void Promise.resolve(result).catch((error) => {
+        console.warn(`OAuth flow could not be ${reason}:`, error);
+      });
+    }
+  } catch (error) {
+    console.warn(`OAuth flow could not be ${reason}:`, error);
+  }
+}
+
+export function createSessionOAuthFlowRegistry({ ttlMs = DEFAULT_FLOW_TTL_MS } = {}) {
+  const flows = new Map();
+  let sequence = 0;
+
+  function requireFlow(id) {
+    const key = requiredFlowId(id);
+    const flow = flows.get(key);
+    if (!flow) throw new Error('OAuth login flow is no longer available.');
+    return flow;
+  }
+
+  function register(value) {
+    const started = value && typeof value === 'object' ? value : null;
+    if (!started) throw new Error('OAuth provider did not return a login flow.');
+    const provider = String(started.provider || '').trim();
+    if (!provider) throw new Error('OAuth provider login is missing its provider id.');
+    const id = `oauth_${Date.now().toString(36)}_${(++sequence).toString(36)}`;
+    const flow = {
+      id,
+      provider,
+      url: typeof started.url === 'string' ? started.url : null,
+      manualUrl: typeof started.manualUrl === 'string' ? started.manualUrl : null,
+      state: 'pending',
+      result: null,
+      error: null,
+      completeCode: typeof started.completeCode === 'function' ? started.completeCode : undefined,
+      cancel: typeof started.cancel === 'function' ? started.cancel : undefined,
+      timeout: null,
+    };
+    flow.timeout = setTimeout(() => {
+      const current = flows.get(id);
+      if (!current) return;
+      cancelFlow(current, 'expired');
+      flows.delete(id);
+    }, Math.max(1, Number(ttlMs) || DEFAULT_FLOW_TTL_MS));
+    flow.timeout.unref?.();
+    flows.set(id, flow);
+    if (started.waitForCallback && typeof started.waitForCallback.then === 'function') {
+      void Promise.resolve(started.waitForCallback).then((result) => {
+        const current = flows.get(id);
+        if (!current || current.state !== 'pending' || !result) return;
+        current.state = 'complete';
+        current.result = true;
+      }).catch((error) => {
+        const current = flows.get(id);
+        if (!current || current.state !== 'pending') return;
+        current.state = 'failed';
+        current.error = error instanceof Error ? error.message : String(error);
+      });
+    }
+    return oauthFlowStatus(flow);
+  }
+
+  function status(id) {
+    return oauthFlowStatus(requireFlow(id));
+  }
+
+  async function complete(id, rawCode) {
+    const flow = requireFlow(id);
+    if (typeof flow.completeCode !== 'function') {
+      throw new Error('This OAuth provider does not accept a manual code.');
+    }
+    const code = String(rawCode || '').trim();
+    if (!code || code.length > 16_384) throw new TypeError('OAuth code is invalid.');
+    try {
+      const completed = await flow.completeCode(code);
+      flow.result = Boolean(completed);
+      flow.state = completed ? 'complete' : 'failed';
+      flow.error = completed ? null : 'OAuth code did not complete the login.';
+    } catch (error) {
+      flow.state = 'failed';
+      flow.error = error instanceof Error ? error.message : String(error);
+      throw error;
+    }
+    return oauthFlowStatus(flow);
+  }
+
+  async function cancel(id) {
+    const flow = requireFlow(id);
+    let failure = null;
+    try {
+      await flow.cancel?.();
+    } catch (error) {
+      failure = error;
+    } finally {
+      flow.state = 'cancelled';
+      clearTimeout(flow.timeout);
+      flows.delete(flow.id);
+    }
+    if (failure) throw failure;
+    return oauthFlowStatus(flow);
+  }
+
+  function cancelAll() {
+    for (const flow of flows.values()) {
+      clearTimeout(flow.timeout);
+      cancelFlow(flow, 'cancelled');
+    }
+    flows.clear();
+  }
+
+  return Object.freeze({ register, status, complete, cancel, cancelAll });
+}

package/src/tui/{engine → session}/prompt-history.mjs

@@ -1,8 +1,8 @@
 /**
- * src/tui/engine/prompt-history.mjs - pure prompt-history derivation.
+ * src/tui/session/prompt-history.mjs - pure prompt-history derivation.
  *
- * Extracted from engine.mjs unchanged: the newest-first, deduped user-prompt
- * history the engine publishes on state.promptHistoryList. Pure (input items
+ * Extracted from session-local.mjs unchanged: the newest-first, deduped user-prompt
+ * history the session runtime publishes on state.promptHistoryList. Pure (input items
  * → array); callers decide when/whether to publish so the store's
  * immutable-emit contract is preserved.
  */

package/src/tui/{engine → session}/queue-helpers.mjs

@@ -1,8 +1,8 @@
 /**
- * src/tui/engine/queue-helpers.mjs - pure helpers for the prompt/notification
+ * src/tui/session/queue-helpers.mjs - pure helpers for the prompt/notification
  * queue: priority ordering, entry visibility/editability, prompt content
  * flattening, session activity timestamps, and batch merging. Extracted from
- * engine.mjs.
+ * session-local.mjs.
  */
 import {
   agentJobResultText,

package/src/tui/{engine → session}/render-timing.mjs

@@ -1,7 +1,7 @@
 /**
- * src/tui/engine/render-timing.mjs - render-throttle timing helper.
+ * src/tui/session/render-timing.mjs - render-throttle timing helper.
  *
- * Extracted from engine.mjs (no behavior change originally).
+ * Extracted from session-local.mjs (no behavior change originally).
  *
  * Ink renders through a maxFps throttle (120fps in index.jsx, ≈8.3ms). A plain
  * setImmediate only yields to the event loop; if Ink already painted within the

package/src/tui/{engine → session}/session-api-ext.mjs

@@ -1,5 +1,5 @@
 /**
- * src/tui/engine/session-api-ext.mjs - part of the public engine session object.
+ * src/tui/session/session-api-ext.mjs - part of the public session runtime session object.
  */
 import { listThemes, getThemeSetting, setThemeSetting } from '../theme.mjs';
 import { resetAllStreamingMarkdownStablePrefixes } from '../markdown/streaming-markdown.mjs';
@@ -7,7 +7,8 @@ import { toolResultText } from './tool-result-text.mjs';
 import { parseSyntheticAgentMessage } from './agent-envelope.mjs';
 import { flushTuiSteeringPersist } from './tui-steering-persist.mjs';
 import { getVoiceStatus, toggleVoice } from '../lib/voice-setup.mjs';
-import { aggregateToolCategoryEntry, aggregateDoneCategories, classifyToolCategory, formatAggregateDetail, summarizeToolResult } from '../../runtime/shared/tool-surface.mjs';
+import { createSessionOAuthFlowRegistry } from './oauth-flows.mjs';
+import { aggregateToolCategoryEntries, aggregateDoneCategories, classifyToolCategory, formatAggregateDetail, summarizeToolResult } from '../../runtime/shared/tool-surface.mjs';
 import { aggregateBucketForCategory, aggregateRawResult, failureDetailText, shellCommandExitCode } from './tool-result-status.mjs';
 import { isInternalTranscriptDisplayText } from '../../runtime/shared/tool-execution-contract.mjs';
 import { toolResultTerminalStatus } from '../../runtime/shared/tool-status.mjs';
@@ -121,10 +122,11 @@ function buildRestoredAggregateItem(members) {
   const categoryOrder = [];
   const calls = [];
   for (const { item, category } of members) {
-    const entry = aggregateToolCategoryEntry(item.name, item.args, category);
-    if (!categories.has(entry.key)) categoryOrder.push(entry.key);
-    const prev = categories.get(entry.key);
-    categories.set(entry.key, { ...entry, count: Number(prev?.count || 0) + Number(entry.count || 1) });
+    for (const entry of aggregateToolCategoryEntries(item.name, item.args, category)) {
+      if (!categories.has(entry.key)) categoryOrder.push(entry.key);
+      const prev = categories.get(entry.key);
+      categories.set(entry.key, { ...entry, count: Number(prev?.count || 0) + Number(entry.count || 1) });
+    }
     const resultText = String(item.result ?? '');
     // Mirror live outcome semantics: a plain non-zero shell exit is the
     // neutral 'Exit N' state, not a red failure; only real call errors count.
@@ -186,7 +188,7 @@ function buildRestoredAggregateItem(members) {
 }
 
 // Restored transcripts must mirror the live turn's category merging: the live
-// engine (turn.mjs) collapses consecutive same-bucket tool calls into one
+// session runtime (turn.mjs) collapses consecutive same-bucket tool calls into one
 // aggregate card, but resume rebuilt one card per call, so a reopened session
 // un-merged every run (user bug). Walk the restored items and merge adjacent
 // tool cards whose aggregateBucketForCategory matches; any non-tool item
@@ -381,10 +383,11 @@ export function sessionContextSnapshotProjection(session, contextStatus) {
   };
 }
 
-export function createEngineApiB(bag) {
+export function createSessionApiB(bag) {
   const {
     runtime, nextId, flags, lifecycle, listeners, getState, set, flushEmitImmediate, disposeEmit, replaceItems, pushNotice, removeNotice, setProgressHint, clearToastTimers, disposeTranscriptSpill, routeState, syncContextStats, finishToolApproval, denyAllToolApprovals, restoreLeadSteeringFromDisk, resetStats, clearUiActivityBeforeContextSync, resetTuiForPendingSessionReset, snapshotTuiBeforeSessionReset, restoreTuiAfterFailedSessionReset, commitTuiSessionReset, resetStatsAndSyncContext,
   } = bag;
+  const oauthFlows = createSessionOAuthFlowRegistry();
   return {
     resolveToolApproval: (id, decision = {}) => {
       const approved = decision === true || decision?.approved === true;
@@ -519,7 +522,7 @@ export function createEngineApiB(bag) {
     // `/remote` slash command — repeated /remote just re-claims (idempotent).
     claimRemote: async () => {
       // Desired state paints before daemon cold boot. The final read in
-      // `finally` reconciles a skipped/failed claim to the backend truth.
+      // `finally` reconciles a skipped/failed claim to the session truth.
       set({
         remoteEnabled: true,
         remoteSessionId: runtime.getRemoteSessionId?.() || getState().sessionId || null,
@@ -623,9 +626,6 @@ export function createEngineApiB(bag) {
     setAgentRoute: async (agentId, opts) => {
       return await runtime.setAgentRoute?.(agentId, opts);
     },
-    setDefaultProvider: async (provider) => {
-      return await runtime.setDefaultProvider?.(provider);
-    },
     listProviders: () => {
       return runtime.listProviders();
     },
@@ -636,7 +636,7 @@ export function createEngineApiB(bag) {
       return await runtime.getUsageDashboard?.(options);
     },
     consumeCodexRateLimitResetCredit: async (options = {}) => {
-      // Desktop capability parity: without this delegation the engine surface
+      // Desktop capability parity: without this delegation the session runtime surface
       // rejects the sidebar's reset-credit invoke as unsupported even though
       // the session runtime implements it.
       if (typeof runtime.consumeCodexRateLimitResetCredit !== 'function') {
@@ -644,8 +644,14 @@ export function createEngineApiB(bag) {
       }
       return await runtime.consumeCodexRateLimitResetCredit(options);
     },
-    getTurnReviewDiff: async () => {
-      return (await runtime.getTurnReviewDiff?.()) ?? { supported: false, files: [], patch: '' };
+    getTurnReviewDiff: async (options = {}) => {
+      return (await runtime.getTurnReviewDiff?.(options)) ?? { supported: false, files: [], patch: '' };
+    },
+    revertTurnReviewFile: async (file) => {
+      if (typeof runtime.revertTurnReviewFile !== 'function') {
+        throw new Error('Turn review revert is unavailable');
+      }
+      return await runtime.revertTurnReviewFile(file);
     },
     getOnboardingStatus: () => {
       return runtime.getOnboardingStatus?.() || { completed: true, workflowRoutes: {} };
@@ -682,13 +688,16 @@ export function createEngineApiB(bag) {
       if (getState().commandBusy) throw new Error('command busy');
       set({ commandBusy: true });
       try {
-        const result = await runtime.beginOAuthProviderLogin(provider);
+        const result = oauthFlows.register(await runtime.beginOAuthProviderLogin(provider));
         pushNotice(`provider oauth started: ${result.provider}`, 'info');
         return result;
       } finally {
         set({ commandBusy: false });
       }
     },
+    getOAuthProviderLoginStatus: (flowId) => oauthFlows.status(flowId),
+    completeOAuthProviderLogin: async (flowId, code) => oauthFlows.complete(flowId, code),
+    cancelOAuthProviderLogin: async (flowId) => oauthFlows.cancel(flowId),
     saveProviderApiKey: (provider, secret) => {
       const result = runtime.saveProviderApiKey(provider, secret);
       pushNotice(`provider api key saved: ${result.provider}`, 'info');
@@ -741,7 +750,7 @@ export function createEngineApiB(bag) {
       return runtime.getChannelSetup();
     },
     getChannelWorkerStatus: () => runtime.getChannelWorkerStatus?.(),
-    setBackend: (name) => runtime.setBackend?.(name),
+    setChannelProvider: (name) => runtime.setChannelProvider?.(name),
     saveDiscordToken: (token) => {
       const result = runtime.saveDiscordToken(token);
       pushNotice('discord token saved', 'info');
@@ -883,7 +892,7 @@ export function createEngineApiB(bag) {
     renameSessionTitle: (id, title) => {
       return runtime.renameSessionTitle?.(id, title) ?? false;
     },
-    // Desktop sidebar watcher hook: EngineHost fs.watches this directory so
+    // Desktop sidebar watcher hook: the daemon watches this directory so
     // heartbeat sidecar create/delete pushes instant working/dot updates.
     // Without it the watcher silently no-ops and the sidebar falls back to
     // the 60s safety poll (user: spinner kept spinning after the turn ended).
@@ -1005,7 +1014,7 @@ export function createEngineApiB(bag) {
       }
     },
     // Desktop split panes: read-only transcript + route peek of an idle
-    // session — no resume, no ownership claim, no engine state mutation.
+    // session — no resume, no ownership claim, no session runtime state mutation.
     // Panes render every visible session as foreground from this frame.
     peekSessionTranscript: (id, options = {}) => {
       const session = runtime.peekSession?.(id);
@@ -1031,7 +1040,7 @@ export function createEngineApiB(bag) {
     },
     resume: async (id, options = {}) => {
       if (getState().commandBusy) return false;
-      // quiet: viewer-follow refreshes (engine share tick) re-resume on every
+      // quiet: viewer-follow refreshes (session runtime share tick) re-resume on every
       // owner turn — they must not flash the "Resuming conversation" status.
       set({
         commandBusy: true,
@@ -1098,6 +1107,7 @@ export function createEngineApiB(bag) {
       try { lifecycle.unsubscribeRemoteState?.(); } catch {}
       lifecycle.unsubscribeRemoteState = null;
       denyAllToolApprovals('runtime closing');
+      oauthFlows.cancelAll();
       await flushTuiSteeringPersist();
       await runtime.close(reason, options);
       listeners.clear();