mixdog 1.3.2 → 1.3.3

package/src/session-runtime/quick-model-rows/model-meta.mjs

@@ -5,10 +5,12 @@ import { getModelMetadataSync } from '../../runtime/agent/orchestrator/providers
 import { isCustomProviderName } from '../../runtime/agent/orchestrator/providers/custom-reasoning.mjs';
 
 const CUSTOM_DECLARED_FIELDS = [
+  'supportsVision',
   'supportsReasoning',
   'reasoningOptions',
   'reasoningLevels',
   'reasoningContentField',
+  'providerName',
   'hidden',
   'manual',
   'customReasoning',

package/src/session-runtime/quick-model-rows/provider-rows.mjs

@@ -22,7 +22,10 @@ function customProviderModels(provider, providerConfig, discovered = providerCac
   } catch {
     return [];
   }
-  return effectiveCustomModelRows(config, discovered, { providerId: provider });
+  const providerName = clean(config.name);
+  return effectiveCustomModelRows(config, discovered, { providerId: provider }).map((row) =>
+    providerName ? { ...row, providerName } : row
+  );
 }
 
 export function createQuickProviderRows({
@@ -53,6 +56,8 @@ export function createQuickProviderRows({
         display: model.display || model.name || modelId,
         contextWindow: model.contextWindow || meta.contextWindow || null,
         outputTokens: model.outputTokens || meta.outputTokens || null,
+        // An explicit value (an override's false included) wins; the catalog fills the rest.
+        supportsVision: model.supportsVision ?? meta.supportsVision,
         supportsReasoning: model.supportsReasoning === true || meta.supportsReasoning === true,
         supportsFunctionCalling: model.supportsFunctionCalling === true || meta.supportsFunctionCalling === true,
         supportsPromptCaching: model.supportsPromptCaching === true || meta.supportsPromptCaching === true,
@@ -78,6 +83,7 @@ export function createQuickProviderRows({
         contextWindow: meta.contextWindow || null,
         outputTokens: meta.outputTokens || null,
         latest: routeLike.latest === true,
+        supportsVision: meta.supportsVision,
         supportsReasoning: !!routeLike.effort || meta.supportsReasoning === true,
         supportsFunctionCalling: meta.supportsFunctionCalling === true,
         supportsPromptCaching: meta.supportsPromptCaching === true,

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

@@ -2,6 +2,7 @@ import { registerCacheInvalidationListener } from '../runtime/agent/orchestrator
 import { turnReviewReply } from '../runtime/shared/turn-review-reply.mjs';
 import {
   clearSessionChangeHistory,
+  forgetTurnSnapshotSession,
   getSessionReviewDiff,
   getSessionReviewFilePatch,
   getTurnChanges,
@@ -19,8 +20,10 @@ import { registerSessionPurgeHook } from '../runtime/agent/orchestrator/session/
 
 // A deleted history stays deleted for as long as its session exists; the
 // session's own deletion takes the marker — and its stored first-seen file
-// contents — with it.
+// contents — with it, and its in-memory turn, parked worker reviews and
+// bound worker trackers.
 registerSessionPurgeHook((sessionId) => {
+  forgetTurnSnapshotSession(sessionId);
   void forgetSessionChangeHistoryMarker(sessionId);
   void forgetSessionBaselines(sessionId);
 });

package/src/session-runtime/services/agent-tool/job-views/agent-list.mjs

@@ -25,11 +25,16 @@ export function isActiveWorkerRow(row = {}) {
   return !isTerminalWorkerStatus(effective);
 }
 
-function agentRow({ tag, session, runtime, progress, now, indexRow = null }) {
+function rowState(session, runtime) {
   const status = session.closed === true ? 'closed' : session.status || 'idle';
   const stage =
     session.stage ||
     (status === 'idle' || status === 'error' || status === 'closed' ? status : runtime?.stage || status);
+  return { status, stage };
+}
+
+function agentRow({ tag, session, runtime, progress, now, indexRow = null }) {
+  const { status, stage } = rowState(session, runtime);
   // Additive: the current turn's start (worker index, stamped at dispatch) so
   // surfaces time a continued worker from its turn, not from createdAt.
   const turnStartedAt = indexRow?.turnStartedAt || session.turnStartedAt || null;
@@ -76,24 +81,34 @@ export function createAgentList({ mgr, refreshTagsFromSessions, agentSessionEntr
   return function list({ scanSessions = false, context = {}, includeTerminal = false } = {}) {
     refreshTagsFromSessions({ scanSessions, context });
     const now = Date.now();
-    const rows = agentSessionEntries({ scanSessions, context }).map(({ tag, session, indexRow, loaded }) =>
-      agentRow({
-        tag,
-        session,
-        indexRow,
-        runtime: mgr.getSessionRuntime?.(session.id),
-        // A tag-bound entry is the getSession answer itself; an index row or
-        // a scanned summary is only a projection and still reads the session.
-        progress: progress.sessionProgressExtras(
-          session.id,
-          session.agent || null,
+    const rows = [];
+    for (const { tag, session, indexRow, loaded } of agentSessionEntries({ scanSessions, context })) {
+      const runtime = mgr.getSessionRuntime?.(session.id);
+      // Whether a row is listed depends on its status and stage alone, so a
+      // finished worker is dropped before its progress is read: that read
+      // loads the worker's stored session, and a Lead's status pulse (every
+      // 2 s) would otherwise read every worker it ever ran, whole transcripts
+      // on first sight, synchronously on the daemon loop.
+      if (!includeTerminal && !isActiveWorkerRow(rowState(session, runtime))) continue;
+      rows.push(
+        agentRow({
+          tag,
+          session,
+          indexRow,
+          runtime,
+          // A tag-bound entry is the getSession answer itself; an index row or
+          // a scanned summary is only a projection and still reads the session.
+          progress: progress.sessionProgressExtras(
+            session.id,
+            session.agent || null,
+            now,
+            null,
+            loaded ? { loaded: session } : {}
+          ),
           now,
-          null,
-          loaded ? { loaded: session } : {}
-        ),
-        now,
-      })
-    );
-    return includeTerminal ? rows : rows.filter((row) => isActiveWorkerRow(row));
+        })
+      );
+    }
+    return rows;
   };
 }

package/src/session-runtime/services/agent-tool/spawn-flow/job-start.mjs

@@ -9,6 +9,7 @@ import { resourceAdmission } from '../../../../runtime/shared/resource-admission
 import { clean, terminalPidForContext } from '../helpers.mjs';
 import { renderResult } from '../render.mjs';
 import { closeManagedSession } from '../../../lifecycle/shared.mjs';
+import { hopOf } from '../../../../runtime/shared/bot-hops.mjs';
 
 /** The completion callback that hands a worker's result back to its caller session; null without a handoff. */
 function handoffNotifier(handoffSessionId, notifySessionCompletion) {
@@ -30,6 +31,8 @@ export function createJobStarter({ mgr, notifyStatusChange, notifySessionComplet
       ownerSessionId: ownerSessionId || null,
       clientHostPid: clientHostPid || null,
       notifyFn: handoffNotifier(handoffSessionId, notifySessionCompletion),
+      // The turn that started the job: its completion returns at that bot-chain hop (bot-hops.mjs).
+      ...(hopOf(notifyContext?.hop) ? { hop: notifyContext.hop } : {}),
     };
     const jobMeta = sanitizeTaskMeta({
       ...(meta || {}),

package/src/session-runtime/services/provider-admin.mjs

@@ -442,6 +442,7 @@ function publicCustomModelRows(rows) {
     model.hidden = item.hidden === true;
     model.manual = item.manual === true;
     for (const key of [
+      'supportsVision',
       'supportsReasoning',
       'reasoningOptions',
       'reasoningLevels',
@@ -588,7 +589,8 @@ async function modelProxyProviderSetup(options) {
       });
   const custom = Object.entries(providers)
     .filter(([id, entry]) => isCustomProviderId(id) && entry?.type === 'custom')
-    .map(([id]) => ({ id, name: id }));
+    // Older desktops advertise no name: the id is the fallback.
+    .map(([id, entry]) => ({ id, name: (typeof entry.name === 'string' && entry.name.trim()) || id }));
   return {
     managedByClient: true,
     api: [...project(API_PROVIDERS, 'api', 'api-key'), ...project(custom, 'api', 'custom')],
@@ -1111,7 +1113,15 @@ export async function saveCustomProvider(cfgMod, rawInput) {
   return typed ? serializeCustomKeySave(id, commit) : commit();
 }
 
-const MODEL_PATCH_KEYS = new Set(['manual', 'hidden', 'name', 'contextWindow', 'maxOutputTokens', 'reasoning']);
+const MODEL_PATCH_KEYS = new Set([
+  'manual',
+  'hidden',
+  'name',
+  'contextWindow',
+  'maxOutputTokens',
+  'supportsVision',
+  'reasoning',
+]);
 const REASONING_PATCH_KEYS = new Set(['levels', 'wireFormat', 'wireValues', 'replay']);
 
 // Tri-state merge: undefined preserves, null deletes the property, a value replaces it.

package/src/session-runtime/services/worktree-access.mjs

@@ -0,0 +1,27 @@
+// Who may change worktrees from a chat (the git tool's managed-worktree
+// operations, the daemon's cross-session `worktree` control). A worktree
+// mutation — entering, returning, merging, removing, pruning, `git worktree
+// add/remove`, a snapshot — runs only in a conversation session: a Lead
+// session of the desktop or TUI, or a bot's chat. Unattended runs (schedules,
+// webhooks, routines, room seats) are refused by the run's trusted identity;
+// delegated workers have no worktree host at all. Listing stays open.
+//
+// The scope is the session-level caller scope (schedule-access.mjs
+// scheduleCallerScope: the session's provenance and its unattended-run mark),
+// never anything the model or a message supplies.
+import { scheduleCallerScope } from './schedule-access.mjs';
+
+/** `{ kind, agentId?, unattended?, attended }` of a calling session record. */
+export function worktreeCallerScope(session) {
+  const scope = scheduleCallerScope(session);
+  const attended = (scope.kind === 'human' || scope.kind === 'agent') && scope.unattended !== true;
+  return { ...scope, attended };
+}
+
+/** Throws unless `scope` (worktreeCallerScope) may change worktrees; `what` names the refused action. */
+export function assertWorktreeMutationAllowed(scope, what) {
+  if (scope?.attended === true) return;
+  throw new Error(
+    `${what} changes worktrees only in a conversation session (a Lead session or a bot chat); schedule, webhook, routine and room runs may only list them`
+  );
+}

package/src/session-runtime/session-hooks.mjs

@@ -5,9 +5,6 @@
 // facade's hookCommonPayload / currentCwd accessor + the session itself. All
 // properties are non-enumerable/configurable/writable so the loop/manager can
 // read them by name without changing session enumeration.
-import { roomMemberOfSession } from '../runtime/agent/orchestrator/session/agent-room.mjs';
-import { roomMemberToolDecision } from './room-member-gate.mjs';
-
 export function attachSessionHooks(session, { hooks, hookCommonPayload, getCwd }) {
   const identity = (input) => ({
     session_id: input?.sessionId || input?.session_id || session?.id,
@@ -28,26 +25,21 @@ export function attachSessionHooks(session, { hooks, hookCommonPayload, getCwd }
   // rejection cannot escape the tool loop or the compaction flow.
   const dispatcher = (event, payload) => (input) => hooks.dispatch(event, hookCommonPayload(payload(input)));
 
-  // PreToolUse bridge. A group-room member's mutating calls always ask the
-  // user (room-member-gate.mjs), whatever the hooks decided short of a deny.
-  define('beforeToolHook', async (input, options = {}) => {
-    const name = input?.name || input?.tool_name;
-    const args = input?.args || input?.tool_input;
-    const cwd = input?.cwd || getCwd();
-    const decision = await hooks.beforeTool(
+  // PreToolUse bridge. A group-room member follows the same rules as its
+  // agent's home thread: no room-only approval on top.
+  define('beforeToolHook', async (input, options = {}) =>
+    hooks.beforeTool(
       hookCommonPayload({
         ...input,
         session_id: input?.sessionId || input?.session_id || session?.id,
-        tool_name: name,
-        tool_input: args,
+        tool_name: input?.name || input?.tool_name,
+        tool_input: input?.args || input?.tool_input,
         tool_use_id: input?.toolCallId || input?.tool_use_id,
-        cwd,
+        cwd: input?.cwd || getCwd(),
       }),
       options
-    );
-    if (!roomMemberOfSession(session?.id)) return decision;
-    return roomMemberToolDecision({ name, args, cwd }, decision);
-  });
+    )
+  );
   // PostToolUse: bridge runtime tool completions to the standard hook bus.
   define('afterToolHook', dispatcher('PostToolUse', toolPayload));
   // PostToolUseFailure: dispatched by loop.mjs only when a tool execution

package/src/session-runtime/settings-builtin-tools-api.mjs

@@ -19,6 +19,7 @@ import {
   effortJudgeAvailable,
   effortJudgeInfo,
   effortJudgeInstalling,
+  effortJudgeLastError,
   effortJudgeReady,
   shutdownEffortJudge,
 } from '../runtime/effort-judge/judge-client.mjs';
@@ -178,6 +179,7 @@ export function createBuiltinToolSettings(
           installed: effortJudgeAvailable(),
           installing: effortJudgeInstalling(),
           ready: effortJudgeReady(),
+          lastError: effortJudgeLastError(),
           info: effortJudgeInfo(),
         },
       };

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

@@ -38,6 +38,10 @@ const PROFILE_VALUE_IDS = Object.freeze({
 });
 
 const ACTION_APPLIES_TO = {
+  set_agent_route:
+    "the bot's chats from their next turn (a running turn finishes on the old model); an agent switched on or off reaches open conversations from their next turn as an agent list reminder",
+  set_orchestration_mode:
+    "new sessions and an empty current one (the default mode); a conversation keeps its own mode until it is switched with the composer's mode selector",
   set_recap_enabled: 'background Memory cycles; no restart required',
   set_auto_update: 'subsequent automatic update checks',
   set_worktree_settings: 'new tasks and worktrees created afterwards; existing worktrees are unchanged',

package/src/session-runtime/setup-tool/settings-contract.mjs

@@ -223,6 +223,9 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
     turnNotifications: boolean,
     usagePinned: boolean,
     usageRailShortLong: boolean,
+    usageAccountsExpanded: boolean,
+    usageRailSlotsThree: boolean,
+    usageRailSlotsAll: boolean,
     computerObserveOnly: boolean,
     browserAutoSignIn: boolean,
     notificationVolume: {

package/src/session-runtime/tool-policy/agent-profile-fold.mjs

@@ -2,6 +2,8 @@
 // changes (a switched workflow or mode, moved tool gates, changed shipped
 // rules) in where the provider cache is cold anyway.
 import { sessionHasConversationMessages } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import { ORCHESTRATION_MODES } from '../../runtime/shared/orchestration.mjs';
+import { orchestrationModeFromPrompt } from '../../runtime/agent/orchestrator/session/manager/orchestration-mode-switch-notice.mjs';
 import { promptRulesRevision } from '../../runtime/agent/orchestrator/session/manager/rules-cache.mjs';
 import { isAgentOwner } from '../../runtime/agent/orchestrator/agent-owner.mjs';
 import { AGENT_MODE, sessionModeOf } from '../../runtime/agent/orchestrator/session/agent-mode.mjs';
@@ -15,6 +17,7 @@ import {
   agentMcpToolPermission,
   connectorPolicyAgentOf,
 } from '../../runtime/agent/orchestrator/mcp/agent-connectors.mjs';
+import { agentListEntries } from '../../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
 import { markToolSurfaceMigrated } from '../../runtime/agent/orchestrator/session/loop/tool-exposure-migration.mjs';
 import {
   agentProfileRevision,
@@ -50,6 +53,27 @@ const promptPrefix = (session) =>
 const rulesStale = (session) =>
   sessionModeOf(session) === AGENT_MODE && session.rulesRevision !== promptRulesRevision();
 
+// Before session-local modes were used by profile refreshes, changing the
+// roster could replace a coding Lead's mode rules with the configured default
+// while leaving its selected mode intact. This is not a normal mode overlay:
+// repair only a known generated mismatch, with no user switch still pending.
+function orchestrationRecoveryNeeded(session) {
+  if (
+    !session?.promptIdentity ||
+    session.promptIdentity.skipAgentRules ||
+    isAgentOwner(session) ||
+    sessionModeOf(session) === AGENT_MODE ||
+    !ORCHESTRATION_MODES.includes(session.orchestrationMode) ||
+    session.workflowOverlay ||
+    session.orchestrationModeOverlay ||
+    session.pendingWorkflowId !== undefined ||
+    session.pendingOrchestrationMode !== undefined
+  )
+    return false;
+  const presented = orchestrationModeFromPrompt(session);
+  return presented !== null && presented !== session.orchestrationMode;
+}
+
 // Changes the prompt does not carry yet: a workflow switched mid-conversation,
 // a bot's tool gates that moved, or shipped rules a release changed.
 const foldPending = (session) =>
@@ -130,6 +154,35 @@ function stageLiveToolChanges({ liveDeniedTools, modelStandaloneTools }, session
   return true;
 }
 
+// A coding Lead keeps `agent` whichever agents exist (workflow.mjs
+// workflowDisallowsAgentTool); a denial a session recorded under the older
+// rule, because no agent was enabled, is lifted as the live policy no longer
+// holds it: the tool becomes reachable by deferred loading and the next
+// turn's deferred_tools_delta names it. Nothing in the request prefix moves.
+// Returns true when the session changed.
+function liftAgentDenial({ liveDeniedTools, modelStandaloneTools }, session) {
+  const disallowed = (session.disallowedTools || []).map(String);
+  const overlayDenied = (session.workflowOverlay?.deniedTools || []).includes('agent');
+  if (!disallowed.includes('agent') && !overlayDenied) return false;
+  if (liveDeniedTools(session, session.workflow).includes('agent')) return false;
+  const known = new Map(schemaTools(session).map((tool) => [toolName(tool), tool]));
+  if (!known.has('agent')) {
+    const fresh = modelStandaloneTools().filter((tool) => toolName(tool) === 'agent');
+    if (!fresh.length) return false;
+    session.deferredToolCatalog = [...(session.deferredToolCatalog || []), ...fresh];
+    known.set('agent', fresh[0]);
+  }
+  session.disallowedTools = disallowed.filter((name) => name !== 'agent');
+  if (overlayDenied) {
+    session.workflowOverlay.deniedTools = session.workflowOverlay.deniedTools.filter((name) => name !== 'agent');
+  }
+  mergePendingDeferredToolDelta(session, {
+    added: [{ name: 'agent', description: known.get('agent')?.description || '' }],
+  });
+  session.updatedAt = Date.now();
+  return true;
+}
+
 export function createAgentProfileFold({
   getSession,
   getConfig,
@@ -189,9 +242,11 @@ export function createAgentProfileFold({
    * anything it embeds changed; a delegated worker keeps its prompt. The core
    * is rebuilt like a workflow switch's (the session's own workflow, the
    * workspace slices the model was told) and replaces the stored one, so the
-   * next turn sends it with one provider cache break; nothing is re-read per
-   * turn. That rewrite is immediate (one tagged cache break) and takes every
-   * pending fold with it (foldPrompt), moving all stamps.
+   * next turn sends it with one provider cache break. The prompt is not re-embedded
+   * per turn, but currentAgents() does resolve the agent catalog at each
+   * turn's preparation (for the listing reminder). That rewrite is immediate
+   * (one tagged cache break) and takes every pending fold with it
+   * (foldPrompt), moving all stamps.
    * What is not an edit never touches the prefix: a bot thread's feature gates
    * and connectors are staged live (stageLiveToolChanges), and shipped rules a
    * release changed wait silently; both are folded in at the next cold point
@@ -210,22 +265,29 @@ export function createAgentProfileFold({
     const workflowConfig = configForSession(getConfig(), promptWorkflowOf(session)?.id, promptMode(session));
     const { leadPromptParts, summary: workflow } = activeWorkflowContext(workflowConfig, getDataDir());
     const roster = leadRosterRevision(leadPartsFor(session, leadPromptParts));
-    const edited = session.agentProfileRevision !== revision || session.agentRosterRevision !== roster;
+    const recoverMode = orchestrationRecoveryNeeded(session);
+    // A coding Lead hears of its agents through the listing reminder each
+    // turn carries (agent-listing-notice.mjs), never a rewritten prompt;
+    // syncAgentListing only lifts a stale `agent` denial.
+    const edited =
+      recoverMode || session.agentProfileRevision !== revision || (agentMode && session.agentRosterRevision !== roster);
     // At a turn's start its own turn is the one counted; nothing runs yet.
     const busy = () => getSession?.() !== session || (trigger !== 'turn' && turnInFlight(session));
     if (busy()) {
       agentProfilePending = true;
       return false;
     }
-    const toolsChanged =
-      agentMode &&
-      stageLiveToolChanges({ liveDeniedTools, modelStandaloneTools }, session, workflow, {
-        edited: session.agentProfileRevision !== revision,
-      });
+    const toolsChanged = agentMode
+      ? stageLiveToolChanges({ liveDeniedTools, modelStandaloneTools }, session, workflow, {
+          edited: session.agentProfileRevision !== revision,
+        })
+      : trigger === 'resume' && syncAgentListing(session);
     if (!edited) return (trigger === 'resume' && (await foldPromptIfCold())) || toolsChanged;
     // A coding session from before profile stamps keeps its prompt when it
     // is reopened; a saved edit still reaches it.
-    if (session.agentProfileRevision === undefined && trigger === 'resume' && !agentMode) return toolsChanged;
+    if (session.agentProfileRevision === undefined && trigger === 'resume' && !agentMode && !recoverMode) {
+      return toolsChanged;
+    }
     if (foldPending(session)) {
       await foldPrompt(session, AGENT_PROFILE_INTENT);
       return true;
@@ -241,7 +303,7 @@ export function createAgentProfileFold({
     if (staged.core === presentedBp3Core(session)) return toolsChanged;
     rewriteConversationBp3Core(session, staged.core);
     // The request prefix changed: one cache break, tagged on the next send.
-    markToolSurfaceMigrated(session, AGENT_PROFILE_INTENT);
+    markToolSurfaceMigrated(session, recoverMode ? PROMPT_FOLD_INTENT : AGENT_PROFILE_INTENT);
     return true;
   }
 
@@ -254,12 +316,34 @@ export function createAgentProfileFold({
     if (session?.id && sessionModeOf(session) === AGENT_MODE && !Array.isArray(session.agentConnectorTools)) {
       session.agentConnectorTools = connectorTools(session, schemaTools(session).map(toolName));
     }
-    if (agentProfilePending) {
+    if (agentProfilePending || orchestrationRecoveryNeeded(session)) {
       agentProfilePending = false;
       changed = await refreshAgentProfile({ trigger: 'turn' });
     }
-    return (await foldPromptIfCold()) || changed;
+    changed = (await foldPromptIfCold()) || changed;
+    return syncAgentListing(session) || changed;
+  }
+
+  // A coding Lead hears of its agents through the agent list reminder.
+  const codingLead = (session) =>
+    Boolean(session?.id && session.promptIdentity && !isAgentOwner(session) && sessionModeOf(session) !== AGENT_MODE);
+
+  /** A coding Lead keeps `agent` reachable (liftAgentDenial). Returns true
+   *  when the session changed. */
+  function syncAgentListing(session) {
+    return codingLead(session) && liftAgentDenial({ liveDeniedTools, modelStandaloneTools }, session);
+  }
+
+  /** The agents a coding Lead may delegate to now, as its prompt would list
+   *  them: the turn's input to the agent list reminder (manager/
+   *  agent-listing-notice.mjs); undefined for any other session. */
+  function currentAgents() {
+    const session = getSession?.();
+    if (!codingLead(session)) return undefined;
+    const config = configForSession(getConfig(), session.workflow?.id, currentMode(session));
+    const { leadPromptParts } = activeWorkflowContext(config, getDataDir());
+    return agentListEntries(leadPartsFor(session, leadPromptParts).agentCatalogContext) || [];
   }
 
-  return { refreshAgentProfile, applyPendingAgentProfile };
+  return { refreshAgentProfile, applyPendingAgentProfile, currentAgents };
 }

package/src/session-runtime/tool-policy/policy-stage.mjs

@@ -1,6 +1,9 @@
 // Staging and applying the tool/prompt policy a config gives a Lead session:
 // the tools it is denied, its BP1 rules and its BP3 core.
-import { toSessionWorkflowMeta } from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
+import {
+  toSessionWorkflowMeta,
+  workflowDisallowsAgentTool,
+} from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
 import {
   applyDeferredToolSurface,
   filterDisallowedTools,
@@ -20,7 +23,10 @@ import { finalizeSessionToolList } from '../../runtime/agent/orchestrator/sessio
 import { isAgentOwner } from '../../runtime/agent/orchestrator/agent-owner.mjs';
 import { AGENT_MODE, sessionModeOf } from '../../runtime/agent/orchestrator/session/agent-mode.mjs';
 import { unusedModelEditToolName } from '../../runtime/shared/edit-tool-dialect.mjs';
-import { withPresentedWorkspaceSlices } from '../../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
+import {
+  presentedAgentCatalogSlice,
+  withPresentedWorkspaceSlices,
+} from '../../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
 import { leadPartsFor, rewriteSystemHeading, toolNames } from './surface-helpers.mjs';
 
 export function createPolicyStage({
@@ -34,12 +40,14 @@ export function createPolicyStage({
   activeWorkflowContext,
 }) {
   // The tools `session` is denied now: its caller's denials, the feature gates
-  // as they stand, and the agent tool when its workflow delegates to no one.
+  // as they stand, and an agent-mode Lead's agent tool when its workflow
+  // delegates to no one (a coding Lead keeps it: workflow.mjs
+  // workflowDisallowsAgentTool).
   function liveDeniedTools(session, workflow) {
     return [
       ...session.callerDisallowedTools,
       ...featureDisallowedTools(),
-      ...(workflow?.delegatesAgents === false ? ['agent'] : []),
+      ...(workflowDisallowsAgentTool(workflow, { agentMode: sessionModeOf(session) === AGENT_MODE }) ? ['agent'] : []),
     ]
       .map((name) => String(name || ''))
       .filter(Boolean);
@@ -100,7 +108,17 @@ export function createPolicyStage({
     } = activeWorkflowContext(config, getDataDir());
     const sessionMode = sessionModeOf(session);
     const agentMode = sessionMode === AGENT_MODE;
-    const leadWorkflowParts = ownerIsAgent ? {} : leadPartsFor(session, leadPromptParts);
+    // A coding Lead's conversation keeps the agent list it was built with, as
+    // it keeps the workspace slices: agents switched on or off since reach it
+    // as reminders on top of that list (agent-listing-notice.mjs). A slice
+    // that is not one generated list is rebuilt as before.
+    const presentedCatalog = conversation && !agentMode ? presentedAgentCatalogSlice(session) : null;
+    const leadWorkflowParts = ownerIsAgent
+      ? {}
+      : {
+          ...leadPartsFor(session, leadPromptParts),
+          ...(presentedCatalog !== null ? { agentCatalogContext: presentedCatalog } : {}),
+        };
     const denied = liveDeniedTools(session, workflow);
 
     const baseRules =

package/src/session-runtime/tool-policy-refresh.mjs

@@ -101,5 +101,6 @@ export function createToolPolicyRefresh({
     applyPendingSessionSwitches: switches.applyPendingSessionSwitches,
     refreshAgentProfile: profile.refreshAgentProfile,
     applyPendingAgentProfile: profile.applyPendingAgentProfile,
+    currentAgents: profile.currentAgents,
   };
 }

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

@@ -17,6 +17,7 @@ import {
 import { workflowDisallowsAgentTool } from '../runtime/agent/orchestrator/runtime-core/workflow.mjs';
 import { promptWorkflowOf } from '../runtime/agent/orchestrator/session/manager/workflow-switch-notice.mjs';
 import { configuredOrchestrationMode } from '../runtime/shared/orchestration.mjs';
+import { isAgentModeSession } from '../runtime/agent/orchestrator/session/agent-mode.mjs';
 
 export function createToolSurface({
   mgr,
@@ -36,15 +37,18 @@ export function createToolSurface({
 }) {
   let preSessionSurface = null;
 
-  // A live session keeps its frozen capability (the workflow its prompt was
-  // built with, even after a mid-conversation switch); a new session uses
-  // current agents. Solo still offers the tool (deferred) for explicit user requests.
+  // A coding Lead keeps `agent` whichever agents exist (the agents reach it as
+  // a listing reminder); Solo still offers it (deferred) for explicit user
+  // requests. An agent-mode Lead keeps its frozen capability once live (the
+  // workflow its prompt was built with, even after a mid-conversation switch)
+  // and a new one gets it with current agents.
   function workflowAllowsAgents() {
     const session = getSession();
+    const agentMode = isAgentModeSession(session || {});
     if (session?.id || session?.workflow || session?.orchestrationMode) {
-      return !workflowDisallowsAgentTool(promptWorkflowOf(session));
+      return !workflowDisallowsAgentTool(promptWorkflowOf(session), { agentMode });
     }
-    return (delegatableAgentIds?.(getConfig(), cfgMod.getPluginData?.() || dataDir).length ?? 1) > 0;
+    return !agentMode || (delegatableAgentIds?.(getConfig(), cfgMod.getPluginData?.() || dataDir).length ?? 1) > 0;
   }
 
   function modelStandaloneTools() {

package/src/session-runtime/turn/session-ops.mjs

@@ -5,6 +5,7 @@
 import { normalizeToolMode } from '../../runtime/agent/orchestrator/runtime-core/effort.mjs';
 import { interruptTaskWaitForSession } from '../../runtime/agent/orchestrator/session/task-wait-control.mjs';
 import { markPendingGoalReminder } from '../../runtime/agent/orchestrator/runtime-core/goal-reminder.mjs';
+import { rearmLateDeferredTools } from '../../runtime/agent/orchestrator/runtime-core/tool-catalog.mjs';
 
 export function createSessionOps(deps) {
   const {
@@ -55,6 +56,7 @@ export function createSessionOps(deps) {
     if (!session?.id) return null;
     const result = await mgr.rewindSessionMessagesTo?.(session.id, options);
     if (!result) return null;
+    if (options.dryRun === true) return result;
     setSession(mgr.getSession(session.id) || session);
     invalidateContextStatusCache();
     return result;
@@ -96,6 +98,12 @@ export function createSessionOps(deps) {
     } catch {
       /* best-effort: a Goal reminder must never break manual compact */
     }
+    // The same compaction strips late MCP tool announcements from older turns.
+    try {
+      rearmLateDeferredTools(getSession());
+    } catch {
+      /* best-effort: a tool reminder must never break manual compact */
+    }
     if (options.recoverAgent === true) recoverAgentWorkers();
     invalidateContextStatusCache();
     return result;

package/src/session-runtime/turn/turn-run.mjs

@@ -28,6 +28,7 @@ export function createTurnRunner(deps) {
     completeTurnSnapshotForTurn = completeTurnSnapshot,
     turnCleanupSettleMs = 2_000,
     getConfig = () => null,
+    currentAgents,
   } = deps;
   const transcript = createTurnTranscript(deps);
   const openTurn = createTurnOpener({
@@ -81,7 +82,10 @@ export function createTurnRunner(deps) {
           plannedToolCalls(session0, options),
           getCurrentCwd(),
           options.prefetch || null,
-          callbacks
+          // The agents enabled now (coding Leads), asked for each user turn
+          // the ask prepares, for its agent list reminder
+          // (manager/agent-listing-notice.mjs).
+          { ...callbacks, agentsNow: currentAgents }
         );
       } finally {
         releaseWebSearchUsage?.();