mixdog 0.9.55 → 0.9.59

package/src/runtime/shared/schedule-session-run.mjs

@@ -0,0 +1,63 @@
+/**
+ * Run a schedule as a VISIBLE Mixdog session instead of a hidden agent
+ * dispatch. Shared by the engine run-now capability and the channels-worker
+ * scheduler so both paths leave the same trail: a resumable session with
+ * owner 'user' + sourceType 'schedule' (admitted by the lead-session list
+ * filter as its own type, so it shows in desktop Recent / TUI resume), the
+ * schedule's provider/model route, and the schedule's project cwd.
+ */
+import { loadConfig } from '../agent/orchestrator/config.mjs';
+import { createSession } from '../agent/orchestrator/session/manager/session-lifecycle.mjs';
+import { askSession } from '../agent/orchestrator/session/manager/ask-session.mjs';
+import { parseScheduleModelRef } from './schedule-model-ref.mjs';
+
+/** Resolve schedule.model into a {provider,model,effort?,fast?} route. */
+export function scheduleRouteFromModelRef(modelRef, config = null) {
+  const ref = parseScheduleModelRef(modelRef);
+  if (ref && typeof ref === 'object') return ref;
+  const cfg = config || loadConfig({ secrets: false });
+  const preset = cfg.presets?.find((p) => p.id === ref || p.name === ref);
+  if (!preset) {
+    throw new Error(`schedule model "${ref}" is neither a provider/model route nor a known preset name`);
+  }
+  return {
+    provider: preset.provider,
+    model: preset.model,
+    ...(preset.effort ? { effort: preset.effort } : {}),
+    ...(preset.fast === true ? { fast: true } : {}),
+  };
+}
+
+/**
+ * Create the visible schedule session and run the prompt in it.
+ * `prompt` overrides schedule.prompt when the caller (channels worker) has
+ * already resolved/wrapped the prompt body; the override is used verbatim
+ * while the fallback gets a small origin header.
+ */
+export async function runScheduleSession(schedule, { config = null, prompt: promptOverride = null } = {}) {
+  if (!schedule?.name) throw new Error('runScheduleSession: schedule row required');
+  const prompt = String(promptOverride ?? schedule.prompt ?? '').trim();
+  if (!prompt) throw new Error(`schedule "${schedule.name}" has no instructions`);
+  if (!schedule.model) {
+    throw new Error(`schedule "${schedule.name}" has no model configured — edit it and choose a model first`);
+  }
+  const route = scheduleRouteFromModelRef(schedule.model, config);
+  const cwd = schedule.cwd ? String(schedule.cwd) : null;
+  const session = createSession({
+    provider: route.provider,
+    model: route.model,
+    ...(route.effort ? { effort: route.effort } : {}),
+    ...(route.fast === true ? { fast: true } : {}),
+    owner: 'user',
+    sourceType: 'schedule',
+    sourceName: schedule.name,
+    ...(cwd ? { cwd } : {}),
+    desktopSession: cwd
+      ? { classification: 'project', projectPath: cwd }
+      : { classification: 'task', projectPath: null },
+  });
+  // The user message is the schedule's instructions verbatim: the desktop
+  // title/preview derive from it, so no "[Scheduled task: …]" header noise.
+  const result = await askSession(session.id, prompt, null, null, cwd || undefined);
+  return { sessionId: session.id, result: String(result?.content || '') };
+}

package/src/runtime/shared/schedules-db.mjs

@@ -32,6 +32,7 @@ CREATE TABLE IF NOT EXISTS scheduler.schedules (
   target         text NOT NULL CHECK (target IN ('channel','session')),
   channel_id     text,
   model          text,
+  cwd            text,
   prompt         text NOT NULL,
   enabled        boolean NOT NULL DEFAULT true,
   status         text NOT NULL DEFAULT 'active' CHECK (status IN ('active','done')),
@@ -43,6 +44,7 @@ CREATE TABLE IF NOT EXISTS scheduler.schedules (
   updated_at     timestamptz NOT NULL DEFAULT now(),
   CONSTRAINT schedules_when_xor CHECK ((when_at IS NOT NULL) <> (when_cron IS NOT NULL))
 );
+ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS cwd text;
 `;
 
 async function getDb(dataDir = resolvePluginData()) {
@@ -79,6 +81,7 @@ function rowToDef(row) {
     target:        row.target,
     channelId:     row.channel_id,
     model:         row.model,
+    cwd:           row.cwd,
     prompt:        row.prompt,
     enabled:       row.enabled,
     status:        row.status,
@@ -91,7 +94,7 @@ function rowToDef(row) {
   };
 }
 
-const COLS = 'name, description, when_at, when_cron, timezone, target, channel_id, model, prompt, enabled, status, last_fired_at, next_fire_at, deferred_until, skipped_until, created_at, updated_at';
+const COLS = 'name, description, when_at, when_cron, timezone, target, channel_id, model, cwd, prompt, enabled, status, last_fired_at, next_fire_at, deferred_until, skipped_until, created_at, updated_at';
 
 // ---------------------------------------------------------------------------
 // Public API
@@ -126,6 +129,7 @@ export async function upsertSchedule(def, { dataDir } = {}) {
     def.target,
     def.channelId ?? null,
     def.model ?? null,
+    def.cwd ?? null,
     def.prompt,
     def.enabled ?? true,
     def.status ?? 'active',
@@ -133,8 +137,8 @@ export async function upsertSchedule(def, { dataDir } = {}) {
   ];
   const { rows } = await db.query(
     `INSERT INTO scheduler.schedules
-       (name, description, when_at, when_cron, timezone, target, channel_id, model, prompt, enabled, status, next_fire_at)
-     VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12)
+       (name, description, when_at, when_cron, timezone, target, channel_id, model, cwd, prompt, enabled, status, next_fire_at)
+     VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13)
      ON CONFLICT (name) DO UPDATE SET
        description  = EXCLUDED.description,
        when_at      = EXCLUDED.when_at,
@@ -143,6 +147,7 @@ export async function upsertSchedule(def, { dataDir } = {}) {
        target       = EXCLUDED.target,
        channel_id   = EXCLUDED.channel_id,
        model        = EXCLUDED.model,
+       cwd          = EXCLUDED.cwd,
        prompt       = EXCLUDED.prompt,
        enabled      = EXCLUDED.enabled,
        next_fire_at = EXCLUDED.next_fire_at,

package/src/runtime/shared/tool-result-summary.mjs

@@ -449,7 +449,10 @@ export function summarizeToolResult(name, args, resultText, isError = false) {
       // Agent/task result cards show only a one-liner; full report via ctrl+o.
       if (answerLine) return truncateSingleLine(stripInlineMarkdown(answerLine), AGENT_SURFACE_BRIEF_MAX);
       const task = /^agent task:\s*(\S+)/mi.exec(text);
-      const status = /^status:\s*([^\s(]+)/mi.exec(text);
+      const statusMatch = /^status:\s*([^\s(]+)/mi.exec(text);
+      // Defensive twin of the render-side guard: an envelope that still says
+      // "status: undefined"/"null" must not surface a titleized "Undefined".
+      const status = statusMatch && !/^(?:undefined|null)$/i.test(statusMatch[1]) ? statusMatch : null;
       const agent = /^agent:\s*(.+)$/mi.exec(text);
       const preset = /^preset:\s*(.+)$/mi.exec(text);
       const model = /^model:\s*(.+)$/mi.exec(text);

package/src/runtime/shared/tool-surface.mjs

@@ -602,17 +602,17 @@ export function aggregateToolCategoryEntry(name, args = {}, category = '') {
 }
 
 /**
- * Rebuild the per-category count map for the DONE state, excluding calls that
- * terminated in an error (rec.isError). Mirrors the call-time accumulation in
- * turn.mjs (sum aggregateToolCategoryEntry(...).count per key) but drops failed
- * calls so the completed label counts only successful work — across ALL
- * categories, not just Memory. The active/in-flight header keeps using the raw
- * `categories` map, so in-flight counting is unchanged.
+ * Rebuild the per-category count map for the DONE state. Counts ATTEMPTS —
+ * failed calls included — so the collapsed header total always agrees with
+ * the 'N Ok · N Failed' breakdown rendered beside it ("Ran 5 commands ·
+ * 3 Ok · 2 Failed", never "Ran 3 commands · 3 Ok · 2 Failed"). Mirrors the
+ * call-time accumulation in turn.mjs (sum aggregateToolCategoryEntry(...).count
+ * per key); outcome splitting stays in the failure detail, not the header.
  */
 export function aggregateDoneCategories(calls = []) {
   const map = new Map();
   for (const rec of calls || []) {
-    if (!rec || rec.isError) continue;
+    if (!rec) continue;
     const entry = aggregateToolCategoryEntry(rec.name, rec.args, rec.category);
     const prev = map.get(entry.key);
     map.set(entry.key, { ...entry, count: Number(prev?.count || 0) + Number(entry.count || 1) });

package/src/runtime/shared/transcript-writer.mjs

@@ -167,6 +167,22 @@ export function createTranscriptWriter({ mixdogHome, sessionId, cwd, pid } = {})
     });
   }
 
+  // User prompt row. The channel forwarder ignores plain user text rows
+  // (output-forwarder extractNewText only surfaces assistant rows and
+  // user rows carrying tool_result), so this never echoes back to the
+  // channel — it exists so the memory transcript watcher ingests BOTH
+  // sides of the conversation (user rows were previously never written,
+  // leaving recall unable to reconstruct recent sessions).
+  function appendUser(text) {
+    const value = typeof text === 'string' ? text : (text == null ? '' : String(text));
+    if (!value.trim()) return;
+    appendLine({
+      type: 'user',
+      sessionId,
+      message: { content: [{ type: 'text', text: value }] },
+    });
+  }
+
   function appendToolUse(name, input) {
     if (!name) return;
     appendLine({
@@ -217,6 +233,7 @@ export function createTranscriptWriter({ mixdogHome, sessionId, cwd, pid } = {})
     ensureTranscriptFile,
     refresh,
     appendAssistant,
+    appendUser,
     appendToolUse,
     appendToolResult,
   };

package/src/session-runtime/channel-config-api.mjs

@@ -9,6 +9,8 @@ import {
   setWebhookEnabled,
   setWebhookConfigAsync,
 } from '../standalone/channel-admin.mjs';
+import { getSchedule } from '../runtime/shared/schedules-db.mjs';
+import { runScheduleSession } from '../runtime/shared/schedule-session-run.mjs';
 
 // Channel/webhook/schedule config surface. Extracted verbatim from the runtime
 // API object; the mutating admin helpers are imported directly here and the
@@ -66,5 +68,14 @@ export function createChannelConfigApi({ flushBackendSave, channels, reloadChann
       reloadChannelsSoon();
       return result;
     },
+    async runScheduleNow(name) {
+      const id = String(name || '').trim();
+      const schedule = await getSchedule(id);
+      if (!schedule) throw new Error(`schedule "${id}" does not exist`);
+      // Runs in the engine process as a VISIBLE schedule session, so it works
+      // even while the channels worker is off and the run lands in Recent.
+      const { sessionId, result } = await runScheduleSession(schedule);
+      return { name: schedule.name, ok: true, sessionId, result };
+    },
   };
 }

package/src/session-runtime/config-helpers.mjs

@@ -114,18 +114,21 @@ const AUTO_CLEAR_DEFAULT_IDLE_MS = 60 * 60 * 1000;
 
 // Provider-aware auto-clear idle-sweep defaults. Rationale mirrors the
 // provider cache TTLs documented in agent-runtime/cache-strategy.mjs
-// (explicit breakpoint / managed-cache windows): Anthropic follows the BP4
-// messages-tail TTL (5m default cache_control window; BP1~3 stay on the 1h
-// extended TTL and are prefix-shared, so reaping at 5m only forfeits an
-// already-cold tail — see resolveLeadMessagesTtl). Gemini, xAI and Mistral
+// (explicit breakpoint / managed-cache windows): Anthropic follows the 1h BP4
+// messages-tail TTL. The 2026-07-16 6.8h trace found no intra-session gaps
+// over 1h; gaps over 5m were common for agent tool executions/reviewer
+// fix-loop reuse, and 24/25 such Lead gaps were agent waits where autoClear
+// cannot fire. Tail-cost simulation favors 1h despite its 2x write premium:
+// Lead 11.75M vs 20.11M and agents 14.46M vs 45.04M input-token equivalents,
+// because cold misses rewrite the accumulated tail. Gemini, xAI and Mistral
 // caches run ~1h, Groq's implicit cache persists ~2h, OpenAI/DeepSeek
 // key-prefix/implicit caches persist far longer (~24h), and OpenAI OAuth's
 // in-memory server cache is short-lived (~5-10min), so we round up slightly
 // to 10m to avoid sweeping a still-warm cache. Unknown/unrecognized
 // providers fall back to the 'default' 1h entry.
 export const AUTO_CLEAR_PROVIDER_IDLE_MS = Object.freeze({
-  'anthropic': 5 * 60 * 1000,
-  'anthropic-oauth': 5 * 60 * 1000,
+  'anthropic': 60 * 60 * 1000,
+  'anthropic-oauth': 60 * 60 * 1000,
   'gemini': 60 * 60 * 1000,
   'groq': 2 * 60 * 60 * 1000,
   'openai': 24 * 60 * 60 * 1000,

package/src/session-runtime/context-status.mjs

@@ -2,10 +2,13 @@ import {
   estimateRequestReserveTokens,
   estimateToolSchemaTokens,
   contextMessagesRevision,
+  providerTokenCalibration,
   resolveSessionCompactPolicy,
   summarizeContextMessages,
   toolSchemaSignature,
 } from '../runtime/agent/orchestrator/session/context-utils.mjs';
+import { SUMMARY_PREFIX } from '../runtime/agent/orchestrator/session/compact.mjs';
+import { hasUserConversationMessage } from '../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
 import {
   resolveCompactionPressureTokens,
   resolveWorkerCompactPolicy,
@@ -130,14 +133,85 @@ export function createContextStatus({
   function contextStatus() {
     const session = getSession();
     const route = getRoute();
+    const committedMessages = Array.isArray(session?.messages) ? session.messages : [];
+    const liveMessages = Array.isArray(session?.liveTurnMessages) ? session.liveTurnMessages : null;
+    const activityMessages = liveMessages || committedMessages;
+    const hasConversationActivity = hasUserConversationMessage(activityMessages)
+      || activityMessages.some((message) => (
+        message?.role === 'user'
+        && typeof message.content === 'string'
+        && message.content.startsWith(SUMMARY_PREFIX)
+      ));
+    // A route is not a conversation. Keep a pristine desktop/TUI task truly
+    // empty until the first real turn. Remote auto-start may prepare a local
+    // session shell containing system/tool templates, but those templates have
+    // not entered a provider request and must not appear as consumed context.
+    if (!session?.id || !hasConversationActivity) {
+      const emptyCompactPolicy = session
+        ? resolveWorkerCompactPolicy(session, Array.isArray(session.tools) ? session.tools : [])
+        : null;
+      const routeWindow = Math.max(0, Number(
+        session?.compactBoundaryTokens
+        || session?.contextWindow
+        || route?.contextWindow
+        || 0,
+      ));
+      return {
+        sessionId: session?.id || null,
+        provider: route.provider,
+        model: route.model,
+        cwd: getCurrentCwd(),
+        toolMode: getMode(),
+        contextWindow: routeWindow || null,
+        effectiveContextWindow: routeWindow || null,
+        rawContextWindow: routeWindow || null,
+        effectiveContextWindowPercent: null,
+        usedTokens: 0,
+        usedSource: 'empty',
+        currentEstimatedTokens: 0,
+        lastApiRequestTokens: 0,
+        lastApiRequestStale: false,
+        freeTokens: routeWindow,
+        compaction: {
+          boundaryTokens: Number(session?.compactBoundaryTokens || emptyCompactPolicy?.boundaryTokens || 0) || null,
+          triggerTokens: Number(emptyCompactPolicy?.triggerTokens || 0) || null,
+          bufferTokens: Number(emptyCompactPolicy?.bufferTokens || 0) || null,
+          bufferRatio: Number.isFinite(emptyCompactPolicy?.bufferRatio)
+            ? emptyCompactPolicy.bufferRatio
+            : null,
+          currentEstimatedTokens: 0,
+          lastApiRequestTokens: 0,
+          lastApiRequestStale: false,
+        },
+        messages: summarizeContextMessages([]),
+        request: {
+          toolSchemaTokens: 0,
+          toolSchemaBreakdown: {},
+          requestOverheadTokens: 0,
+          reserveTokens: 0,
+        },
+        usage: {
+          lastInputTokens: 0,
+          lastUncachedInputTokens: 0,
+          lastOutputTokens: 0,
+          lastCachedReadTokens: 0,
+          lastCacheWriteTokens: 0,
+          lastContextTokens: 0,
+          totalInputTokens: 0,
+          totalUncachedInputTokens: 0,
+          totalOutputTokens: 0,
+          totalCachedReadTokens: 0,
+          totalCacheWriteTokens: 0,
+        },
+      };
+    }
     // Prefer the in-flight working transcript while a turn is running so the
     // context gauge reflects LIVE growth (user turn + tool calls/results) as
     // it accumulates, instead of freezing at the pre-turn committed snapshot.
     // askSession() sets session.liveTurnMessages for the turn duration and
     // clears it on commit/cancel/error, after which we fall back to the
     // authoritative committed transcript.
-    const liveTurnMessages = Array.isArray(session?.liveTurnMessages) ? session.liveTurnMessages : null;
-    const messages = liveTurnMessages || (Array.isArray(session?.messages) ? session.messages : []);
+    const messages = activityMessages;
     const requestProvider = session?.provider || route.provider;
     // Do not even evaluate live native definitions when an in-flight request
     // scope owns the complete immutable provider surface.
@@ -185,7 +259,10 @@ export function createContextStatus({
     const workerCompactPolicy = resolveWorkerCompactPolicy(session, requestTools);
     const compactPolicy = workerCompactPolicy?.boundaryTokens
       ? workerCompactPolicy
-      : resolveSessionCompactPolicy(session || {}, compactBoundaryTokens);
+      : {
+        ...resolveSessionCompactPolicy(session || {}, compactBoundaryTokens),
+        tokenCalibration: providerTokenCalibration(session?.provider || route.provider),
+      };
     // Match the pre-provider-send auto-compact check exactly: the gauge uses
     // the same provider-baseline-or-estimate pressure, including request and
     // configured reserves, rather than a separate transcript-only estimate.

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

@@ -11,6 +11,10 @@ import {
 } from './session-text.mjs';
 import { toolSpecForMode, deferredSurfaceModeForLead } from './effort.mjs';
 import { unregisterLiveSession } from '../runtime/shared/staged-update.mjs';
+import {
+  getStoreDir,
+  listSessionHeartbeatMtimes,
+} from '../runtime/agent/orchestrator/session/store/paths-heartbeat.mjs';
 
 export function resolveResumeCwd(session, currentCwd) {
   const desktop = session?.desktopSession;
@@ -44,10 +48,90 @@ export function createLifecycleApi(deps) {
     withTeardownDeadline, closePatchRuntimeIfLoaded,
     createCurrentSession, refreshRouteEffort,
     invalidateContextStatusCache, invalidatePreSessionToolSurface,
-    applyResolvedCwd, resolveRoute, applyDeferredToolSurface, standaloneTools,
+    applyResolvedCwd, resolveRoute, applyDeferredToolSurface, getStandaloneTools,
     pushTranscriptRebind,
     notificationListeners, remoteStateListeners, desktopSession,
   } = deps;
+  const listLeadSessions = (options = {}) => {
+    const heartbeatMtimes = listSessionHeartbeatMtimes();
+    return mgr.listSessions({
+      refreshFromStorage: options?.refreshFromStorage === true,
+    }).map(s => {
+    const owner = clean(s.owner || 'user').toLowerCase();
+    if (owner && !['cli', 'user', 'mixdog', 'legacy'].includes(owner)) return null;
+    const sourceType = clean(s.sourceType || '').toLowerCase();
+    const sourceName = clean(s.sourceName || '').toLowerCase();
+    const agent = clean(s.agent || '').toLowerCase();
+    const leadish = agent === 'lead'
+      || sourceType === 'lead'
+      || (sourceType === 'cli')
+      // Schedule runs are their own visible type: they surface in desktop
+      // Recent / TUI resume next to lead sessions instead of hiding like
+      // agent dispatches.
+      || sourceType === 'schedule'
+      || (!sourceType && !sourceName && !isAgentOwner(owner));
+    if (!leadish) return null;
+    const rawPreview = s.preview || '';
+    let preview = isSessionPreviewNoise(rawPreview) ? '' : cleanSessionPreview(rawPreview);
+    let messageCount = Math.max(0, Number(s.messageCount) || 0);
+    if (!preview && Array.isArray(s.messages)) {
+      const msgs = s.messages || [];
+      const userPreviews = msgs
+        .filter(m => m && m.role === 'user')
+        .map(m => sessionMessageText(m.content))
+        .filter(text => !isSessionPreviewNoise(text))
+        .map(text => cleanSessionPreview(text))
+        .filter(Boolean);
+      preview = userPreviews[0] || '';
+      messageCount = msgs.filter(m => m && (m.role === 'user' || m.role === 'assistant')).length;
+    }
+    if (!preview && messageCount === 0) return null;
+    return {
+      id: s.id,
+      updatedAt: s.updatedAt,
+      cwd: s.cwd || '',
+      model: s.model,
+      provider: s.provider,
+      messageCount,
+      preview,
+      heartbeatAt: Math.max(
+        Number(s.lastHeartbeatAt) || 0,
+        Number(heartbeatMtimes.get(s.id)) || 0,
+      ),
+      desktopSession: s.desktopSession || null,
+    };
+    }).filter(Boolean);
+  };
+  // Persist a closing session's conversation into the memory DB. Sessions
+  // that never compacted had NO session-sourced rows (ingest_session
+  // previously ran only inside compaction), so recall could not reconstruct
+  // the most recent conversations. Best-effort and deadline-capped: the row
+  // inserts are fast and committed even if the bounded wait elapses during
+  // the trailing embedding flush (the raw-embedding backlog sweep embeds
+  // them later). Never loads the memory runtime just for this — a null
+  // module promise means memory was never used this run, so skip.
+  async function ingestSessionIntoMemory(session) {
+    try {
+      const messages = Array.isArray(session?.messages) ? session.messages : [];
+      if (!session?.id || messages.length === 0) return;
+      const modPromise = getMemoryModPromise();
+      if (!modPromise) return;
+      await withTeardownDeadline(
+        Promise.resolve(modPromise)
+          .then((mod) => (typeof mod?.handleToolCall === 'function'
+            ? mod.handleToolCall('memory', {
+              action: 'ingest_session',
+              sessionId: session.id,
+              cwd: session.cwd || getCurrentCwd(),
+              messages,
+            })
+            : null))
+          .catch(() => {}),
+        2500,
+        undefined,
+      );
+    } catch { /* best-effort: memory ingest must never break lifecycle paths */ }
+  }
   return {
     async close(reason = 'cli-exit', options = {}) {
       const detach = options?.detach === true || options?.wait === false || options?.waitForExit === false;
@@ -78,6 +162,9 @@ export function createLifecycleApi(deps) {
           );
         }
       } catch { /* best-effort: SessionEnd hook must never wedge teardown */ }
+      // Ingest the final conversation BEFORE the memory runtime stop below is
+      // kicked off, so the write happens against a live module/daemon.
+      try { await ingestSessionIntoMemory(getSession()); } catch { /* best-effort */ }
       // Teardown stays async end-to-end across every writer sharing the config
       // lock. Never start a synchronous lock wait while an in-process async
       // holder still needs the event loop to finish and release it.
@@ -189,47 +276,50 @@ export function createLifecycleApi(deps) {
       return mgr.abortSessionTurn(session.id, reason);
     },
     listSessions(options = {}) {
-      return mgr.listSessions({
-        refreshFromStorage: options?.refreshFromStorage === true,
-      }).map(s => {
-        const owner = clean(s.owner || 'user').toLowerCase();
-        if (owner && !['cli', 'user', 'mixdog', 'legacy'].includes(owner)) return null;
-        const sourceType = clean(s.sourceType || '').toLowerCase();
-        const sourceName = clean(s.sourceName || '').toLowerCase();
-        const agent = clean(s.agent || '').toLowerCase();
-        const leadish = agent === 'lead'
-          || sourceType === 'lead'
-          || (sourceType === 'cli')
-          || (!sourceType && !sourceName && !isAgentOwner(owner));
-        if (!leadish) return null;
-        let preview = cleanSessionPreview(s.preview || '');
-        let messageCount = Math.max(0, Number(s.messageCount) || 0);
-        if (!preview && Array.isArray(s.messages)) {
-          const msgs = s.messages || [];
-          const userPreviews = msgs
-            .filter(m => m && m.role === 'user')
-            .map(m => cleanSessionPreview(sessionMessageText(m.content)))
-            .filter(text => !isSessionPreviewNoise(text));
-          preview = userPreviews[userPreviews.length - 1] || userPreviews[0] || '';
-          messageCount = msgs.filter(m => m && (m.role === 'user' || m.role === 'assistant')).length;
-        }
-        if (!preview && messageCount === 0) return null;
-        return {
-          id: s.id,
-          updatedAt: s.updatedAt,
-          cwd: s.cwd || '',
-          model: s.model,
-          provider: s.provider,
-          messageCount,
-          preview,
-          desktopSession: s.desktopSession || null,
-        };
-      }).filter(Boolean);
+      return listLeadSessions(options);
+    },
+    // Desktop watcher hook: absolute path of the on-disk session store so the
+    // host can fs.watch it and push sidebar updates instead of polling.
+    sessionStoreDir() {
+      try { return getStoreDir(); } catch { return null; }
+    },
+    async deleteSession(id) {
+      const sessionId = clean(id);
+      if (!sessionId || !/^[A-Za-z0-9_-]+$/.test(sessionId)) return false;
+      const available = listLeadSessions({ refreshFromStorage: true })
+        .some(row => row.id === sessionId);
+      if (!available) return false;
+      const current = getSession();
+      if (current?.id !== sessionId) return mgr.deleteSession(sessionId) === true;
+
+      const cleanupReason = 'desktop-session-delete';
+      try {
+        cancelBackgroundTasksForLifecycle({
+          reason: cleanupReason,
+          notify: false,
+          callerSessionId: sessionId,
+        });
+      } catch {}
+      try { agentTool?.closeAll?.(cleanupReason); } catch {}
+      statusRoutes?.clearGatewaySessionRoute?.(sessionId);
+      // Active sessions retain a tombstone until the normal sweep. Unlinking
+      // immediately would let a late provider/save continuation resurrect the
+      // deleted conversation after the user has moved to its replacement.
+      if (mgr.closeSession(sessionId, cleanupReason, { tombstone: true }) !== true) return false;
+      setSession(null);
+      invalidateContextStatusCache();
+      invalidatePreSessionToolSurface();
+      await createCurrentSession();
+      pushTranscriptRebind?.();
+      return true;
     },
     async switchContext({ cwd, desktopSession: nextDesktopSession } = {}) {
       const session = getSession();
       if (session?.id) {
         const cleanupReason = 'desktop-context-switch';
+        // Fire-and-forget: context switch is user-facing latency; the memory
+        // runtime outlives the closed session so the write completes safely.
+        void ingestSessionIntoMemory(session);
         try {
           cancelBackgroundTasksForLifecycle({
             reason: cleanupReason,
@@ -247,7 +337,21 @@ export function createLifecycleApi(deps) {
       setDesktopSession(nextDesktopSession && typeof nextDesktopSession === 'object'
         ? nextDesktopSession
         : null);
-      await applyResolvedCwd(cwd, { markRefresh: false, waitForMcpReset: true });
+      // Do NOT block the switch on the project MCP reconnect (observed 5s+ per
+      // project entry on desktop). The reset still STARTS here synchronously
+      // (generation bump + in-flight registration inside applyResolvedCwd), so
+      // stale servers cannot be re-adopted, and the ask path gates boundedly on
+      // the in-flight connect before the next turn's tool surface is built.
+      await applyResolvedCwd(cwd, { markRefresh: false });
+      // Resuming a historical session temporarily routes the runtime through
+      // that session's provider/model. A fresh desktop task or project must
+      // return to the configured Lead route instead of inheriting the route
+      // of whichever session happened to be open immediately beforehand.
+      if (typeof setRoute === 'function' && typeof getConfig === 'function'
+        && typeof resolveRoute === 'function') {
+        setRoute(resolveRoute(getConfig(), {}));
+        await refreshRouteEffort?.();
+      }
       invalidateContextStatusCache();
       invalidatePreSessionToolSurface();
       return true;
@@ -255,6 +359,7 @@ export function createLifecycleApi(deps) {
     async newSession() {
       const session = getSession();
       if (session?.id) {
+        void ingestSessionIntoMemory(session);
         const tombstone = !hasUserConversationMessage(session.messages)
           && !hasUserConversationMessage(session.liveTurnMessages);
         mgr.closeSession(session.id, 'cli-new', { tombstone });
@@ -268,12 +373,20 @@ export function createLifecycleApi(deps) {
       pushTranscriptRebind?.();
       return getSession().id;
     },
+    prefetchSession(id) {
+      return mgr.prefetchSession?.(id, toolSpecForMode(getMode())) === true;
+    },
     async resume(id) {
       const prev = getSession();
       const previousId = prev?.id || null;
       const previousMessages = prev?.messages || null;
       const previousLive = prev?.liveTurnMessages || null;
-      const activeDesktopSession = getDesktopSession?.() ?? desktopSession;
+      // A context switch can deliberately clear the desktop marker for legacy
+      // sessions. Fall back to the creation-time value only for callers that
+      // do not supply mutable context bindings.
+      const activeDesktopSession = typeof getDesktopSession === 'function'
+        ? getDesktopSession()
+        : desktopSession;
       const resumeOptions = activeDesktopSession && typeof activeDesktopSession === 'object'
         ? { desktopSession: activeDesktopSession }
         : undefined;
@@ -281,6 +394,7 @@ export function createLifecycleApi(deps) {
       if (!resumed) return null;
       if (previousId && previousId !== resumed.id) {
         statusRoutes?.clearGatewaySessionRoute?.(previousId);
+        void ingestSessionIntoMemory(prev);
         const tombstone = !hasUserConversationMessage(previousMessages)
           && !hasUserConversationMessage(previousLive);
         mgr.closeSession(previousId, 'cli-resume', { tombstone });
@@ -294,7 +408,7 @@ export function createLifecycleApi(deps) {
       const session = getSession();
       session.effort = getRoute().effectiveEffort || null;
       session.cwd = getCurrentCwd();
-      applyDeferredToolSurface(session, deferredSurfaceModeForLead(getMode()), standaloneTools, { provider: getRoute().provider });
+      applyDeferredToolSurface(session, deferredSurfaceModeForLead(getMode()), getStandaloneTools(), { provider: getRoute().provider });
       invalidatePreSessionToolSurface();
       invalidateContextStatusCache();
       setSessionNeedsCwdRefresh(false);