mixdog 1.3.5 → 1.4.1

package/src/session-runtime/session-compaction-sync.mjs

@@ -0,0 +1,27 @@
+// Keeps a live session's compaction settings on the saved global ones. One
+// helper for every path that can leave a session behind the config: saving the
+// settings, a shared-config reload, and adopting a resumed or swapped session.
+import { normalizeCompactionConfig } from '../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
+import { COMPACTION_CONFIG_KEYS } from '../runtime/agent/orchestrator/runtime-core/compaction-config-keys.mjs';
+
+/** A headless caller injects its own isolated config: its sessions keep the
+ *  compaction they were created with instead of following the profile on disk. */
+export function usesInjectedConfig(params) {
+  return Boolean(params?.initialConfig) && typeof params.initialConfig === 'object';
+}
+
+/** Replace the live session's compaction fields with the saved (normalized) ones. */
+export function adoptSessionCompaction(session, saved) {
+  if (!session) return;
+  const currentSessionCompaction = { ...(session.compaction || {}) };
+  // Anything outside the config-owned set (per-session thresholds, archive
+  // state, timing) is the session's own and survives.
+  for (const key of COMPACTION_CONFIG_KEYS) delete currentSessionCompaction[key];
+  session.compaction = { ...currentSessionCompaction, ...saved };
+}
+
+/** Follow `config.compaction` on a session; a config without the section leaves it alone. */
+export function syncSessionCompaction(session, config) {
+  if (!config?.compaction || typeof config.compaction !== 'object') return;
+  adoptSessionCompaction(session, normalizeCompactionConfig(config.compaction));
+}

package/src/session-runtime/session-create/session-options.mjs

@@ -33,6 +33,7 @@ function agentOwnedSessionFields(sessionProfile) {
     agentTag: sessionProfile?.agentTag || null,
     taskType: sessionProfile?.taskType || null,
     ...(sessionProfile?.routeFallbacks !== undefined ? { routeFallbacks: sessionProfile.routeFallbacks } : {}),
+    ...(sessionProfile?.routeFallbackSource ? { routeFallbackSource: sessionProfile.routeFallbackSource } : {}),
     permission: sessionProfile?.permission || undefined,
     permissionMode: sessionProfile?.permissionMode || undefined,
     schemaAllowedTools: Array.isArray(sessionProfile?.schemaAllowedTools)

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

@@ -96,6 +96,17 @@ export function createBuiltinToolSettings(
       saveConfigAndAdopt({ ...getConfig(), aiSessionTitles: enabled !== false });
       return this.getSessionTitleSettings();
     },
+    // Prompt-cache warming on/off (orchestrator session/cache-warm.mjs);
+    // default on. The warmer reads the saved value at each
+    // warm, so a change applies without a restart.
+    getCacheWarmingSettings() {
+      return { enabled: getConfig()?.promptCacheWarming !== false };
+    },
+    setCacheWarmingEnabled(enabled) {
+      if (typeof enabled !== 'boolean') throw new TypeError('cache warming must be on or off (a boolean)');
+      saveConfigAndAdopt({ ...getConfig(), promptCacheWarming: enabled });
+      return this.getCacheWarmingSettings();
+    },
     // The one pixel face every Lead row on the bot page wears, shared by every
     // device that follows this host. Only a mascot look counts; null (the
     // default grey pup) is stored as no key.

package/src/session-runtime/settings-compaction-api.mjs

@@ -6,38 +6,8 @@ import {
 import { isAutoClearUnlimited } from '../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { COMPACTION_SUMMARY_MODES } from '../runtime/agent/orchestrator/session/compact/summary-mode.mjs';
 
-// Every spelling of the main-context buffer budget; a new representation
-// replaces the previous one.
-const MAIN_BUFFER_KEYS = [
-  'mainBufferTokens',
-  'mainBuffer',
-  'mainBufferPercent',
-  'mainBufferPct',
-  'mainBufferRatio',
-  'mainBufferFraction',
-];
-// Session-level compaction fields that the saved config owns from now on.
-const SESSION_COMPACTION_KEYS = [
-  'type',
-  'compactType',
-  'compact_type',
-  'semantic',
-  'semanticModel',
-  'prune',
-  'tailTurns',
-  'recallMemoryTimeoutMs',
-  'recallIngestLimit',
-  'recallChunkLimit',
-  'recallLimit',
-  'recallCycle1BatchSize',
-  'recallRowsPerSession',
-  'recallWindowSize',
-  'recallConcurrency',
-  'recallCycle1DeadlineMs',
-  // Replaced by summaryMode.
-  'useMaintainer',
-  ...MAIN_BUFFER_KEYS,
-];
+import { MAIN_BUFFER_KEYS } from '../runtime/agent/orchestrator/runtime-core/compaction-config-keys.mjs';
+import { adoptSessionCompaction } from './session-compaction-sync.mjs';
 
 // Unlimited (never auto-clear) typed as a duration.
 const UNLIMITED_DURATION = /^(?:unlimited|never)$/i;
@@ -66,14 +36,6 @@ function applyCompactionInput(next, input, hasOwn) {
   return next;
 }
 
-/** Replace the live session's compaction fields with the saved config's. */
-function adoptSessionCompaction(session, saved) {
-  if (!session) return;
-  const currentSessionCompaction = { ...(session.compaction || {}) };
-  for (const key of SESSION_COMPACTION_KEYS) delete currentSessionCompaction[key];
-  session.compaction = { ...currentSessionCompaction, ...saved };
-}
-
 // Advanced picker shows only providers the user actually has enabled
 // (config.providers[*].enabled), plus the active route provider, any
 // provider with a custom override, and the 'default' fallback row —

package/src/session-runtime/settings-system-api.mjs

@@ -1,5 +1,10 @@
 // Automation worker status, the system shell, self-update, Mixy's heartbeat
 // and bots' reactions settings.
+import {
+  normalizeHeartbeatIntervalMinutes,
+  requireHeartbeatIntervalMinutes,
+} from '../runtime/shared/heartbeat-interval.mjs';
+
 export function createSystemSettings({
   getConfig,
   saveConfigAndAdopt,
@@ -51,12 +56,19 @@ export function createSystemSettings({
       return this.getUpdateSettings();
     },
     getHeartbeatSettings() {
-      return { heartbeat: getConfig()?.heartbeat !== false };
+      return {
+        heartbeat: getConfig()?.heartbeat !== false,
+        intervalMinutes: normalizeHeartbeatIntervalMinutes(getConfig()?.heartbeatIntervalMinutes),
+      };
     },
     setHeartbeatEnabled(enabled) {
       saveConfigAndAdopt({ ...getConfig(), heartbeat: enabled === true });
       return this.getHeartbeatSettings();
     },
+    setHeartbeatInterval(minutes) {
+      saveConfigAndAdopt({ ...getConfig(), heartbeatIntervalMinutes: requireHeartbeatIntervalMinutes(minutes) });
+      return this.getHeartbeatSettings();
+    },
     getReactionSettings() {
       return { reactions: getConfig()?.reactions !== false };
     },

package/src/session-runtime/setup-tool/agent-settings-actions.mjs

@@ -0,0 +1,65 @@
+/** Setup actions for per-agent and per-project switches and the bot roster:
+ *  action permissions, connector switches, archived bots, bot order and
+ *  prompt-cache warming. Each goes through the runtime method its settings
+ *  surface uses. Permission and connector writes are made as a remote client's
+ *  are (`noWiden`): a chat may take authority away, never give an agent more
+ *  without asking — that stays with the person in the desktop app. */
+import { agentPermissions, setAgentPermission } from '../../runtime/agent/orchestrator/session/human-gate/store.mjs';
+import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+
+const NO_WIDEN = Object.freeze({ noWiden: true });
+
+function requireText(value, label) {
+  const text = clean(value);
+  if (!text) throw new Error(`${label} is required`);
+  return text;
+}
+
+export const AGENT_SETTINGS_HANDLERS = {
+  async read_agent_settings(rt, args) {
+    const agent = requireText(args.agent, 'agent');
+    const [permissions, connectors, alwaysAllowedTools] = await Promise.all([
+      agentPermissions(agent),
+      rt.getAgentConnectors(agent),
+      rt.getAgentAlwaysAllowedTools(agent),
+    ]);
+    return { agent, permissions, connectors, alwaysAllowedTools };
+  },
+  read_project_connectors: async (rt, args) => {
+    const projectPath = requireText(args.projectPath, 'projectPath');
+    return { projectPath, connectors: await rt.getProjectConnectors(projectPath) };
+  },
+  async set_agent_permission(_rt, args) {
+    const agent = requireText(args.agent, 'agent');
+    return { agent, permissions: await setAgentPermission(agent, args.actionKind, args.permissionMode, NO_WIDEN) };
+  },
+  async set_agent_connector(rt, args) {
+    const agent = requireText(args.agent, 'agent');
+    const name = requireText(args.name, 'name');
+    return { agent, connectors: await rt.setAgentConnectorEnabled(agent, name, args.enabled, NO_WIDEN) };
+  },
+  async set_agent_connector_tool(rt, args) {
+    const agent = requireText(args.agent, 'agent');
+    const name = requireText(args.name, 'name');
+    const tool = requireText(args.tool, 'tool');
+    await rt.setAgentConnectorToolPermission(agent, name, tool, args.permission, NO_WIDEN);
+    return { agent, connector: name, tool, permission: args.permission };
+  },
+  async set_project_connector(rt, args) {
+    const projectPath = requireText(args.projectPath, 'projectPath');
+    const name = requireText(args.name, 'name');
+    return { projectPath, connectors: await rt.setProjectConnectorEnabled(projectPath, name, args.enabled, NO_WIDEN) };
+  },
+  async restore_definition(rt, args) {
+    if (args.definitionKind !== 'agent') {
+      throw new Error('Only an archived agent or bot can be restored; a deleted workflow is gone');
+    }
+    const name = requireText(args.name, 'name');
+    await rt.restoreAgentDefinition(name);
+    return { restored: name, note: 'Its chat is back; its routines stay off until they are turned on.' };
+  },
+  set_bot_order: (rt, args) => ({ botOrder: rt.setBotOrder(args.botOrder).order }),
+  set_cache_warming_enabled: (rt, args) => ({
+    promptCacheWarming: rt.setCacheWarmingEnabled(args.enabled).enabled,
+  }),
+};

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

@@ -7,6 +7,10 @@ import { builtinFeatureActive } from '../../runtime/agent/orchestrator/runtime-c
 import { ORCHESTRATION_MODES } from '../../runtime/shared/orchestration.mjs';
 import { AUTO_EFFORT_BASES } from '../../runtime/agent/orchestrator/providers/auto-effort.mjs';
 import { INSTRUCTION_FILES_MODES } from '../../runtime/shared/instruction-files-mode.mjs';
+import {
+  normalizeHeartbeatIntervalMinutes,
+  requireHeartbeatIntervalMinutes,
+} from '../../runtime/shared/heartbeat-interval.mjs';
 import { MEDIA_KINDS } from '../../runtime/media/tool-defs.mjs';
 import { SETUP_DESKTOP_DOMAINS, SETUP_HANDOFFS } from './settings-contract.mjs';
 import { executeExtendedSetupAction, publicAutomation, publicHookRule, validateMcpInput } from './extended-actions.mjs';
@@ -30,8 +34,32 @@ import { schemaValueError } from '../../runtime/shared/schema-value-error.mjs';
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { CONNECTOR_IDS, connectorById } from '../../runtime/shared/connector-catalog.mjs';
 import profileConfig from '../../runtime/shared/profile-config.cjs';
+import { SESSION_ROUTE_HANDLERS, routePositionsStatus } from './session-route-actions.mjs';
+import { AGENT_SETTINGS_HANDLERS } from './agent-settings-actions.mjs';
+import {
+  routeFallbackPosition,
+  sessionChainSource,
+  sessionRoutePrimary,
+} from '../../runtime/agent/orchestrator/session/manager/route-fallback-chain.mjs';
+import { sameRouteModel } from '../../runtime/agent/orchestrator/session/manager/owner-route-fallbacks.mjs';
+
+const AGENT_DEFINITION_ACTIONS = new Set([
+  'create_definition',
+  'save_definition',
+  'delete_definition',
+  'restore_definition',
+]);
+// Actions on one agent's own settings: another agent's thread changes only its own.
+const OWN_AGENT_ACTIONS = new Set([
+  'set_agent_route',
+  'set_agent_permission',
+  'set_agent_connector',
+  'set_agent_connector_tool',
+]);
 
-const AGENT_DEFINITION_ACTIONS = new Set(['create_definition', 'save_definition', 'delete_definition']);
+// How a fallback chain edit reaches sessions that already run (route-fallback-chain.mjs).
+const CHAIN_APPLIES =
+  'a changed fallback chain reaches running sessions on that route from their next fallback hop ([] stops further hops at once; the turn ends with the provider error)';
 
 const PROFILE_VALUE_IDS = Object.freeze({
   language: profileConfig.PROFILE_LANGUAGES.map((entry) => entry.id),
@@ -39,8 +67,20 @@ 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_route: `new sessions (an established conversation keeps its model); ${CHAIN_APPLIES}: Lead conversations and agents that inherit Main`,
+  set_agent_route: `the bot's chats from their next turn (a running turn finishes on the old model); ${CHAIN_APPLIES}: its chats and sub-agents; an agent switched on or off reaches open conversations from their next turn as an agent list reminder`,
+  reset_route_fallback:
+    'each listed session from its next turn (a running turn finishes on its fallback model): it returns to its primary and its chain starts over',
+  continue_in_model: 'that session now; its stopped turn is not resent',
+  schedule_quota_resume: "that session's stopped turn, resent at the provider's reset time",
+  cancel_quota_resume: 'that session: its pending resume is dropped; the turn stays stopped',
+  set_cache_warming_enabled: 'the next prompt-cache warm of every session; no restart required',
+  set_agent_permission: "that agent's next action of the kind, in every session",
+  set_agent_connector: "that agent's next connector tool call, in every session",
+  set_agent_connector_tool: "that agent's next call of the tool, in every session",
+  set_project_connector: 'the next connector tool call of sessions in that Project',
+  restore_definition: 'now: the bot and its chat return; its routines stay off',
+  set_bot_order: 'the Bots page and the Sessions bot section on every device',
   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',
@@ -48,7 +88,9 @@ const ACTION_APPLIES_TO = {
   set_ai_session_titles: 'titles generated from now on; existing titles are unchanged',
   set_quota_auto_resume: 'subsequent usage-limit stops; turning it off cancels pending resumes',
   set_model_preferences: 'the /model picker and model management lists',
-  set_heartbeat_enabled: "Mixy's next heartbeat check (every 30 minutes); no restart required",
+  set_heartbeat_enabled: "Mixy's next heartbeat check; no restart required",
+  set_heartbeat_interval:
+    "Mixy's heartbeat from the next tick: the next check is due the new interval after the last one; no restart required",
   set_reactions_enabled:
     "bots' chats; while off a reaction is refused at once and new chats are not offered the tool; reactions already left stay visible",
   set_worktree_settings: 'new tasks and worktrees created afterwards; existing worktrees are unchanged',
@@ -124,6 +166,31 @@ function routeInput(source) {
   return next;
 }
 
+/** A fallback chain edit's receipt: whether the calling conversation now
+ *  follows the saved chain, and the position it reads it from. `owner` is
+ *  whose route was edited: `{ kind: 'lead' }` (set_route) or `{ kind: 'bot',
+ *  agent }` (set_agent_route); only a caller whose chain comes from that
+ *  route's settings follows it. */
+function chainReceipt(route, { caller, getConfig }, owner) {
+  if (!Object.hasOwn(route, 'fallbacks') || !caller?.agent) return {};
+  const config = getConfig();
+  const position = routeFallbackPosition(caller, config);
+  // Settings-sourced and still on that route's primary: a conversation left on
+  // a previous model follows no chain, whatever the saved one is.
+  const source = sessionChainSource(caller, config);
+  const followsEdited =
+    position.chainFrom === 'settings' &&
+    sameRouteModel(source, sessionRoutePrimary(caller)) &&
+    position.kind === owner.kind &&
+    (owner.kind !== 'bot' || position.agent === owner.agent);
+  const saved = route.fallbacks.map((entry) => `${entry.provider}/${entry.model}`);
+  const followed = position.fallbacks.map((entry) => `${entry.provider}/${entry.model}`);
+  return {
+    appliedToCurrentSession: followsEdited && saved.join('\n') === followed.join('\n'),
+    currentSession: position,
+  };
+}
+
 function apiKeySource(row) {
   if (row.env) return `env:${row.envName}`;
   return row.stored ? 'keychain' : 'none';
@@ -232,6 +299,18 @@ function mcpRows(status) {
       error: server.error || null,
       ...(server.warnings?.length ? { warnings: server.warnings } : {}),
       scope: Array.isArray(server.scope) ? server.scope : null,
+      ...(server.connector ? { connector: server.connector } : {}),
+      // A multi-account connector's accounts: remove_mcp_server / sign-in take an account's name.
+      ...(Array.isArray(server.accounts)
+        ? {
+            accounts: server.accounts.map((account) => ({
+              name: account.name,
+              email: account.email || '',
+              ...(account.authRequired ? { authRequired: true } : {}),
+              ...(account.error ? { error: account.error } : {}),
+            })),
+          }
+        : {}),
     })),
     ...(status?.warnings?.length ? { warnings: status.warnings } : {}),
     ...(status?.declarationErrors?.length ? { declarationErrors: status.declarationErrors } : {}),
@@ -284,14 +363,20 @@ async function featureStatus(rt, getConfig) {
     browser: { active: builtinFeatureActive(config, 'browser') },
     computer: { active: builtinFeatureActive(config, 'computer') },
     terminal: { active: builtinFeatureActive(config, 'terminal') },
-    heartbeat: { enabled: config?.heartbeat !== false },
+    heartbeat: {
+      enabled: config?.heartbeat !== false,
+      intervalMinutes: normalizeHeartbeatIntervalMinutes(config?.heartbeatIntervalMinutes),
+    },
     reactions: { enabled: config?.reactions !== false },
     voice: rt.getVoiceStatus ? voiceFeatureStatus(await rt.getVoiceStatus()) : null,
   };
 }
 
 async function mediaDefaults(rt) {
-  const [pins, ...rows] = await Promise.all([rt.getMediaPins(), ...MEDIA_KINDS.map((kind) => rt.getMediaDefault(kind))]);
+  const [pins, ...rows] = await Promise.all([
+    rt.getMediaPins(),
+    ...MEDIA_KINDS.map((kind) => rt.getMediaDefault(kind)),
+  ]);
   const fieldsOf = (row, fields) => (row ? Object.fromEntries(fields.map((field) => [field, row[field]])) : null);
   return {
     // The default generator (Settings → Built-in → Media generation); null = Auto.
@@ -335,7 +420,7 @@ const SETUP_STATUS_READERS = {
     features: await featureStatus(rt, getConfig),
     onboarding: rt.getOnboardingStatus?.() || null,
   }),
-  model: (rt) => ({
+  model: (rt, { getConfig, caller }) => ({
     route: {
       ...mainRoute(rt),
       autoEffort: rt.autoEffort !== false,
@@ -343,11 +428,16 @@ const SETUP_STATUS_READERS = {
       fallbacks: (rt.listPresets?.() || []).find((preset) => preset?.id === 'workflow-lead')?.fallbacks || [],
     },
     effortOptions: rt.effortOptions || [],
+    // Where this conversation and the other Lead conversations are on their chain.
+    ...routePositionsStatus({ caller, config: getConfig(), keep: (row) => row.kind === 'lead' }),
   }),
-  agents: (rt) => ({
+  agents: (rt, { getConfig, caller }) => ({
     agents: rt.listAgents?.() || [],
     orchestrationMode: rt.getOrchestrationMode(),
     orchestrationModes: ORCHESTRATION_MODES,
+    ...(rt.getBotOrder ? { botOrder: rt.getBotOrder().order } : {}),
+    // Bot chats and sub-agents on their fallback chains.
+    sessions: routePositionsStatus({ caller, config: getConfig(), keep: (row) => row.kind !== 'lead' }).sessions,
   }),
   workflow: (rt) => ({ workflows: rt.listWorkflows?.() || [] }),
   websearch: (rt) => ({
@@ -366,7 +456,11 @@ const SETUP_STATUS_READERS = {
     };
   },
   autoclear: (rt) => rt.getAutoClear?.() || {},
-  compaction: (rt) => ({ ...(rt.getCompactionSettings?.() || {}), ...(rt.getSessionTitleSettings?.() || {}) }),
+  compaction: (rt) => ({
+    ...(rt.getCompactionSettings?.() || {}),
+    ...(rt.getSessionTitleSettings?.() || {}),
+    ...(rt.getCacheWarmingSettings ? { promptCacheWarming: rt.getCacheWarmingSettings().enabled } : {}),
+  }),
   memory: (rt) => ({ ...(rt.getToolModuleSettings?.()?.memory || {}), recap: rt.getRecapSettings?.() || null }),
   'local-provider': (rt) => rt.getToolModuleSettings().localProvider,
   features: (rt, { getConfig }) => featureStatus(rt, getConfig),
@@ -496,22 +590,28 @@ const SETUP_INSTALLABLE_FEATURES = [
 // Action handlers: (rt, args, { requestDesktop, readStatus, openSurface }).
 // `rt` is null for `status` and `open`, which never touch the facade.
 const SETUP_ACTION_HANDLERS = {
-  status: async (_rt, args, { readStatus, requestDesktop }) => {
+  status: async (_rt, args, { readStatus, requestDesktop, caller }) => {
     const domain = clean(args.domain) || 'summary';
     requireEnum(domain, SETUP_STATUS_DOMAINS, 'domain');
-    return { domain, ...(await readStatus(domain, requestDesktop, args.detail === true)) };
+    return { domain, ...(await readStatus(domain, requestDesktop, args.detail === true, caller)) };
   },
   open: (_rt, args, { openSurface }) => openSurface(args.target),
-  set_route: async (rt, args) => {
+  set_route: async (rt, args, context) => {
     const route = routeInput(args.route);
     const next = await rt.setRoute(route, { keepMainModel: false });
-    return { route: next, appliesTo: 'next session (a conversation keeps its frozen route)' };
+    return { route: next, ...chainReceipt(args.route, context, { kind: 'lead' }) };
   },
-  set_agent_route: async (rt, args) => {
+  set_agent_route: async (rt, args, context) => {
     const agent = requireText(args.agent, 'agent');
     const route = routeInput(args.route);
-    return { agent, route: await rt.setAgentRoute(agent, route) };
+    return {
+      agent,
+      route: await rt.setAgentRoute(agent, route),
+      ...chainReceipt(args.route, context, { kind: 'bot', agent }),
+    };
   },
+  ...SESSION_ROUTE_HANDLERS,
+  ...AGENT_SETTINGS_HANDLERS,
   set_web_search_route: async (rt, args) => ({ route: await rt.setWebSearchRoute(routeInput(args.route)) }),
   set_workflow: (rt, args) => rt.setWorkflow(requireText(args.workflow, 'workflow')),
   set_output_style: async (rt, args) => {
@@ -621,14 +721,18 @@ const SETUP_ACTION_HANDLERS = {
   set_system_shell: (rt, args) => rt.setSystemShell({ command: clean(args.command) }),
   set_auto_update: (rt, args) => rt.setAutoUpdate(requireBoolean(args.enabled)),
   set_ai_session_titles: (rt, args) => rt.setAiSessionTitles(requireBoolean(args.enabled)),
-  set_quota_auto_resume: async (rt, args) => ({ quotaAutoResume: await rt.setQuotaAutoResume(requireBoolean(args.enabled)) }),
+  set_quota_auto_resume: async (rt, args) => ({
+    quotaAutoResume: await rt.setQuotaAutoResume(requireBoolean(args.enabled)),
+  }),
   set_model_preferences: async (rt, args) => {
     const change = { model: requireText(args.model, 'model') };
-    for (const key of ['hidden', 'favorite']) if (Object.hasOwn(args, key)) change[key] = requireBoolean(args[key], key);
+    for (const key of ['hidden', 'favorite'])
+      if (Object.hasOwn(args, key)) change[key] = requireBoolean(args[key], key);
     if (Object.keys(change).length === 1) throw new Error('hidden or favorite is required');
     return rt.setModelPreferences(requireText(args.provider, 'provider'), [change]);
   },
   set_heartbeat_enabled: (rt, args) => rt.setHeartbeatEnabled(requireBoolean(args.enabled)),
+  set_heartbeat_interval: (rt, args) => rt.setHeartbeatInterval(requireHeartbeatIntervalMinutes(args.minutes)),
   set_reactions_enabled: (rt, args) => rt.setReactionsEnabled(requireBoolean(args.enabled)),
   set_worktree_settings: (rt, args) => rt.setWorktreeSettings(args.worktree),
   forget_provider_auth: async (rt, args) => {
@@ -736,6 +840,8 @@ const READ_ONLY_SETUP_ACTIONS = new Set([
   'search_local_models',
   'inspect_hf_model',
   'local_model_details',
+  'read_agent_settings',
+  'read_project_connectors',
 ]);
 // Actions that start or steer work rather than saving a setting.
 const BACKGROUND_SETUP_ACTIONS = new Set([
@@ -744,6 +850,10 @@ const BACKGROUND_SETUP_ACTIONS = new Set([
   'cancel_local_installation',
   'reconnect_mcp',
   'run_automation',
+  'reset_route_fallback',
+  'continue_in_model',
+  'schedule_quota_resume',
+  'cancel_quota_resume',
 ]);
 
 function setupMutationReceipt(action, result) {
@@ -768,6 +878,7 @@ export function createSetupToolExecutor({
   getSessionId,
   getCallerSession,
   flushSettings,
+  executeSessionControl = null,
 }) {
   const desktop = createSetupUiRequests({ notifySessionUi, getSessionId });
   const api = () => {
@@ -776,11 +887,11 @@ export function createSetupToolExecutor({
     return facade;
   };
 
-  async function readStatus(domain, requestDesktop, detail) {
+  async function readStatus(domain, requestDesktop, detail, caller = null) {
     const rt = api();
     if (SETUP_DESKTOP_DOMAINS.includes(domain)) return requestDesktop({ action: 'status', domain });
     if (!Object.hasOwn(SETUP_STATUS_READERS, domain)) throw new Error(`setup: unknown status domain "${domain}"`);
-    return SETUP_STATUS_READERS[domain](rt, { domain, detail, getConfig: () => getConfig?.() || {} });
+    return SETUP_STATUS_READERS[domain](rt, { domain, detail, caller, getConfig: () => getConfig?.() || {} });
   }
 
   function openSurface(target) {
@@ -809,15 +920,16 @@ export function createSetupToolExecutor({
     // it never creates agents, definitions or automations, nor changes any
     // other setting. Hosts without session provenance (no getCallerSession)
     // skip this gate; automation actions still refuse an unknown caller.
+    let scope = null;
     if (getCallerSession && !READ_ONLY_SETUP_ACTIONS.has(action)) {
-      const scope = scheduleCallerScope(caller);
+      scope = scheduleCallerScope(caller);
       assertInteractiveCaller(scope, action);
       // Agent definitions (contacts) change only from Mixy; another agent's
       // home changes only its own agent settings.
       if (AGENT_DEFINITION_ACTIONS.has(action) && args.definitionKind === 'agent') {
         assertAgentEditorAccess(scope, caller, action);
       }
-      if (action === 'set_agent_route') assertOwnAgentSettings(scope, args.agent, action);
+      if (OWN_AGENT_ACTIONS.has(action)) assertOwnAgentSettings(scope, args.agent, action);
     }
     // Mixy's heartbeat session takes only its two routine actions, reads included.
     assertHeartbeatSetupAction(sessionId, action, args);
@@ -825,7 +937,18 @@ export function createSetupToolExecutor({
     if (!Object.hasOwn(SETUP_ACTION_HANDLERS, action)) {
       return executeExtendedSetupAction(rt, args, requestDesktop, { sessionId, caller });
     }
-    return SETUP_ACTION_HANDLERS[action](rt, args, { requestDesktop, readStatus, openSurface });
+    return SETUP_ACTION_HANDLERS[action](rt, args, {
+      requestDesktop,
+      readStatus,
+      openSurface,
+      sessionId,
+      caller,
+      // The session-scoped actions authorize each target against it (session-route-actions.mjs).
+      scope,
+      getSession: getCallerSession,
+      getConfig: () => getConfig?.() || {},
+      executeSessionControl,
+    });
   }
 
   return {

package/src/session-runtime/setup-tool/extended-actions.mjs

@@ -71,7 +71,10 @@ function modelDetail(row) {
     defaultModelParameters: row.defaultModelParameters,
     supportsMaxMode: row.supportsMaxMode,
   };
-  return { ...Object.fromEntries(Object.entries(detail).filter(([, value]) => isPresent(value))), ...modelPreferenceFields(row) };
+  return {
+    ...Object.fromEntries(Object.entries(detail).filter(([, value]) => isPresent(value))),
+    ...modelPreferenceFields(row),
+  };
 }
 
 function findModel(rows, id, provider) {
@@ -420,7 +423,7 @@ export const EXTENDED_SETUP_HANDLERS = Object.freeze({
       if (own(args, 'model') || own(args, 'accountId')) throw new Error('model and accountId need a lane');
       return { kind: args.kind, media: await rt.setMediaPin({ kind: args.kind, lane: '' }) };
     }
-    const lane =(await rt.listMediaLanes()).find((row) => row.id === args.lane);
+    const lane = (await rt.listMediaLanes()).find((row) => row.id === args.lane);
     if (!lane) throw new Error(`Unknown media lane "${args.lane}"; list lanes with the media tool`);
     if (!lane.authenticated) throw new Error(`${lane.label} is not signed in; open providers first`);
     const spec = lane[args.kind];
@@ -431,7 +434,9 @@ export const EXTENDED_SETUP_HANDLERS = Object.freeze({
     if (own(args, 'accountId')) {
       if (lane.authType !== 'oauth') throw new Error(`${lane.id} signs in with an API key; it has no accounts`);
       if (!rt.getProviderAccounts(lane.authProvider).accounts.some((row) => row.id === args.accountId)) {
-        throw new Error(`Unknown ${lane.authProvider} account "${args.accountId}"; list accounts with status providers`);
+        throw new Error(
+          `Unknown ${lane.authProvider} account "${args.accountId}"; list accounts with status providers`
+        );
       }
     }
     const pin = await rt.setMediaPin({ kind: args.kind, lane: args.lane, model: args.model, account: args.accountId });