mixdog 1.4.2 → 1.4.3

package/src/session-runtime/workspace/worktree-setup.mjs

@@ -61,8 +61,20 @@ export function createWorktreeSetup({ backend, newTxId, planWorktreeSetup, runWo
         }
       }
     };
+    if (claimed.blocked?.length) {
+      report.notes.push(
+        `Dependencies were not installed: ${claimed.blocked.join(', ')} ${claimed.blocked.length > 1 ? 'are links' : 'is a link'}, and any install here could empty the folder it points at (such as the main checkout's) through it. Remove the link (never its target); the next turn installs.`
+      );
+      session.pendingSetupNotice = { revision: Date.now(), content: worktreePreparationNote(report) };
+      return;
+    }
     try {
-      const plan = await planWorktreeSetup({ worktreeDir: here.cwd, mainDir: here.projectPath, signal });
+      const plan = await planWorktreeSetup({
+        worktreeDir: here.cwd,
+        mainDir: here.projectPath,
+        shared: claimed.shared ?? [],
+        signal,
+      });
       report.dependencyNotes = plan.notes;
       if (plan.commands.length) {
         report.installs = await runWorktreeSetup({ commands: plan.commands, signal, onProgress: emit });

package/src/session-runtime/workspace/worktree-tool.mjs

@@ -147,6 +147,11 @@ export function createWorktreeToolHost({ getSession, getWorkspaceApi, executeSes
     }
     const lane = laneFor(entry.ownerSessionId, callerSessionId, scope);
     const menu = await lane.menu();
+    // This session's worktree that it does not work in: removed where it is,
+    // without entering it (its own running workers elsewhere never block that).
+    if (lane.own && menu.workspace?.worktreeId !== entry.id) {
+      return workspaceApi().removeOwnedWorktree({ entryId: entry.id, force: request.force === true });
+    }
     if (menu.retainedWorktree?.id !== entry.id) {
       throw new Error(
         `git worktree remove: ${entry.path} is not the current worktree of session ${entry.ownerSessionId}; enter it (worktree_action enter, branch ${entry.branch}) first, then remove it`
@@ -174,6 +179,17 @@ export function createWorktreeToolHost({ getSession, getWorkspaceApi, executeSes
         return merge(lane());
       case 'remove': {
         const force = request.force === true;
+        if (request.branch) {
+          // By branch: the managed worktree of that branch this session owns.
+          const rows = await workspaceApi().listWorktrees();
+          const row = rows.find((item) => item.branch === request.branch && item.ownerSessionId === callerSessionId);
+          if (!row) {
+            throw new Error(
+              `git worktree remove: this session owns no managed worktree of branch ${request.branch}; git worktree list shows them`
+            );
+          }
+          return removePath({ path: row.path, force }, callerSessionId, scope);
+        }
         if (request.sessionId && request.sessionId !== callerSessionId) {
           const gone = await orphan((row) => row.ownerSessionId === request.sessionId);
           if (gone) return workspaceApi().removeOrphanWorktree({ entryId: gone.id, force });

package/src/standalone/daemon-agent-control.mjs

@@ -6,7 +6,7 @@
 //
 // Inputs: `getSessionService` / `getSessionRuntimeHost` (both are wired after
 // this control exists — the host takes `execute` as a constructor option), and
-// `cwd`. Output: { canonicalAgentTool, execute }.
+// `cwd`. Output: { canonicalAgentTool, execute, runForeground, dispose }.
 
 export function createCanonicalAgentControl({ getSessionService, getSessionRuntimeHost, cwd }) {
   let canonicalAgentToolPromise = null;
@@ -43,16 +43,33 @@ export function createCanonicalAgentControl({ getSessionService, getSessionRunti
     return canonicalAgentToolPromise;
   }
 
-  async function execute(args = {}, context = {}) {
-    const tool = await canonicalAgentTool();
+  /** `context` rooted at its caller session (agent-tool: the owner is the caller's root). */
+  async function scopeContext(context) {
     const sessionService = getSessionService();
     const parentSessionId = String(context?.callerSessionId || '').trim();
     await sessionService.rehydrateAgentSessions();
-    const scopedContext = {
-      ...context,
-      callerSessionId: parentSessionId || null,
-      ownerSessionId: sessionService.rootOwnerSessionId(parentSessionId),
+    return {
+      parentSessionId,
+      sessionService,
+      scopedContext: {
+        ...context,
+        callerSessionId: parentSessionId || null,
+        ownerSessionId: sessionService.rootOwnerSessionId(parentSessionId),
+      },
     };
+  }
+
+  /** One agent run to its end for a caller with no session to hand it to
+   *  (routine-executor.mjs): resolves `{ sessionId, content }`. */
+  async function runForeground(args = {}, context = {}, options = {}) {
+    const tool = await canonicalAgentTool();
+    const { scopedContext } = await scopeContext(context);
+    return await tool.runToCompletion(args, scopedContext, options);
+  }
+
+  async function execute(args = {}, context = {}) {
+    const tool = await canonicalAgentTool();
+    const { parentSessionId, sessionService, scopedContext } = await scopeContext(context);
     if (String(args?.type || '') === '__close_all') {
       await tool.closeAll?.(String(args?.reason || 'agent owner closed'), {
         callerSessionId: parentSessionId || null,
@@ -72,5 +89,5 @@ export function createCanonicalAgentControl({ getSessionService, getSessionRunti
     await tool?.disposeAsync?.({ settle: true });
   }
 
-  return { canonicalAgentTool, execute, dispose };
+  return { canonicalAgentTool, execute, runForeground, dispose };
 }

package/src/standalone/daemon-desktop-runtime.mjs

@@ -12,12 +12,13 @@
  *  this daemon's in-memory turn activity (every session runs inline here, so
  *  it is the single source of truth; worker index files only declare work). */
 async function loadSessionStoreWithRuntimeActivity() {
-  const [store, runtime, progress, tasks] = await Promise.all([
+  const [store, runtime, progress, tasks, liveState] = await Promise.all([
     import('../runtime/agent/orchestrator/session/store-summary-reader.mjs'),
     // The import-free leaf holding the runtime map: no session manager graph.
     import('../runtime/agent/orchestrator/session/manager/runtime-state.mjs'),
     import('../runtime/agent/orchestrator/session/agent-pool-progress.mjs'),
     import('../runtime/shared/background-tasks.mjs'),
+    import('../runtime/agent/orchestrator/session/store/live-state.mjs'),
   ]);
   return {
     ...store,
@@ -33,7 +34,10 @@ async function loadSessionStoreWithRuntimeActivity() {
       });
       const awaiting = tasks.activeBackgroundTaskSessionIds({ surface: 'shell', awaitedOnly: true });
       return progress.withTurnProgress(
-        rows,
+        progress.withLiveUsage(
+          progress.withLiveTodo(rows, (sessionId) => liveState._liveSessions.get(sessionId)),
+          (sessionId) => liveState._liveSessions.get(sessionId)
+        ),
         (sessionId) => runtime.runtimeState.get(sessionId),
         runtime.isTurnInFlight,
         (sessionId) => awaiting.has(sessionId)

package/src/standalone/daemon-lag-profiler.mjs

@@ -15,14 +15,14 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 export const LAG_PROFILE_FLAG_FILE = 'lag-profile.on';
-export const LAG_PROFILE_DIR_NAME = 'profiles';
-export const LAG_PROFILE_KEEP = 10;
-export const LAG_PROFILE_TOP = 15;
+const LAG_PROFILE_DIR_NAME = 'profiles';
+const LAG_PROFILE_KEEP = 10;
+const LAG_PROFILE_TOP = 15;
 export const LAG_PROFILE_SAMPLING_US = 1000;
-export const LAG_P99_THRESHOLD_MS = 1000;
+const LAG_P99_THRESHOLD_MS = 1000;
 // The owner lease's stall threshold: any window holding one logged
 // `event loop stalled` line is kept.
-export const LAG_MAX_THRESHOLD_MS = 1000;
+const LAG_MAX_THRESHOLD_MS = 1000;
 
 const PROFILE_FILE_RE = /^daemon-lag-.+\.cpuprofile$/;
 const SRC_ROOT = fileURLToPath(new URL('..', import.meta.url));
@@ -90,12 +90,12 @@ export function summarizeCpuProfile(profile, { limit = LAG_PROFILE_TOP, srcRoot
     .slice(0, limit);
 }
 
-export function formatTopEntries(entries) {
+function formatTopEntries(entries) {
   return entries.map((entry) => `${entry.label}=${Math.round(entry.ms)}ms`).join(',');
 }
 
 /** Keep only the `keep` newest daemon-lag profiles (names sort by timestamp). */
-export async function pruneProfiles(dir, keep = LAG_PROFILE_KEEP) {
+async function pruneProfiles(dir, keep = LAG_PROFILE_KEEP) {
   const names = (await fsp.readdir(dir)).filter((name) => PROFILE_FILE_RE.test(name)).sort();
   const stale = names.slice(0, Math.max(0, names.length - keep));
   for (const name of stale) await fsp.rm(path.join(dir, name), { force: true });

package/src/standalone/daemon.mjs

@@ -841,6 +841,50 @@ async function startChannelFrontDoor({ channelsRuntime, bootPhases }) {
   return bootPhases.measure('channel-transport-start', () => transport.start());
 }
 
+async function startDaemonMaintenance() {
+  const [schedule, liveness, { IN_FLIGHT_STAGES }] = await Promise.all([
+    import('../runtime/shared/maintenance-schedule.mjs'),
+    import('../runtime/agent/orchestrator/session/manager/runtime-liveness.mjs'),
+    import('../runtime/agent/orchestrator/session/manager/runtime-state.mjs'),
+  ]);
+  const entries = () => [...liveness._runtimeEntries()];
+  schedule.registerMaintenanceIdleProbe(
+    () =>
+      !entries().some(
+        ([, entry]) => (entry?.controller && !entry.controller.signal?.aborted) || IN_FLIGHT_STAGES.has(entry?.stage)
+      )
+  );
+  schedule.registerMaintenanceTask(
+    'worktree-cleanup',
+    async () => {
+      const maintenance = await import('../runtime/shared/worktrees/maintenance.mjs');
+      // Every session with an open runtime entry here counts as live, read
+      // again right before each removal (one that opened meanwhile keeps its folder).
+      const liveSessionIds = () =>
+        entries()
+          .filter(([, entry]) => entry && entry.closed !== true)
+          .map(([id]) => id);
+      const report = await maintenance.runWorktreeCleanup({
+        liveSessionIds: liveSessionIds(),
+        currentLiveSessionIds: liveSessionIds,
+      });
+      const incomplete = report.kept.filter((item) => item.reason === 'incomplete');
+      if (report.removed.length || report.errors.length || incomplete.length) {
+        log(
+          `worktree cleanup: removed ${report.removed.length}, incomplete ${incomplete.length}` +
+            `${incomplete.length ? ` (${incomplete.map((item) => item.id).join(', ')})` : ''}, errors ${report.errors.length}`
+        );
+      }
+    },
+    {
+      intervalMs: 60 * 60_000,
+      initialDelayMs: 3 * 60_000,
+      onError: (error) => log(`worktree cleanup failed: ${error?.message || error}`),
+    }
+  );
+  schedule.startMaintenanceSchedule();
+}
+
 async function main() {
   const startedAt = performance.now();
   const bootPhases = createBootPhaseProfiler({ log, startedAt });
@@ -865,14 +909,19 @@ async function main() {
     .then((maintenance) => maintenance.reconcileWorktreesAtStartup())
     .then((report) => {
       const changed = report.removed.length + report.recovered.length + report.pruned.length;
-      if (changed || report.errors.length) {
+      const incomplete = report.kept.filter((item) => item.reason === 'incomplete').length;
+      if (changed || incomplete || report.errors.length) {
         log(
           `worktree reconcile: removed ${report.removed.length}, recovered ${report.recovered.length}, ` +
-            `pruned ${report.pruned.length}, errors ${report.errors.length}`
+            `pruned ${report.pruned.length}, incomplete ${incomplete}, errors ${report.errors.length}`
         );
       }
     })
     .catch((error) => log(`worktree reconcile failed: ${error?.message || error}`));
+  // Idle-time housekeeping (shared/maintenance-schedule.mjs): the worktree
+  // cleanup's count/age limits and archive rules once the desktop (favorites)
+  // is attached, then hourly while no session is mid-turn.
+  void startDaemonMaintenance().catch((error) => log(`maintenance schedule failed: ${error?.message || error}`));
   // The daemon owns prompt attachments; its census runs off the boot path
   // (first attempt after the store's start delay, then per its interval).
   void import('../runtime/attachments/store.mjs').then((store) => store.startAttachmentGc()).catch(() => {});
@@ -1043,6 +1092,9 @@ async function main() {
     submit: async (sessionId, prompt, options) =>
       (await sessionService.submitSession({ sessionId, prompt, options }))?.accepted === true,
     abort: (sessionId) => sessionService.abortSession({ sessionId }),
+    // A routine's executor sub-agent, run to its end before its bot is woken
+    // (routine-executor.mjs); resolves `{ sessionId, content }`.
+    runAgent: (args, context, options) => agentControl.runForeground(args, context, options),
   });
   // A bot's next turn, whatever starts it, first reads the progress updates
   // queued for its thread (they wake nobody on their own).

package/src/standalone/local-session-runtime.mjs

@@ -17,6 +17,7 @@ import { createToolCardResults } from '../tui/session/tool-card-results.mjs';
 import { createAgentJobFeed } from '../tui/session/agent-job-feed.mjs';
 import { createWorktreeSetupNotices } from '../tui/session/worktree-setup-notice.mjs';
 import { createContextState } from '../tui/session/context-state.mjs';
+import { onTodoChange, todoSnapshot } from '../runtime/agent/orchestrator/runtime-core/todo-list.mjs';
 import { createSessionFlow } from '../tui/session/session-flow.mjs';
 import { createRunTurn } from '../tui/session/turn.mjs';
 import { createQuotaResumeLane } from '../tui/session/quota-resume.mjs';
@@ -147,6 +148,9 @@ export function createRuntimePulse({
   const pulse = () => {
     if (flags.disposed) return;
     if (flags.pendingSessionReset) return;
+    // A closed conversation has no session to read: republishing would blank
+    // its last todo and Goal for anyone still viewing it.
+    if (flags.admission === 'terminal') return;
     syncContextStats({ allowEstimated: true });
     publishChanged({
       ...routeState(),
@@ -385,6 +389,12 @@ export async function createLocalSessionRuntime({
     displayedExecutionNotificationKeys,
     pushNotice,
     itemIndexById,
+    // The status line's context gauge after an empty session's settings reconcile.
+    refreshContextStats: () => {
+      if (flags.disposed || flags.pendingSessionReset) return;
+      syncContextStats({ allowEstimated: true });
+      set({ stats: { ...getState().stats } });
+    },
   });
   lifecycle.unsubscribeRuntimeNotifications = subscribeRuntimeNotifications();
   if (typeof runtime.onWorktreeSetup === 'function') {
@@ -400,6 +410,12 @@ export async function createLocalSessionRuntime({
     });
   }
 
+  // A todo call republishes the list at once, not on the next 2s pulse.
+  lifecycle.unsubscribeTodo = onTodoChange(({ sessionId }) => {
+    if (flags.disposed || flags.pendingSessionReset || !sessionId || sessionId !== runtime.id) return;
+    set({ todo: todoSnapshot(runtime.session) });
+  });
+
   const { patchToolCardResult, flushToolResults } = createToolCardResults({
     getState,
     set,

package/src/standalone/session-client/daemon-unavailable.mjs

@@ -4,7 +4,7 @@
 // owner that never published, the newest candidate's exit and first stderr
 // error — so the desktop error card's details name the cause, not only the
 // symptom.
-export const DAEMON_UNAVAILABLE_MESSAGE = 'daemon session endpoint is unavailable';
+const DAEMON_UNAVAILABLE_MESSAGE = 'daemon session endpoint is unavailable';
 
 function exitCodeText(code) {
   // Windows reports NTSTATUS crash codes as large unsigned values.

package/src/standalone/session-protocol.mjs

@@ -12,6 +12,8 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'agentDefinitionPresence',
   'archivedAgentIdentities',
   'getAgentDefinition',
+  'listInstructionFiles',
+  'getInstructionFile',
   'getAgentAvatarImage',
   'getAgentConnectors',
   'getProjectConnectors',
@@ -82,6 +84,8 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getBranchMenu',
   'getProjectBranchMenu',
   'listWorktrees',
+  'previewWorktreeCleanup',
+  'getSessionWorktreeWork',
   'hooksStatus',
   'inheritancePreflight',
   'listAgents',
@@ -136,6 +140,8 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'deleteAgentDefinition',
   'restoreAgentDefinition',
   'purgeAgentDefinition',
+  'saveInstructionFile',
+  'resetInstructionFile',
   'deleteHookRule',
   'deleteMediaAsset',
   'deleteMediaAssets',
@@ -149,6 +155,9 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'checkCustomProviderKeyEnv',
   'discoverCustomProviderModels',
   'deleteSession',
+  // The desktop's auto-delete: configureSession routes it through the turn
+  // gate (session-action.mjs deleteIdleSession), never the generic lane.
+  'deleteSessionIfIdle',
   'deleteWebhook',
   'deleteWorkflow',
   'enablePluginMcp',
@@ -293,6 +302,8 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'mergeWorkspace',
   'removeWorktree',
   'pruneWorktrees',
+  'deleteWorktree',
+  'setArchivedSessionWorktrees',
 ]);
 
 export const SESSION_READ_ACTION_SET = new Set(SESSION_READ_ACTIONS);

package/src/standalone/session-service/agent-route-follow.mjs

@@ -4,21 +4,13 @@
 // on the model it started on). The latest saved route wins. A thread no
 // runtime hosts keeps its model until it is opened (the desktop refreshes it
 // then, agent-home-sessions.ts).
-import { subscribeAgentRouteChanges } from '../../session-runtime/agent-profile-changes.mjs';
+import {
+  AGENT_ROUTE_KEYS as ROUTE_KEYS,
+  subscribeAgentRouteChanges,
+} from '../../session-runtime/agent-profile-changes.mjs';
 import { agentHomeSessionId } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
 import { roomMemberOfSession } from '../../runtime/agent/orchestrator/session/agent-room.mjs';
 
-const ROUTE_KEYS = [
-  'provider',
-  'model',
-  'effort',
-  'fast',
-  'autoEffort',
-  'modelParameters',
-  'contextPercent',
-  'contextTokens',
-];
-
 /** The pick the session route API takes for a saved route. */
 function sessionRoutePick(route) {
   const pick = { sessionOnly: true };
@@ -41,29 +33,40 @@ export function createAgentRouteFollow({ sessionsById, sessionOwner, advance, pu
         if (step.changed) publishStep(entry, step);
       })
       .catch((error) => {
-        // A route the runtime refuses (provider signed out) leaves the chat on its model.
+        // A route the runtime refuses (provider signed out) leaves the chat on
+        // its model; the publication fails, so a retrying publisher sends it again.
         log(`agent route change not applied to ${sessionId}: ${error?.message || error}`);
+        throw error;
       });
   }
 
   function enqueue(sessionId, pick) {
     const queued = (tails.get(sessionId) || Promise.resolve()).then(() => apply(sessionId, pick));
-    tails.set(sessionId, queued);
-    queued.then(() => {
-      if (tails.get(sessionId) === queued) tails.delete(sessionId);
+    // A refused update never holds back the chat's later ones.
+    const tail = queued.catch(() => {});
+    tails.set(sessionId, tail);
+    tail.then(() => {
+      if (tails.get(sessionId) === tail) tails.delete(sessionId);
     });
     return queued;
   }
 
-  // Every matching chat is queued before the first await: publications queue in order.
-  function follow(agentId, route) {
+  // Every matching chat is queued before the first await: publications queue
+  // in order. Rejects once every chat settled when any refused the route.
+  async function follow(agentId, route) {
     const home = agentHomeSessionId(agentId);
-    if (!home || !route?.provider || !route?.model) return Promise.resolve();
+    if (!home || !route?.provider || !route?.model) return;
     const pick = sessionRoutePick(route);
     const queued = [...sessionsById.keys()]
       .filter((sessionId) => sessionId === home || roomMemberOfSession(sessionId)?.agentId === agentId)
       .map((sessionId) => enqueue(sessionId, pick));
-    return Promise.all(queued);
+    const failures = (await Promise.allSettled(queued)).filter((one) => one.status === 'rejected');
+    if (failures.length) {
+      throw new AggregateError(
+        failures.map((one) => one.reason),
+        `${failures.length} chat(s) of ${agentId} did not take the route`
+      );
+    }
   }
   return subscribeAgentRouteChanges(follow);
 }

package/src/standalone/session-service/agent-tree/agent-turns.mjs

@@ -6,6 +6,7 @@ import { createAgentChildFactory } from './agent-child.mjs';
 import { partialHandoffTextFromSession } from '../../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
 import { attachmentsForIntake } from '../../../runtime/attachments/store.mjs';
 import { producedFileLines } from '../../../runtime/shared/handoff-artifacts.mjs';
+import { carryReportOnError, turnReportText } from '../../../runtime/agent/orchestrator/session/loop/turn-report.mjs';
 import {
   collectUnreportedWrites,
   handoffContent,
@@ -79,7 +80,16 @@ export function createAgentTurns({
     return error;
   }
 
-  async function runAgentTurn({ session, prompt, context = null, onToolResult, onTerminalResult } = {}) {
+  async function runAgentTurn({
+    session,
+    prompt,
+    context = null,
+    onToolResult,
+    onTerminalResult,
+    // The trusted skill-selection text of the turn (a routine executor's
+    // instructions); absent selects from the whole prompt, as any turn does.
+    skillSelection,
+  } = {}) {
     await rehydrateAgentSessions();
     const sessionId = String(session?.id || session || '').trim();
     const cancelEpoch = registry.assertAdmission(sessionId);
@@ -116,11 +126,12 @@ export function createAgentTurns({
         priority: 'next',
         context,
         transcriptMeta: agentTurnTranscriptMeta(content),
+        ...(typeof skillSelection === 'string' ? { skillSelection } : {}),
         ...(entry.runtime.isWireSafe === true || typeof onToolResult !== 'function' ? {} : { onToolResult }),
       };
       const detail = await target.call(entry.runtime, content, options);
       if (detail?.status === 'failed') {
-        throw new Error(String(detail.error || 'agent session turn failed'));
+        throw carryReportOnError(new Error(String(detail.error || 'agent session turn failed')), detail.carriedReport);
       }
       if (detail?.status === 'cancelled') {
         const stop = takeWatchdogStop(sessionId) || new Error('agent session turn cancelled');
@@ -134,11 +145,12 @@ export function createAgentTurns({
         const reason = String(detail?.reason || detail?.error || '').trim();
         throw new Error(`agent turn ${status}${reason ? `: ${reason}` : ''}`);
       }
-      let result = detail?.result || { content: '' };
-      // The files the turn produced reach the owner with its handoff.
-      const report = String(result.content || '');
+      const { reportContent, ...settled } = detail?.result || { content: '' };
+      // The owner gets the turn's whole report (turn-report.mjs), with the
+      // files the turn produced.
+      const report = turnReportText({ ...settled, reportContent });
       const files = await turnArtifactLines(entry.runtime, messageStart, descriptor, report);
-      if (files.length) result = { ...result, content: [report, files.join('\n')].join('\n\n') };
+      const result = { ...settled, content: files.length ? [report, files.join('\n')].join('\n\n') : report };
       descriptor.status = 'idle';
       descriptor.stage = 'idle';
       descriptor.lastHandoff = typeof result?.content === 'string' ? result.content : '';

package/src/standalone/session-service/quota-resume.mjs

@@ -124,6 +124,15 @@ export function createQuotaResumeScheduler({
   function tick() {
     if (running) return running;
     running = (async () => {
+      // The setting turned off anywhere (another process, a hand edit), not
+      // only through setQuotaAutoResumeEnabled here: nothing pending resumes.
+      if (store.quotaAutoResumeEnabled?.() === false) {
+        if (store.listQuotaResumeEntries().length) {
+          store.cancelAllQuotaResumeEntries();
+          log('quota resume off: pending resumes cancelled');
+        }
+        return;
+      }
       for (const entry of store.listQuotaResumeEntries()) {
         if (isClosed()) return;
         if (entry.resetAt > now() || !isCurrent(store, entry)) continue;

package/src/standalone/session-service/session-calls/session-action.mjs

@@ -5,6 +5,7 @@ import { SESSION_CONFIGURE_ACTION_SET, SESSION_READ_ACTION_SET } from '../../ses
 import { annotateSpan, markPhase } from '../../../runtime/shared/slow-span.mjs';
 import { sanitizeForWire } from '../../session-wire-values.mjs';
 import { botWorkBySession } from '../../../runtime/shared/bot-owned-work.mjs';
+import { createSessionTurnGate } from './turn-gate.mjs';
 
 /** Reads a session without a live runtime answers from disk (readStoredReview). */
 const STORED_REVIEW_ACTIONS = new Set([
@@ -43,6 +44,9 @@ export function createSessionActionCalls(ctx) {
   const { bodyForClient } = ctx.projection;
   const { retainUnwatched, awaitingApprovalSessionKinds, roomHandoffQuestions } = ctx.retention;
   const { assertAvailable, hostedEntryForSession, entryForSession } = ctx.entries;
+  const { stateBusy } = ctx.retention;
+  const sessionOwner = ctx.projection?.sessionOwner;
+  const turnGate = ctx.turnGate ?? createSessionTurnGate();
 
   /** A cold session's review, read from its durable turn record (the same
    *  source a runtime loaded only to answer it would read). Bodiless: the
@@ -82,7 +86,12 @@ export function createSessionActionCalls(ctx) {
     if (storedReview && !hosted) return storedReviewResult(id, name, args, baseRevision);
     const entry = hosted || (await entryForSession(id, openHints || {}));
     assertAvailable(entry);
-    const target = entry.runtime[name];
+    // A remote read of the context status waits for an empty session's
+    // settings reconcile; the local accessor stays synchronous.
+    const target =
+      name === 'contextStatus' && typeof entry.runtime.contextStatusSettled === 'function'
+        ? entry.runtime.contextStatusSettled
+        : entry.runtime[name];
     if (typeof target !== 'function') throw new TypeError(`session action ${name} is unavailable`);
     markPhase('load');
     const value = await target.apply(entry.runtime, Array.isArray(args) ? args : []);
@@ -162,9 +171,50 @@ export function createSessionActionCalls(ctx) {
     };
   }
 
+  /** The desktop's auto-delete through the control session (`sessionId`):
+   *  `args` = [target id, { lastUsedAt }]. The target is closed to service
+   *  turn starts while the runtime's idle-only delete checks and acts
+   *  (session-delete.mjs deleteSessionIfIdle); one being admitted refuses it. */
+  async function deleteIdleSession({ sessionId, args = [], open: openHints = {}, baseRevision = null } = {}) {
+    assertAvailable();
+    const controlId = String(sessionId || '');
+    if (!controlId) throw new TypeError('sessionId is required');
+    const [target, expected] = Array.isArray(args) ? args : [];
+    const id = String(target || '');
+    const entry = await entryForSession(controlId, openHints || {});
+    assertAvailable(entry);
+    if (typeof entry.runtime.deleteSessionIfIdle !== 'function') {
+      throw new TypeError('session action deleteSessionIfIdle is unavailable');
+    }
+    let value;
+    const reopen = id ? turnGate.fence(id) : null;
+    if (!reopen) value = { deleted: false, reason: id ? 'turn-starting' : 'invalid' };
+    else {
+      try {
+        value = await entry.runtime.deleteSessionIfIdle(id, expected ?? {}, {
+          isHostedBusy: (sessionIdToCheck) => {
+            const owner = sessionOwner?.(sessionIdToCheck);
+            return Boolean(owner) && stateBusy(owner.runtime?.getState?.());
+          },
+        });
+      } finally {
+        reopen();
+      }
+    }
+    log(`session action deleteSessionIfIdle session=${id} result=${resultSummary(value?.deleted ?? value)}`);
+    const step = advanceForCaller(entry);
+    retainUnwatched(entry);
+    return {
+      value: sanitizeForWire(value) ?? null,
+      sessionId: responseSessionId(entry, controlId),
+      ...bodyForClient(step, Number.isInteger(baseRevision) ? baseRevision : null),
+    };
+  }
+
   async function configureSession(params = {}, callCtx = null) {
     const revision = Math.max(0, Number(callCtx?.revision) || 0);
     const action = params?.action;
+    if (action === 'deleteSessionIfIdle') return deleteIdleSession(params);
     // Revision 0 desktop adapters routed some reads through configure because
     // their local read list lagged the session surface. A newer daemon accepts
     // those reads without weakening the current revision's finite lanes.