mixdog 1.2.2 → 1.2.4

package/src/tui/session/active-tool-summary.mjs

@@ -2,7 +2,7 @@
  * src/tui/session/active-tool-summary.mjs - surfaced-tool activity summary.
  *
  * Status surfaces must react at tool start, before a shell is backgrounded or
- * an agent worker heartbeat exists. Track the three surfaced categories
+ * an agent worker row exists. Track the three surfaced categories
  * directly; background shell records and worker rows later dedupe by max.
  */
 // Tool category -> the activeTools key it publishes under. Iteration order is

package/src/tui/session/context-state.mjs

@@ -47,9 +47,6 @@ export function createContextState({
     // (fresh id, copied transcript), hosts validating "resume returned the
     // requested session" must accept the fork by its origin id.
     sessionForkedFrom: runtime.session?.forkedFrom || null,
-    // Remote-attach marker: this surface is a live viewer on a session owned
-    // by another process; submits are injected, transcript follows disk.
-    sessionRemoteAttached: runtime.session?.remoteAttached === true,
     clientHostPid: runtime.clientHostPid || null,
     model: runtime.model,
     provider: runtime.provider,
@@ -71,8 +68,10 @@ export function createContextState({
     // Lead workspace record (worktrees/contract.mjs SessionWorkspace): the
     // registered Project, the execution root, the worktree binding and its
     // revision. Null while the session has never left its project folder.
-    // Identity-stable until a transition commits.
-    workspace: runtime.getWorkspace?.() ?? null,
+    // Identity-stable until a transition commits. A project-folder session in a
+    // git repository publishes the folder's branch / detached commit too
+    // (getLiveWorkspace reads HEAD without spawning git).
+    workspace: runtime.getLiveWorkspace?.() ?? runtime.getWorkspace?.() ?? null,
     systemShell: runtime.systemShell || { source: 'auto', command: '', effective: '' },
     webSearchRoute: runtime.getWebSearchRoute?.() || runtime.webSearchRoute || null,
     autoClear: autoClearState(),

package/src/tui/session/goal-continuation/continuation-queue.mjs

@@ -8,7 +8,7 @@ import { isGoalQueuedEntry } from '../queue-helpers.mjs';
 export function createContinuationQueue({ runtime, flags, getState, getPending, enqueue, visibility }) {
   let scheduled = null;
   let disposed = false;
-  const halted = () => disposed || flags.disposed || flags.pendingSessionReset;
+  const halted = () => disposed || flags.disposed || flags.pendingSessionReset || flags.quotaResumePending;
 
   const cancelQueuedGoalContinuations = ({ keepCloseoutFor = null } = {}) => {
     const pending = getPending();
@@ -38,7 +38,6 @@ export function createContinuationQueue({ runtime, flags, getState, getPending,
 
   const shouldRunGoalContinuation = (entry) => {
     if (halted()) return false;
-    if (getState().sessionRemoteAttached) return false;
     if (entry?.mode === 'goal-closeout') {
       const goal = visibility.refreshGoalState();
       return goal?.status === 'duration_reached' && clean(entry.goalId) === clean(goal.id);
@@ -55,7 +54,7 @@ export function createContinuationQueue({ runtime, flags, getState, getPending,
       scheduled = null;
       if (halted()) return;
       const state = getState();
-      if (state.busy || state.commandBusy || state.sessionRemoteAttached) return;
+      if (state.busy || state.commandBusy) return;
       // Queued user work runs first, and a queued Goal entry already carries
       // the next continuation.
       if (getPending().length > 0) return;

package/src/tui/session/goal-continuation/deadline-delivery.mjs

@@ -1,7 +1,10 @@
 // Deadline notices for the running Goal: the advance warning and the closeout
 // once the duration is reached.
 import { clean } from '../../../runtime/shared/clean.mjs';
-import { goalDeadlineReached, goalDeadlineWarning } from '../../../runtime/agent/orchestrator/runtime-core/goal-text.mjs';
+import {
+  goalDeadlineReached,
+  goalDeadlineWarning,
+} from '../../../runtime/agent/orchestrator/runtime-core/goal-text.mjs';
 import { isGoalQueuedEntry } from '../queue-helpers.mjs';
 
 export function createDeadlineDelivery({ runtime, getState, getPending, enqueue, halted }) {
@@ -54,7 +57,6 @@ export function createDeadlineDelivery({ runtime, getState, getPending, enqueue,
   const deliverGoalCloseout = (goal) => {
     if (halted()) return;
     const state = getState();
-    if (state.sessionRemoteAttached) return;
     if (!state.busy && getPending().some((entry) => !isGoalQueuedEntry(entry))) {
       runtime.markGoalReminder?.('deadline-reached');
       return;

package/src/tui/session/goal-continuation/session-boundary.mjs

@@ -0,0 +1,21 @@
+/**
+ * src/tui/session/goal-continuation/session-boundary.mjs - a session boundary
+ * (resume, new session, context switch) changes which Goal is current, so the
+ * continuation queued for the previous session is dropped and the current
+ * session's Goal is re-read and re-armed once the boundary settles.
+ */
+const SESSION_BOUNDARY_METHODS = ['resume', 'newSession', 'switchContext'];
+
+export function rearmGoalContinuationOnSessionBoundaries({ api, bag }) {
+  for (const method of SESSION_BOUNDARY_METHODS) {
+    if (typeof api[method] !== 'function') continue;
+    const base = api[method].bind(api);
+    api[method] = async (...args) => {
+      const result = await base(...args);
+      bag.cancelQueuedGoalContinuations?.();
+      bag.refreshGoalState?.();
+      bag.scheduleGoalContinuation?.();
+      return result;
+    };
+  }
+}

package/src/tui/session/quota-resume.mjs

@@ -11,42 +11,23 @@
 import {
   cancelQuotaResumeEntry,
   forgetQuotaSuspendedGoal,
-  isAgentOnlySession,
   noteQuotaSuspendedGoal,
   publicQuotaResume,
   quotaAutoResumeEnabled,
   quotaResumeEntry,
   quotaSuspendedGoal,
+  rekeyQuotaResumeTurn,
   scheduleQuotaResumeEntry,
   subscribeQuotaResume,
 } from '../../runtime/shared/quota-resume-store.mjs';
-import { createSubmissionIntake } from './session-api/intake/submission.mjs';
 
 export const RETRY_CONTINUE_INSTRUCTION = 'Continue from where you left off.';
+import { transcriptTurnKeys } from '../../runtime/shared/transcript-turn-keys.mjs';
+export { transcriptTurnKeys };
 
 // Rows that frame a turn rather than carry its output (desktop transcript-rows).
 const TURN_CHROME_KINDS = new Set(['user', 'turndone', 'statusdone', 'notice']);
 
-function stableItemKey(item, index) {
-  if (item?.id !== undefined && item?.id !== null) return String(item.id);
-  return `${item?.kind || 'item'}:${item?.text || item?.label || item?.status || ''}:${index}`;
-}
-
-/** Turn identity per transcript row — the same keys the desktop derives. */
-export function transcriptTurnKeys(items) {
-  const transcript = Array.isArray(items) ? items : [];
-  const keys = [];
-  let activeTurn = null;
-  for (let index = 0; index < transcript.length; index += 1) {
-    const item = transcript[index];
-    if (item?.kind === 'user') activeTurn = `turn:${stableItemKey(item, index)}`;
-    if (!activeTurn) activeTurn = `segment:${stableItemKey(item, index)}`;
-    keys.push(activeTurn);
-    if (item?.kind === 'turndone') activeTurn = null;
-  }
-  return keys;
-}
-
 /** The failed turndone that ended the transcript on exhausted provider quota,
  *  when no later turn has begun: { turnKey, quota: { provider, model, resetAt|null } }. */
 export function latestQuotaFailure(items) {
@@ -106,7 +87,7 @@ export function failedTurnRetryPrompt(items, turnKey) {
     }
     if (!TURN_CHROME_KINDS.has(String(item?.kind || ''))) sampled = true;
   }
-  if (!prompt) return null;
+  if (!prompt) return sampled ? RETRY_CONTINUE_INSTRUCTION : null;
   // Transcript rows keep only attachment metadata, so a text-only replay
   // would drop the attachments and the rewind would delete the original row.
   if (hasAttachments && !sampled) return null;
@@ -116,11 +97,6 @@ export function failedTurnRetryPrompt(items, turnKey) {
 export function createQuotaResumeLane(bag) {
   const { runtime, flags, getState, set, pending } = bag;
   const currentId = () => String(getState().sessionId || '');
-  let intake = null;
-  const submitAsync = (...args) => {
-    intake ??= createSubmissionIntake(bag);
-    return intake.submitAsync(...args);
-  };
 
   const publishQuotaResume = () => {
     const next = publicQuotaResume(quotaResumeEntry(currentId()));
@@ -140,8 +116,6 @@ export function createQuotaResumeLane(bag) {
     routeProvider: String(runtime.sessionProvider ?? runtime.provider ?? ''),
     routeModel: String(runtime.sessionModel ?? runtime.model ?? ''),
   });
-  // A delegated agent child never owns a resume: the Lead decides its retries.
-  const agentOnly = () => isAgentOnlySession({ id: currentId(), ...runtime.session });
   const queueResume = (sessionId, failure) =>
     scheduleQuotaResumeEntry({ sessionId, turnKey: failure.turnKey, ...failure.quota, ...sessionRoute() });
 
@@ -151,6 +125,7 @@ export function createQuotaResumeLane(bag) {
   // that window also keeps the settlement from recording the Goal.
   let settlement = null;
   let cancelEpoch = 0;
+  let retryClaim = '';
 
   const cancelFor = (sessionId) => {
     cancelEpoch += 1;
@@ -169,24 +144,107 @@ export function createQuotaResumeLane(bag) {
       state.commandBusy ||
       flags.autoClearRunning ||
       flags.draining ||
+      flags.quotaResumePending ||
       pending.length > 0
     );
   };
 
-  /** The one retry operation. `automatic` is the scheduler's resume: it
-   *  enqueues directly, because the hours it waited must not trigger the idle
-   *  auto-clear a user submission starts. */
-  function retryFailedTurn(turnKey, { automatic = false } = {}) {
+  /** A resume preserves its history rather than running idle auto-clear. */
+  function retainedRetryInput() {
+    const messages = runtime.readModelMessages?.().messages;
+    const message = Array.isArray(messages) ? messages.findLast((item) => item?.role !== 'system') : null;
+    const transcript = message?.meta?.transcript;
+    if (message?.role !== 'user' || !transcript?.messageId || transcript?.completion?.status !== 'failed') return null;
+    return { content: message.content, messageId: transcript.messageId, attemptId: transcript.completion.attemptId };
+  }
+
+  function retryFailedTurn(turnKey) {
+    const retained = retainedRetryInput();
+    if (retained) {
+      return bag.enqueue(retained.content, {
+        mode: 'prompt',
+        id: bag.nextId(),
+        retryFailedTurn: true,
+        retryTurnId: retained.messageId,
+        retryAttemptId: retained.attemptId,
+        suppressDisplay: true,
+        skipSlashCommands: true,
+      });
+    }
     const prompt = failedTurnRetryPrompt(getState().items, turnKey);
     if (!prompt) return false;
-    if (automatic) {
-      return bag.enqueue(prompt, { mode: 'prompt', id: bag.nextId(), displayText: prompt, retryFailedTurn: true });
+    return bag.enqueue(prompt, { mode: 'prompt', id: bag.nextId(), displayText: prompt, retryFailedTurn: true });
+  }
+
+  function finishResume(id, entry, goalId = '') {
+    if (entry) cancelQuotaResumeEntry(id, { generation: entry.generation });
+    if (goalId && quotaSuspendedGoal(id, entry?.turnKey || latestFailedTurnKey(getState().items)) === goalId) {
+      forgetQuotaSuspendedGoal(id);
+    }
+  }
+
+  async function resumeGoal(id, key, goalId, entry, claim) {
+    const token = { epoch: cancelEpoch, admitted: false };
+    const generation = entry?.generation ?? null;
+    const current = () =>
+      currentId() === id &&
+      cancelEpoch === token.epoch &&
+      !flags.disposed &&
+      (flags.admission || 'open') === 'open' &&
+      latestFailedTurnKey(getState().items) === key &&
+      (quotaResumeEntry(id)?.generation ?? null) === generation;
+    const prompt = failedTurnRetryPrompt(getState().items, key);
+    const retained = retainedRetryInput();
+    flags.quotaResumePending = token;
+    let accepted = false;
+    let recoveryFailed = false;
+    try {
+      if (typeof runtime.reactivateUsageLimitedGoal !== 'function') throw new Error('Goal resume is unavailable.');
+      const goal = await runtime.reactivateUsageLimitedGoal(goalId, {
+        isCurrent: current,
+        accept: () => {
+          if (!current()) return false;
+          if ((retained || prompt) && retryFailedTurn(key) === false) return false;
+          token.admitted = true;
+          return true;
+        },
+      });
+      accepted = goal?.status === 'active' && token.admitted;
+      if (accepted) finishResume(id, entry, goalId);
+      return accepted;
+    } catch (error) {
+      recoveryFailed = error?.quotaResumeRollbackFailed === true;
+      bag.pushNotice?.(`Goal resume failed: ${error?.message || error}`, 'warn', { transcript: true });
+      throw error;
+    } finally {
+      if (!accepted && retryClaim === claim) retryClaim = '';
+      if (!recoveryFailed && flags.quotaResumePending === token) {
+        flags.quotaResumePending = null;
+        void bag.drain?.();
+        if (accepted && !retained && !prompt) bag.scheduleGoalContinuation?.();
+      }
     }
-    return submitAsync(prompt, { retryFailedTurn: true });
+  }
+
+  function hasResumeInput(key) {
+    if (retainedRetryInput()) return true;
+    if (failedTurnRetryPrompt(getState().items, key)) return true;
+    if (key.startsWith('turn:')) return false;
+    return Boolean(
+      quotaSuspendedGoal(currentId(), key) ||
+        (runtime.goalStatus?.()?.id && typeof runtime.reactivateUsageLimitedGoal === 'function')
+    );
   }
 
   return {
     publishQuotaResume,
+    reconcileQuotaResume() {
+      const items = getState().items;
+      const key = latestFailedTurnKey(items);
+      const failure = items?.findLast((item) => item?.kind === 'turndone');
+      if (!key || failure?.attemptId || !failure?.checkpointId) return false;
+      return rekeyQuotaResumeTurn(currentId(), `turn:${failure.checkpointId}`, key);
+    },
     disposeQuotaResume: unsubscribe,
 
     /** Turn close, synchronously with the failed turndone: with a known reset
@@ -198,7 +256,13 @@ export function createQuotaResumeLane(bag) {
       settlement = null;
       if (!id || !failure) return null;
       settlement = { sessionId: id, turnKey: failure.turnKey, epoch: cancelEpoch };
-      if (failure.quota.resetAt === null || !quotaAutoResumeEnabled() || agentOnly()) return null;
+      if (failure.quota.resetAt === null || !quotaAutoResumeEnabled()) return null;
+      if (!hasResumeInput(failure.turnKey)) {
+        bag.pushNotice?.('This turn cannot be resumed automatically. Send a new message to continue.', 'warn', {
+          transcript: true,
+        });
+        return null;
+      }
       return queueResume(id, failure);
     },
 
@@ -220,22 +284,24 @@ export function createQuotaResumeLane(bag) {
     /** Explicit request to auto-resume the latest quota-failed turn. */
     scheduleQuotaResume(sessionId) {
       requireAddressed(sessionId);
-      if (agentOnly()) throw new Error('agent sessions do not auto-resume; the Lead decides retries');
       const failure = latestQuotaFailure(getState().items);
       if (!failure || failure.quota.resetAt === null) {
         throw new Error('latest turn did not fail on exhausted provider quota with a known reset time');
       }
+      if (!hasResumeInput(failure.turnKey))
+        throw new Error('This turn cannot be resumed automatically. Send a new message to continue.');
       queueResume(sessionId, failure);
       return true;
     },
 
     cancelQuotaResume(sessionId) {
       requireAddressed(sessionId);
+      cancelEpoch += 1;
       cancelQuotaResumeEntry(sessionId);
       return true;
     },
 
-    /** A route change or a session clear/delete supersedes the wait. */
+    /** A session clear/delete supersedes the wait. */
     supersedeQuotaResume(sessionId) {
       if (sessionId) cancelFor(String(sessionId));
     },
@@ -248,7 +314,23 @@ export function createQuotaResumeLane(bag) {
       requireAddressed(sessionId);
       const key = String(turnKey || '');
       if (!key || retryBlocked() || latestFailedTurnKey(getState().items) !== key) return false;
-      return (await retryFailedTurn(key)) === true;
+      const claim = `${sessionId}\u0000${key}`;
+      if (retryClaim === claim) return false;
+      const goalId = quotaSuspendedGoal(sessionId, key);
+      if (!retainedRetryInput() && !failedTurnRetryPrompt(getState().items, key) && !goalId) {
+        return false;
+      }
+      retryClaim = claim;
+      const entry = quotaResumeEntry(sessionId);
+      if (goalId) return resumeGoal(sessionId, key, goalId, entry, claim);
+      let accepted = false;
+      try {
+        accepted = retryFailedTurn(key) !== false;
+        if (accepted) finishResume(sessionId, entry);
+        return accepted;
+      } finally {
+        if (!accepted && retryClaim === claim) retryClaim = '';
+      }
     },
 
     /** Scheduler fire for the entry of `generation`, after a usable reading.
@@ -258,10 +340,6 @@ export function createQuotaResumeLane(bag) {
       const id = currentId();
       const entry = quotaResumeEntry(id);
       if (!id || !entry || entry.generation !== generation) return 'stale';
-      if (agentOnly()) {
-        cancelQuotaResumeEntry(id, { generation });
-        return 'agent-session';
-      }
       const state = getState();
       if (retryBlocked()) return 'busy';
       const failure = latestQuotaFailure(state.items);
@@ -269,28 +347,29 @@ export function createQuotaResumeLane(bag) {
         cancelQuotaResumeEntry(id, { generation });
         return 'superseded';
       }
-      const route = sessionRoute();
-      if (route.routeProvider !== entry.routeProvider || route.routeModel !== entry.routeModel) {
-        cancelQuotaResumeEntry(id, { generation });
-        return 'route-changed';
-      }
       const goalId = quotaSuspendedGoal(id, entry.turnKey);
       // A user turn replays its prompt; an automatic Goal turn has no user row
       // and resumes as its Goal's next continuation.
-      const userTurn = entry.turnKey.startsWith('turn:');
-      if (userTurn ? !failedTurnRetryPrompt(state.items, entry.turnKey) : !goalId) {
+      if (!retainedRetryInput() && !failedTurnRetryPrompt(state.items, entry.turnKey) && !goalId) {
+        bag.pushNotice?.('This turn cannot be resumed automatically. Send a new message to continue.', 'warn', {
+          transcript: true,
+        });
         cancelQuotaResumeEntry(id, { generation });
         return 'unreplayable';
       }
-      if (!cancelQuotaResumeEntry(id, { generation })) return 'stale';
-      forgetQuotaSuspendedGoal(id);
-      // Queued on the Goal's mutation chain ahead of the retry turn's own
-      // start, so that turn opens on the revived Goal; the retry is busy
-      // before the revived Goal's continuation check runs, so it queues none.
-      // Without a retry the revived Goal's continuation is the one turn.
-      if (goalId) void Promise.resolve(runtime.reactivateUsageLimitedGoal?.(goalId)).catch(() => {});
-      if (!userTurn) return 'fired';
-      return retryFailedTurn(entry.turnKey, { automatic: true }) !== false ? 'fired' : 'rejected';
+      const claim = `${id}\u0000${entry.turnKey}`;
+      if (retryClaim === claim) return 'stale';
+      retryClaim = claim;
+      if (goalId)
+        return resumeGoal(id, entry.turnKey, goalId, entry, claim).then((accepted) =>
+          accepted ? 'fired' : 'rejected'
+        );
+      if (retryFailedTurn(entry.turnKey) === false) {
+        retryClaim = '';
+        return 'rejected';
+      }
+      finishResume(id, entry);
+      return 'fired';
     },
   };
 }

package/src/tui/session/session-api/commands.mjs

@@ -2,6 +2,7 @@
  * commands.mjs — the session object's long-running slash commands: memory
  * control, recall, doctor, and manual compaction (scheduled for turn end when
  * a turn is running). Each shows a command status while it holds the lock.
+ * /btw side questions (askSide/cancelSide) run beside them, lock-free.
  */
 import { compactEventDetail } from '../labels.mjs';
 import { archiveItemsForCompaction, compactionArchivedRows } from '../compaction-view.mjs';
@@ -92,16 +93,14 @@ export function createSessionCommandsApi(bag) {
     };
   };
 
-  // The compaction pass itself, under a lock its caller holds. `quiet` (the
-  // model switch's pre-compaction) asks the compactor to skip a pass that
-  // would not reduce anything and then adds no row for it.
-  async function runCompaction(startedAt, { quiet = false } = {}) {
+  // The explicit compaction pass, under a lock its caller holds.
+  async function runCompaction(startedAt) {
     // Give Ink one event-loop turn to paint the compacting spinner before
     // runtime.compact() starts synchronous session/transcript work (same
     // yield as the auto-clear path; without it /compact looks frozen with
     // no spinner until the compact already finished).
     await new Promise((resolve) => setTimeout(resolve, 0));
-    const result = await runtime.compact({ recoverAgent: true, ...(quiet ? { requireReduction: true } : {}) });
+    const result = await runtime.compact({ recoverAgent: true });
     const compactChanged = Boolean(result && !result.error && result.changed !== false);
     syncContextStats({
       allowEstimated: true,
@@ -114,16 +113,12 @@ export function createSessionCommandsApi(bag) {
         archived: compactionArchivedRows(result),
       });
       set({ items: replaceItems(items, { preserveSpill: true }) });
-    } else if (!quiet || result?.error) {
+    } else {
       pushItem(compactDoneItem(result, startedAt));
     }
     return result;
   }
 
-  // An in-place model switch compacts first on the current model (routes.mjs
-  // holds the command lock and shows the compacting status meanwhile).
-  bag.compactBeforeModelSwitch = () => runCompaction(Date.now(), { quiet: true });
-
   async function compactCommand() {
     if (getState().commandBusy) return null;
     if (getState().busy) return scheduleCompactForTurnEnd(compactCommand);
@@ -175,5 +170,14 @@ export function createSessionCommandsApi(bag) {
       });
     },
     compact: compactCommand,
+    // /btw: answered from the conversation so far while a turn keeps running.
+    // No command lock and no transcript row: the answer is only returned.
+    askSide: (question) => runtime.askSide(question),
+    // `sessionId` names the session the side question was asked in (it may
+    // no longer be the current one after a switch); omitted, the current one.
+    cancelSide: (sessionId) => {
+      if (typeof sessionId === 'string' && sessionId) runtime.cancelSide(sessionId);
+      else runtime.cancelSide();
+    },
   };
 }

package/src/tui/session/session-api/controls.mjs

@@ -67,6 +67,18 @@ export function createSessionControlsApi(bag) {
     stopShellJob: async (taskId) => {
       return (await runtime.stopShellJob?.(taskId)) ?? { stopped: false, error: 'shell job control is unavailable' };
     },
+    // Explicit force-release of a shell whose termination is unconfirmed:
+    // { released, error? }. Surfaces confirm with the user before calling.
+    releaseShellJob: async (taskId) => {
+      return (
+        (await runtime.releaseShellJob?.(taskId)) ?? { released: false, error: 'shell job control is unavailable' }
+      );
+    },
+    // This session's live shell jobs, each flagged when its termination is
+    // unconfirmed: { jobs }.
+    listShellJobs: async () => {
+      return (await runtime.listShellJobs?.()) ?? { jobs: [] };
+    },
     goalControl: async (args = {}) => {
       const result = await runtime.goalControl?.(args);
       if (['pause', 'stop'].includes(result?.action)) {
@@ -91,8 +103,8 @@ export function createSessionControlsApi(bag) {
       );
       return result;
     },
-    setCwd: (path, options = {}) => {
-      const next = runtime.setCwd(path);
+    setCwd: async (path, options = {}) => {
+      const next = await runtime.setCwd(path);
       // Republish up-arrow history for the NEW project: current session prompts
       // merged with the cwd-scoped persisted store for the new cwd.
       const sessionList = recomputePromptHistory(getState().items);

package/src/tui/session/session-api/integrations.mjs

@@ -38,8 +38,8 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
     getQuotaHistory: async (options = {}) => {
       return await runtime.getQuotaHistory?.(options);
     },
-    getSessionUsage: async () => {
-      return await runtime.getSessionUsage?.();
+    getSessionUsage: async (options = {}) => {
+      return await runtime.getSessionUsage?.(options);
     },
     consumeCodexRateLimitResetCredit: async (options = {}) => {
       // Desktop capability parity: without this delegation the session runtime
@@ -52,6 +52,12 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
     getSessionReviewDiff: async () => {
       return (await runtime.getSessionReviewDiff?.()) ?? { supported: false, files: [], patch: '' };
     },
+    getSessionReviewFilePatch: async (file, oldPath) => {
+      return (await runtime.getSessionReviewFilePatch?.(file, oldPath)) ?? { supported: false, patch: '' };
+    },
+    getTurnReviewFilePatch: async (file) => {
+      return (await runtime.getTurnReviewFilePatch?.(file)) ?? { supported: false, patch: '' };
+    },
     revertTurnReview: async (checkpointId) => {
       return await requireRuntimeMethod('revertTurnReview', 'Turn review revert is unavailable')(checkpointId);
     },
@@ -140,6 +146,7 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
       return result;
     },
     testCustomProvider: (input) => runtime.testCustomProvider(input),
+    checkCustomProviderKeyEnv: (name) => runtime.checkCustomProviderKeyEnv(name),
     discoverCustomProviderModels: (input) => runtime.discoverCustomProviderModels(input),
     saveOpenCodeGoUsageAuth: async (opts) => {
       await runtime.saveOpenCodeGoUsageAuth(opts);

package/src/tui/session/session-api/lifecycle/dispose.mjs

@@ -1,4 +1,4 @@
-// Dispose: release presence, timers, subscriptions, approvals and OAuth flows,
+// Dispose: release timers, subscriptions, approvals and OAuth flows,
 // persist steering, then close the runtime — once.
 import { flushTuiSteeringPersist } from '../../tui-steering-persist.mjs';
 
@@ -20,14 +20,6 @@ export function createDisposeAction(bag, { oauthFlows }) {
       if (flags.disposed) return;
       disposeEmit?.();
       flags.disposed = true;
-      // Release the interactive-presence beacon so a cross-open after this
-      // surface exits takes normal ownership instead of viewer-attaching to a
-      // dead owner (crash paths fall back to the 2min staleness window).
-      try {
-        runtime.clearSessionPresence?.();
-      } catch {
-        /* best-effort */
-      }
       clearToastTimers();
       disposeTranscriptSpill?.();
       disposeGoalContinuation?.();
@@ -40,6 +32,8 @@ export function createDisposeAction(bag, { oauthFlows }) {
         'unsubscribeAgentStatus',
         'unsubscribeRemoteState',
         'unsubscribeCompletionWakeGate',
+        'unsubscribeGitHeadWatch',
+        'unsubscribeWorktreeSetup',
       ]) {
         try {
           lifecycle[key]?.();

package/src/tui/session/session-api/lifecycle/resume.mjs

@@ -1,5 +1,5 @@
 // Resume: reopen a stored session, rebuild the visible transcript from its
-// messages and reconcile live-share and steering at the same boundary.
+// messages and reconcile steering at the same boundary.
 import { primeContextEstimates } from '../../../../runtime/agent/orchestrator/session/context-utils.mjs';
 import { resumedTranscriptArchive } from '../../compaction-view.mjs';
 
@@ -63,12 +63,7 @@ export function createResumeAction(bag, { restoreTranscriptItems }) {
           ...routeState(),
           stats: { ...getState().stats },
         });
-        // Reconcile the live-share legs NOW (viewer pipe attach / owner pipe
-        // start). The 3s share tick otherwise leaves a live-owned session on
-        // the stale disk snapshot and then full-swaps it seconds after entry —
-        // the visible transcript lurch. Connecting here makes the owner's
-        // full frame land at the resume boundary, so entry paints settled.
-        bag.ensureLiveShare?.();
+        bag.reconcileQuotaResume?.();
         // A shard/process restart recreates the runtime before resuming its
         // durable session. Restore accepted steering while commandBusy is
         // still held so the central release hook drains it exactly once after