mixdog 1.4.1 → 1.4.3

package/src/session-runtime/held-requests.mjs

@@ -139,11 +139,13 @@ export function createHeldRequests({
       tool: request.name,
       target: request.outbound?.target || '',
       reason: request.reason || '',
+      // The connector account the call is bound to (tool-exec.mjs).
+      account: request.account,
       ...(request.kind === 'outbound'
         ? {
             payload: request.outbound?.payload || '',
             action: request.outbound?.category,
-            account: request.outbound?.account,
+            account: request.outbound?.account || request.account,
             editable: request.outbound?.editable,
             details: request.outbound?.details,
           }

package/src/session-runtime/internal-tool-executor/ask-user-tool.mjs

@@ -8,6 +8,7 @@ import {
   ASK_USER_MAX_TEXT,
 } from '../../runtime/agent/orchestrator/runtime-core/ask-user-tool-defs.mjs';
 import { createCallerContextResolvers } from './caller-context.mjs';
+import { noteTodoUserWait } from '../../runtime/agent/orchestrator/session/loop/no-tool-turn/todo-check.mjs';
 import { runAbortable } from '../../runtime/shared/abort-race.mjs';
 import {
   HANDOFF_OUTCOMES as AGENT_OUTCOMES,
@@ -309,6 +310,8 @@ export function createAskUserToolHandlers({ rt }) {
           normalizeAskUserAnswers(result.answers, questions),
           normalizeAskUserReply(result.reply)
         );
+      // A question left unanswered: the turn may end waiting on the user.
+      noteTodoUserWait(sessionIdFor(callerCtx));
       return DISMISSED;
     },
   };

package/src/session-runtime/internal-tool-executor/bridge-tools.mjs

@@ -68,8 +68,9 @@ export function createBridgeToolHandlers({ rt }) {
     if (environmentDisabled(callerCtx, 'MIXDOG_FEATURE_VISUALIZE')) {
       throw new Error('the visualize tool is disabled in this environment');
     }
-    // A conversation keeps its frozen tool list, so honor the Settings toggle
-    // at execution time too (an env override wins, as in builtinFeatureActive).
+    // The Settings toggle at execution time too: it reaches a turn already
+    // running and callers outside the session's deny set (an env override
+    // wins, as in builtinFeatureActive).
     if (!(featureEnvOverride('MIXDOG_FEATURE_VISUALIZE') ?? moduleEnabled(rt.config, 'visualize', true))) {
       return {
         content: [

package/src/session-runtime/internal-tool-executor/feature-tools.mjs

@@ -1,19 +1,13 @@
-// Optional feature tools gated by settings for model-initiated calls: office,
-// media and tidy (each loaded on first use), and the setup tool.
+// Optional feature tools: office, media and tidy (each loaded on first use;
+// their settings gates apply in the executor), and the setup tool.
 import { standaloneDataDir } from '../runtime-paths.mjs';
 import { createCallerContextResolvers } from './caller-context.mjs';
 
-export function createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, mediaToolEnabled, tidyToolEnabled }) {
+export function createFeatureToolHandlers({ rt, setupTool }) {
   const { sessionIdFor, signalFor } = createCallerContextResolvers(rt);
-  const requireEnabled = (callerCtx, enabled, label) => {
-    if (callerCtx?.invocationSource === 'model-tool' && !enabled()) {
-      throw new Error(`${label} is disabled in settings; start a new session to refresh the tool list`);
-    }
-  };
 
   return {
     office: async (args, { callerCtx, callerCwd }) => {
-      requireEnabled(callerCtx, officeToolsEnabled, 'office');
       const { executeOfficeTool } = await import('../../runtime/office/index.mjs');
       return await executeOfficeTool(args, {
         cwd: callerCwd,
@@ -25,7 +19,6 @@ export function createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, m
       });
     },
     media: async (args, { callerCtx, callerCwd }) => {
-      requireEnabled(callerCtx, mediaToolEnabled, 'media');
       const { executeMediaTool } = await import('../../runtime/media/tool.mjs');
       const { getSession } = await import('../../runtime/agent/orchestrator/session/manager/session-crud.mjs');
       // Generation spend is attributed to the calling session in the usage ledger.
@@ -38,7 +31,6 @@ export function createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, m
       });
     },
     tidy: async (args, { callerCtx, callerCwd }) => {
-      requireEnabled(callerCtx, tidyToolEnabled, 'tidy');
       const { executeTidyTool } = await import('../../runtime/tidy/tool.mjs');
       return await executeTidyTool(args, {
         cwd: callerCwd,
@@ -50,6 +42,8 @@ export function createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, m
       await setupTool.execute(args || {}, {
         signal: signalFor(callerCtx),
         callerSessionId: callerCtx?.callerSessionId || null,
+        requestApproval: callerCtx?.toolApprovalHook || null,
+        toolCallId: callerCtx?.toolCallId || null,
       }),
   };
 }

package/src/session-runtime/internal-tool-executor/knowledge-tools.mjs

@@ -88,6 +88,14 @@ export function createKnowledgeToolHandlers({
       if (!codeGraphMod?.executeCodeGraphTool) throw new Error('code_graph runtime is not available');
       return await codeGraphMod.executeCodeGraphTool(name, args || {}, args?.cwd || callerCwd);
     },
+    explore: async (args, { callerCtx, callerCwd }) => {
+      const { runExplore } = await import('../../runtime/explore/tool.mjs');
+      return await runExplore(args || {}, {
+        cwd: callerCwd,
+        signal: signalFor(callerCtx),
+        callerSessionId: callerCtx?.callerSessionId || callerCtx?.sessionId || rt.session?.id || null,
+      });
+    },
     load_tool: toolSearch,
     Skill: (args) => skillToolContent(args?.name, activeToolSurface(), rt.mode),
   };

package/src/session-runtime/internal-tool-executor/workspace-tools.mjs

@@ -17,6 +17,7 @@ import { scheduleCallerScope } from '../services/schedule-access.mjs';
 import { worktreeCallerScope } from '../services/worktree-access.mjs';
 import { resolveHandoffAttachments, sessionRoots } from '../handoff-attachments.mjs';
 import { delegationChainOf } from '../bot-chain.mjs';
+import { openTodoItems } from '../../runtime/agent/orchestrator/runtime-core/todo-list.mjs';
 import { BOT_TARGET_ACTIONS, resolveBotTarget } from '../bot-target.mjs';
 
 const USER_TITLE_ERROR = 'session: the user already titled this session; the title was not changed';
@@ -42,6 +43,140 @@ function callerAttachmentParts(rt, args, callerCwd, surface) {
   }).parts;
 }
 
+/** `session` actions that act on another session through session control
+ *  (list, bots, read, send, cancel, delete, create, status of a target). */
+async function runSessionControl(
+  { rt, executeSessionControl, listBots, getSessionManager },
+  args,
+  { action, target, callerSessionId, callerCwd }
+) {
+  // `callerAgentId`: the bot whose conversation gets results reported
+  // back; `callerBotId`: the bot the caller acts as, attended or not,
+  // for what only a bot's own sessions allow (an effort change).
+  const callerAgentId = attendedAgentOf(rt.session);
+  const acting = resolveSessionMode({ session: rt.session });
+  const callerBotId = acting.mode === AGENT_MODE ? acting.agentId : '';
+  if (action === 'create' && !callerAgentId) {
+    throw new Error(
+      'session: create belongs to a bot conversation; delegated workers, agent task sessions and schedule/webhook runs cannot create agent task sessions'
+    );
+  }
+  // A bot id names that bot's home chat; every check below and in the
+  // control runs on the chat it resolves to.
+  const sessionTarget = BOT_TARGET_ACTIONS.has(action) && target ? await resolveBotTarget(target, listBots) : target;
+  // A task session reaches its agent only through its reported result.
+  const origin = rt.session?.taskOrigin;
+  if (
+    action === 'send' &&
+    origin &&
+    (sessionTarget === origin.sessionId || agentIdOfHomeSession(sessionTarget) === origin.agentId)
+  ) {
+    throw new Error('session: a task session reports to its agent only through its result');
+  }
+  if (typeof executeSessionControl !== 'function') {
+    throw new Error('session: cross-session control is unavailable in this runtime');
+  }
+  const { attachments, ...rest } = args || {};
+  if (attachments !== undefined && action !== 'send' && action !== 'create') {
+    throw new Error(`session: attachments apply to send and create, not action=${action}`);
+  }
+  const attachmentParts = callerAttachmentParts(rt, args, callerCwd, 'session');
+  return JSON.stringify(
+    await executeSessionControl(
+      { ...rest, action, ...(sessionTarget !== target ? { session_id: sessionTarget } : {}) },
+      {
+        callerSessionId,
+        callerAgentId,
+        callerBotId,
+        callerCwd,
+        ...(action === 'send' || action === 'create'
+          ? {
+              callerHop: turnHopOf(rt.session),
+              // The bot chain this turn acts in (bot-chain.mjs), checked
+              // against the target and carried to the turn it starts —
+              // only when the sender is a bot conversation (a bot's chat,
+              // room seat or run); any other session hands work to any
+              // bot as before, whatever started its turn (the hop limit
+              // still bounds a loop).
+              callerBotChain: callerBotId
+                ? delegationChainOf(callerSessionId, (id) =>
+                    id === rt.session?.id ? rt.session : getSessionManager()?.getSession?.(id) || null
+                  )
+                : [],
+            }
+          : {}),
+        // Whether a create may provision a worktree (worktree-access.mjs).
+        ...(action === 'create' ? { callerScope: worktreeCallerScope(rt.session) } : {}),
+        // Which bots and sessions it may see (bot-status.mjs).
+        ...(action === 'bots' || action === 'list' ? { callerScope: scheduleCallerScope(rt.session) } : {}),
+        ...(attachmentParts.length ? { attachmentParts } : {}),
+      }
+    )
+  );
+}
+
+/** `session action=rename`: the AI title of the Lead session, mirrored onto the live session. */
+async function renameSession({ rt, getSessionManager }, action, sessionId, args) {
+  if (rt.config?.aiSessionTitles === false) throw new Error('session: AI session titles are disabled in settings');
+  const title = clean(args?.title);
+  if (!title) throw new Error('session: title is required for action=rename');
+  const result = await getSessionManager()?.updateSessionAiTitle(sessionId, title);
+  if (!result?.ok) {
+    throw new Error(
+      result?.reason === 'user-title' ? USER_TITLE_ERROR : `session: rename failed (${result?.reason || 'unavailable'})`
+    );
+  }
+  // Mirror the store's truth onto the live session, never the AI title
+  // itself: a manual rename that landed while the save was awaited wins.
+  const stored = getSessionManager()?.getSession?.(sessionId);
+  if (stored && rt.session?.id === sessionId && stored !== rt.session) {
+    rt.session.title = stored.title;
+    rt.session.titleLocked = stored.titleLocked;
+    rt.session.titleSource = stored.titleSource;
+    rt.session.titleUpdatedAt = stored.titleUpdatedAt;
+  }
+  if (stored && stored.titleSource === 'user') throw new Error(USER_TITLE_ERROR);
+  return JSON.stringify({ action, sessionId, title: result.title }, null, 2);
+}
+
+/** `session action=fork`: inherit the Lead session into a new one. */
+async function forkSession(getLifecycleApi, action, sessionId, args) {
+  const lifecycle = getLifecycleApi();
+  if (typeof lifecycle?.inheritToNewSession !== 'function') {
+    throw new Error('session: fork is unavailable in this runtime');
+  }
+  const result = await lifecycle.inheritToNewSession(sessionId, {
+    compact: args?.compact === true,
+    titleSuffix: ' (Fork)',
+  });
+  return JSON.stringify(
+    { action, sourceSessionId: sessionId, sessionId: result.sessionId, compacted: result.compacted === true },
+    null,
+    2
+  );
+}
+
+/** `session action=status`: the current session's identity, folder and route. */
+function sessionStatusJson(rt, callerCtx, currentCwd) {
+  const current = rt.session;
+  return JSON.stringify(
+    {
+      sessionId: callerCtx?.callerSessionId || current?.id || null,
+      title: current?.title || null,
+      titleSource: current?.titleSource || null,
+      cwd: currentCwd,
+      project: current?.workspace?.projectPath || current?.desktopSession?.projectPath || currentCwd,
+      provider: current?.provider || null,
+      model: current?.model || null,
+      effort: current?.effort || null,
+      autoEffort: current?.autoEffort !== false,
+      fast: current?.fast === true,
+    },
+    null,
+    2
+  );
+}
+
 export function createWorkspaceToolHandlers({
   rt,
   goalRuntime,
@@ -101,70 +236,12 @@ export function createWorkspaceToolHandlers({
       (action === 'status' && target)
     ) {
       const callerSessionId = assertLead(action, callerCtx);
-      // `callerAgentId`: the bot whose conversation gets results reported
-      // back; `callerBotId`: the bot the caller acts as, attended or not,
-      // for what only a bot's own sessions allow (an effort change).
-      const callerAgentId = attendedAgentOf(rt.session);
-      const acting = resolveSessionMode({ session: rt.session });
-      const callerBotId = acting.mode === AGENT_MODE ? acting.agentId : '';
-      if (action === 'create' && !callerAgentId) {
-        throw new Error(
-          'session: create belongs to a bot conversation; delegated workers, agent task sessions and schedule/webhook runs cannot create agent task sessions'
-        );
-      }
-      // A bot id names that bot's home chat; every check below and in the
-      // control runs on the chat it resolves to.
-      const sessionTarget =
-        BOT_TARGET_ACTIONS.has(action) && target ? await resolveBotTarget(target, listBots) : target;
-      // A task session reaches its agent only through its reported result.
-      const origin = rt.session?.taskOrigin;
-      if (
-        action === 'send' &&
-        origin &&
-        (sessionTarget === origin.sessionId || agentIdOfHomeSession(sessionTarget) === origin.agentId)
-      ) {
-        throw new Error('session: a task session reports to its agent only through its result');
-      }
-      if (typeof executeSessionControl !== 'function') {
-        throw new Error('session: cross-session control is unavailable in this runtime');
-      }
-      const { attachments, ...rest } = args || {};
-      if (attachments !== undefined && action !== 'send' && action !== 'create') {
-        throw new Error(`session: attachments apply to send and create, not action=${action}`);
-      }
-      const attachmentParts = callerAttachmentParts(rt, args, callerCwd, 'session');
-      return JSON.stringify(
-        await executeSessionControl(
-          { ...rest, action, ...(sessionTarget !== target ? { session_id: sessionTarget } : {}) },
-          {
-            callerSessionId,
-            callerAgentId,
-            callerBotId,
-            callerCwd,
-            ...(action === 'send' || action === 'create'
-              ? {
-                  callerHop: turnHopOf(rt.session),
-                  // The bot chain this turn acts in (bot-chain.mjs), checked
-                  // against the target and carried to the turn it starts —
-                  // only when the sender is a bot conversation (a bot's chat,
-                  // room seat or run); any other session hands work to any
-                  // bot as before, whatever started its turn (the hop limit
-                  // still bounds a loop).
-                  callerBotChain: callerBotId
-                    ? delegationChainOf(callerSessionId, (id) =>
-                        id === rt.session?.id ? rt.session : getSessionManager()?.getSession?.(id) || null
-                      )
-                    : [],
-                }
-              : {}),
-            // Whether a create may provision a worktree (worktree-access.mjs).
-            ...(action === 'create' ? { callerScope: worktreeCallerScope(rt.session) } : {}),
-            // Which bots and sessions it may see (bot-status.mjs).
-            ...(action === 'bots' || action === 'list' ? { callerScope: scheduleCallerScope(rt.session) } : {}),
-            ...(attachmentParts.length ? { attachmentParts } : {}),
-          }
-        )
-      );
+      return runSessionControl({ rt, executeSessionControl, listBots, getSessionManager }, args, {
+        action,
+        target,
+        callerSessionId,
+        callerCwd,
+      });
     }
     // Mixy's proposals to the user (mixy-heartbeat.mjs): kept so none repeats.
     if (action === 'suggest') {
@@ -184,28 +261,7 @@ export function createWorkspaceToolHandlers({
     if (action === 'status' || action === 'list-projects' || action === 'set-project') assertLead(action, callerCtx);
     if (action === 'rename') {
       const sessionId = assertLead(action, callerCtx);
-      if (rt.config?.aiSessionTitles === false) throw new Error('session: AI session titles are disabled in settings');
-      const title = clean(args?.title);
-      if (!title) throw new Error('session: title is required for action=rename');
-      const result = await getSessionManager()?.updateSessionAiTitle(sessionId, title);
-      if (!result?.ok) {
-        throw new Error(
-          result?.reason === 'user-title'
-            ? USER_TITLE_ERROR
-            : `session: rename failed (${result?.reason || 'unavailable'})`
-        );
-      }
-      // Mirror the store's truth onto the live session, never the AI title
-      // itself: a manual rename that landed while the save was awaited wins.
-      const stored = getSessionManager()?.getSession?.(sessionId);
-      if (stored && rt.session?.id === sessionId && stored !== rt.session) {
-        rt.session.title = stored.title;
-        rt.session.titleLocked = stored.titleLocked;
-        rt.session.titleSource = stored.titleSource;
-        rt.session.titleUpdatedAt = stored.titleUpdatedAt;
-      }
-      if (stored && stored.titleSource === 'user') throw new Error(USER_TITLE_ERROR);
-      return JSON.stringify({ action, sessionId, title: result.title }, null, 2);
+      return renameSession({ rt, getSessionManager }, action, sessionId, args);
     }
     if (action === 'compact') {
       const sessionId = assertLead(action, callerCtx);
@@ -219,38 +275,10 @@ export function createWorkspaceToolHandlers({
     }
     if (action === 'fork') {
       const sessionId = assertLead(action, callerCtx);
-      const lifecycle = getLifecycleApi();
-      if (typeof lifecycle?.inheritToNewSession !== 'function') {
-        throw new Error('session: fork is unavailable in this runtime');
-      }
-      const result = await lifecycle.inheritToNewSession(sessionId, {
-        compact: args?.compact === true,
-        titleSuffix: ' (Fork)',
-      });
-      return JSON.stringify(
-        { action, sourceSessionId: sessionId, sessionId: result.sessionId, compacted: result.compacted === true },
-        null,
-        2
-      );
+      return forkSession(getLifecycleApi, action, sessionId, args);
     }
     if (action === 'status') {
-      const current = rt.session;
-      return JSON.stringify(
-        {
-          sessionId: callerCtx?.callerSessionId || current?.id || null,
-          title: current?.title || null,
-          titleSource: current?.titleSource || null,
-          cwd: currentCwd,
-          project: current?.workspace?.projectPath || current?.desktopSession?.projectPath || currentCwd,
-          provider: current?.provider || null,
-          model: current?.model || null,
-          effort: current?.effort || null,
-          autoEffort: current?.autoEffort !== false,
-          fast: current?.fast === true,
-        },
-        null,
-        2
-      );
+      return sessionStatusJson(rt, callerCtx, currentCwd);
     }
     if (action === 'list-projects') {
       return JSON.stringify(
@@ -295,9 +323,21 @@ export function createWorkspaceToolHandlers({
     goal: async (args, { name, callerCtx }) => {
       // A Goal keeps working in its session across turns: a heartbeat's would
       // run on unseen in the hidden session.
-      if (['create', 'resume'].includes(clean(args?.action).toLowerCase()) && callerIsHeartbeat(callerCtx)) {
+      const action = clean(args?.action).toLowerCase();
+      if (action === 'create' && callerIsHeartbeat(callerCtx)) {
         throw new Error(`goal: ${HEARTBEAT_NO_HANDOFF}`);
       }
+      // A completion claim with steps still open in the session's own list
+      // has not finished the work it recorded.
+      const callerSessionId = callerCtx?.callerSessionId || rt.session?.id || null;
+      if (action === 'complete' && rt.session?.id === callerSessionId) {
+        const open = openTodoItems(rt.session);
+        if (open.length) {
+          throw new Error(
+            `goal: cannot complete with ${open.length} open todo item(s) (${open.map((task) => task.content).join('; ')}); finish them, or drop or block each with its reason`
+          );
+        }
+      }
       return await goalRuntime.executeTool(name, args || {}, {
         callerSessionId: callerCtx?.callerSessionId || rt.session?.id || rt.reservedSessionId || null,
       });
@@ -308,9 +348,10 @@ export function createWorkspaceToolHandlers({
       if (['spawn', 'send'].includes((clean(args?.type) || 'spawn').toLowerCase()) && callerIsHeartbeat(callerCtx)) {
         throw new Error(`agent: ${HEARTBEAT_NO_HANDOFF}`);
       }
-      // `attachmentParts` is never the model's to set: only the resolved
-      // `attachments` reach the agent's turn.
-      const { attachments, attachmentParts: _ignored, ...rest } = args || {};
+      // `attachmentParts` and `skillSelection` are never the model's to set:
+      // only the resolved `attachments` reach the agent's turn, and its skills
+      // are selected from its whole prompt.
+      const { attachments, attachmentParts: _ignored, skillSelection: _selection, ...rest } = args || {};
       const attachmentParts = callerAttachmentParts(rt, { attachments }, callerCwd, 'agent');
       return await agentTool.execute(attachmentParts.length ? { ...rest, attachmentParts } : rest, {
         callerCwd,

package/src/session-runtime/internal-tool-executor.mjs

@@ -6,6 +6,7 @@
  * to channel tools.
  */
 import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import { settingDisabledIn } from '../runtime/agent/orchestrator/runtime-core/tool-availability.mjs';
 import { createAskUserToolHandlers } from './internal-tool-executor/ask-user-tool.mjs';
 import { createBridgeToolHandlers } from './internal-tool-executor/bridge-tools.mjs';
 import { createFeatureToolHandlers } from './internal-tool-executor/feature-tools.mjs';
@@ -19,11 +20,7 @@ export function createInternalToolExecutor({
   goalRuntime,
   agentTool,
   setupTool,
-  webSearchEnabled,
-  memoryToolsEnabled,
-  officeToolsEnabled,
-  mediaToolEnabled,
-  tidyToolEnabled = () => true,
+  featureDisallowedTools = () => [],
   getWebSearchModule,
   getMemoryModule,
   getCodeGraphModule,
@@ -42,7 +39,7 @@ export function createInternalToolExecutor({
     ...createBridgeToolHandlers({ rt }),
     ...createAskUserToolHandlers({ rt }),
     ...createReactionToolHandlers({ rt }),
-    ...createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, mediaToolEnabled, tidyToolEnabled }),
+    ...createFeatureToolHandlers({ rt, setupTool }),
     ...createKnowledgeToolHandlers({
       rt,
       getWebSearchModule,
@@ -67,24 +64,20 @@ export function createInternalToolExecutor({
     }),
   };
 
-  // Settings-disabled features are refused for model-initiated calls before
-  // any handler runs; the tool list is refreshed by a new session.
-  const guardModelCall = (name) => {
-    if ((name === 'web_search' || name === 'web_fetch') && !webSearchEnabled()) {
-      throw new Error('web search is disabled in settings; start a new session to refresh the tool list');
-    }
-    if ((name === 'memory' || name === 'recall') && !memoryToolsEnabled()) {
-      throw new Error(
-        'memory tools are disabled in settings; background memory and manual core memory remain available'
-      );
-    }
-  };
+  // A model call of a tool a setting turned off is refused at dispatch
+  // (tool-exec/dispatch.mjs settingDisabledTool, built-ins such as git
+  // included); a model-tool call reaching this executor directly takes the
+  // same check against this runtime's live gate list.
 
   return async (name, args, callerCtx = {}) => {
     const callerCwd = clean(callerCtx?.callerCwd) || rt.currentCwd;
     // The Reactions setting gates the tool whoever calls it, not only the model.
     if (name === 'react' && rt.config?.reactions === false) throw new Error('reactions are turned off in settings');
-    if (callerCtx?.invocationSource === 'model-tool') guardModelCall(name);
+    const disabled =
+      callerCtx?.invocationSource === 'model-tool' ? settingDisabledIn(name, featureDisallowedTools()) : null;
+    if (disabled) {
+      throw new Error(`${disabled} is disabled in settings by the user; do not retry unless the user turns it back on`);
+    }
     if (Object.hasOwn(handlers, name)) return handlers[name](args, { name, callerCtx, callerCwd });
     if (channels.isChannelTool(name)) {
       return await channels.execute(name, args || {});

package/src/session-runtime/lifecycle/cold-heir.mjs

@@ -35,9 +35,16 @@ const SOURCE_RUNTIME_FIELDS = [
   'toolApprovalHook',
   '_providerPrefixGuardState',
   'activeTurnCheckpoint',
+  // The source's durable transcript identity (store/transcript-durability.mjs).
+  'transcriptEpoch',
+  'turnCoverage',
   'deferredInitialRefreshPending',
   'pendingGoalReminder',
   'goalReminderRevision',
+  'goalStalledNotice',
+  // The source's own step list and its reminder cycle.
+  'todo',
+  'todoCheck',
   'pendingCacheBreakIntent',
   'contextPressureUnanchoredAfterRestart',
   'contextPressureUnanchoredReason',

package/src/session-runtime/lifecycle/memory-ingest.mjs

@@ -4,9 +4,9 @@
  */
 const INGEST_DEADLINE_MS = 2500;
 
-// 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. Deadline-capped: the row inserts are fast
+// Sessions that never compacted have no session-sourced rows unless ingested
+// here, and recall could not reconstruct the most recent conversations
+// without them. 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

package/src/session-runtime/lifecycle/session-switch/session-delete.mjs

@@ -14,6 +14,7 @@ import {
 import { SESSION_ID_PATTERN, closeManagedSession } from '../shared.mjs';
 import { replacementSessionCwd } from '../../workspace/workspace-state.mjs';
 import { isHistoricalAutomaticClosure } from '../../../runtime/agent/orchestrator/session/historical-session-closure.mjs';
+import { readSessionSidebarState } from '../../../runtime/shared/session-sidebar-host.mjs';
 
 export function createSessionDelete(deps, { cancelBackgroundTasks }) {
   const {
@@ -38,12 +39,13 @@ export function createSessionDelete(deps, { cancelBackgroundTasks }) {
   // Availability is one strict read of the session's own file, filtered like
   // the session catalog (an unreadable, foreign, closed or non-catalogued
   // record is not deletable). No catalog rebuild, no folder scan.
-  function isAvailableSession(sessionId) {
+  function availableRecord(sessionId) {
     const stored = _storedSessionFromFile(getStoreDir(), `${sessionId}.json`);
-    if (!stored || stored === STORED_SESSION_UNREADABLE) return false;
-    if (stored.closed === true && !isHistoricalAutomaticClosure(stored)) return false;
-    return leadSessionRow(stored) !== null;
+    if (!stored || stored === STORED_SESSION_UNREADABLE) return null;
+    if (stored.closed === true && !isHistoricalAutomaticClosure(stored)) return null;
+    return leadSessionRow(stored) !== null ? stored : null;
   }
+  const isAvailableSession = (sessionId) => availableRecord(sessionId) !== null;
 
   // The deleted task's worktree: the autoCleanup setting decides (clean and
   // merged → removed; otherwise kept). Off the deletion path; never fails it.
@@ -102,5 +104,51 @@ export function createSessionDelete(deps, { cancelBackgroundTasks }) {
     return true;
   }
 
-  return { releaseSessionWork, deleteSession };
+  /**
+   * The desktop's auto-delete of an archived session: only one that is still
+   * archived, not a favorite, idle (no turn running, waiting for its ask lock
+   * or queued) and unchanged since the caller looked (`expected.lastUsedAt`,
+   * which every turn moves). It holds the session's ask lock, which every
+   * turn takes, and runs its last checks, the close and the delete in one
+   * synchronous stretch, so no turn can start in between. A refusal closes
+   * and deletes nothing: `{ deleted: false, reason }`. `isHostedBusy` (the
+   * session service) reports queued input in a runtime hosting the session.
+   */
+  async function deleteSessionIfIdle(id, expected = {}, { isHostedBusy = null } = {}) {
+    const sessionId = clean(id);
+    const refuse = (reason) => ({ deleted: false, reason });
+    if (!sessionId || !SESSION_ID_PATTERN.test(sessionId)) return refuse('invalid');
+    if (typeof isHostedBusy !== 'function') return refuse('unguarded');
+    if (getSession()?.id === sessionId) return refuse('current');
+    const unlock = mgr.tryAcquireSessionLock(sessionId);
+    if (!unlock) return refuse('busy');
+    try {
+      // The archive and favorite flags are the desktop's.
+      const sidebar = await readSessionSidebarState();
+      if (!sidebar || !Object.hasOwn(sidebar.archived ?? {}, sessionId)) return refuse('not-archived');
+      if (Object.hasOwn(sidebar.favorites ?? {}, sessionId)) return refuse('favorite');
+      // From here to the delete: synchronous.
+      if (mgr.sessionLockContended(sessionId)) return refuse('turn-waiting');
+      if (mgr.isSessionTurnInFlight(sessionId) || mgr.hasUnsettledTurn(sessionId)) return refuse('busy');
+      if (mgr.hasPendingMessages(sessionId) || isHostedBusy(sessionId)) return refuse('queued');
+      const stored = availableRecord(sessionId);
+      if (!stored) return refuse('missing');
+      if ((Number(stored.lastUsedAt) || 0) !== (Number(expected?.lastUsedAt) || 0)) return refuse('changed');
+      const reason = 'desktop-auto-delete';
+      // The blocking close: its barrier lands before this stretch yields.
+      if (closeManagedSession(mgr, sessionId, reason, { tombstone: false }, false) !== true) {
+        return refuse('close-failed');
+      }
+      agentTool?.forgetLeadSession?.(sessionId);
+      releaseSessionWork(sessionId, reason);
+      if (mgr.deleteSession(sessionId, { fenceWrites: true }) !== true) return refuse('delete-failed');
+      void forgetSessionSearch(sessionId);
+      void releaseDeletedWorktree(sessionId);
+      return { deleted: true };
+    } finally {
+      unlock();
+    }
+  }
+
+  return { releaseSessionWork, deleteSession, deleteSessionIfIdle };
 }

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

@@ -15,7 +15,9 @@ export { resolveResumeCwd } from './session-switch/resume.mjs';
 
 export function createSessionSwitching(deps, { ingestSessionIntoMemory, closeSurfaceSession, cancelBackgroundTasks }) {
   const { mgr, getMode } = deps;
-  const { releaseSessionWork, deleteSession } = createSessionDelete(deps, { cancelBackgroundTasks });
+  const { releaseSessionWork, deleteSession, deleteSessionIfIdle } = createSessionDelete(deps, {
+    cancelBackgroundTasks,
+  });
   const { switchContext, newSession } = createContextSwitch(deps, {
     ingestSessionIntoMemory,
     closeSurfaceSession,
@@ -41,5 +43,14 @@ export function createSessionSwitching(deps, { ingestSessionIntoMemory, closeSur
     return mgr.prefetchSession?.(id, toolSpecForMode(getMode())) === true;
   }
 
-  return { listSessions, sessionStoreDir, deleteSession, switchContext, newSession, prefetchSession, resume };
+  return {
+    listSessions,
+    sessionStoreDir,
+    deleteSession,
+    deleteSessionIfIdle,
+    switchContext,
+    newSession,
+    prefetchSession,
+    resume,
+  };
 }