mixdog 1.3.4 → 1.3.5

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

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { renameSync } from 'node:fs';
 import { modelProxyClientMode, serverModelCredentialsDisabledError } from '../../runtime/shared/model-proxy-mode.mjs';
 import { sameAccountIdentity } from '../../runtime/agent/orchestrator/providers/lib/oauth-token-utils.mjs';
+import { agentApiKeyEnvName } from '../../runtime/shared/provider-api-key.mjs';
 import {
   AGENT_PROVIDER_ENV,
   SECRET_ACCOUNTS,
@@ -9,6 +10,7 @@ import {
   getAgentApiKey,
   getKeychainStatus,
   hasStoredSecret,
+  isFallbackSecret,
   saveSecretAsync,
 } from '../../runtime/shared/config.mjs';
 import {
@@ -80,6 +82,13 @@ import {
   hasCursorOAuthCredentials,
   loginCursorOAuth,
 } from '../../runtime/agent/orchestrator/providers/cursor-auth.mjs';
+import {
+  beginDevinOAuthLogin,
+  describeDevinOAuthCredentials,
+  forgetDevinOAuthCredentials,
+  hasDevinOAuthCredentials,
+  loginDevinOAuth,
+} from '../../runtime/agent/orchestrator/providers/devin-auth.mjs';
 import {
   describeAntigravityOAuthCredentials,
   forgetAntigravityOAuthCredentials,
@@ -100,6 +109,7 @@ import {
   removeProviderAccount,
   clearProviderAccountQuotaState,
   providerAccountLimit,
+  providerAccountBlockedUntil,
   ACCOUNT_PROVIDERS,
 } from '../../runtime/shared/provider-accounts.mjs';
 import { currentProviderAccountId, withProviderAccount } from '../../runtime/shared/provider-auth-binding.mjs';
@@ -214,6 +224,16 @@ const OAUTH_PROVIDERS = Object.freeze([
     begin: beginCursorOAuthLogin,
     login: loginCursorOAuth,
   }),
+  Object.freeze({
+    id: 'devin-oauth',
+    name: 'Devin',
+    desc: 'Sign in with your Devin account',
+    has: hasDevinOAuthCredentials,
+    describe: describeDevinOAuthCredentials,
+    forget: forgetDevinOAuthCredentials,
+    begin: beginDevinOAuthLogin,
+    login: loginDevinOAuth,
+  }),
   Object.freeze({
     id: 'antigravity-oauth',
     name: 'Antigravity OAuth',
@@ -231,7 +251,7 @@ const BUILTIN_PROVIDER_IDS = new Set(['mixdog-local']);
 const API_PROVIDER_IDS = new Set(API_PROVIDERS.map((p) => p.id));
 const OAUTH_BY_ID = new Map(OAUTH_PROVIDERS.map((p) => [p.id, p]));
 
-// Dev-only entries (cursor-oauth, antigravity-oauth, mimo-oauth) are unknown to
+// Dev-only entries (cursor-oauth, devin-oauth, antigravity-oauth, mimo-oauth) are unknown to
 // settings/login while the Developer → Providers option is off. Filtered per
 // call, so toggling the option takes effect without a restart.
 function availableOAuthProviders() {
@@ -320,33 +340,71 @@ const KEYCHAIN_HINTS = Object.freeze({
   error: 'The system keyring could not be read — check that it is running and unlocked.',
 });
 
+// The private-file store being ignored, by what is wrong with it (the repair
+// differs: chmod cannot fix an owner or a symlink, and a save fails through a
+// foreign or symlinked folder).
+const UNSAFE_STORE_HINTS = Object.freeze({
+  permissions:
+    'The private secrets folder has unsafe permissions, so its keys are ignored — run chmod 700 on the folder and chmod 600 on its files, or save the key again.',
+  owner:
+    'The private secrets folder or one of its files belongs to another user, so its keys are ignored — change its owner to the current user (chown).',
+  type: 'The private secrets folder or one of its files is a symlink or not a regular file, so its keys are ignored — remove it and save the key again.',
+});
+
 export function keychainIssueFor(checkSecrets) {
   if (!checkSecrets) return null;
-  const { state } = getKeychainStatus();
+  // A host with no keychain provider keeps its keys in the private secrets
+  // file (keychain-cjs.cjs "Linux fallback file"): that works, so nothing to
+  // report — unless the store's permissions make reads ignore it, which is
+  // reported with the folder to repair. A locked keyring is still an issue.
+  const { state, fallback, unsafeStore } = getKeychainStatus();
+  if (fallback && unsafeStore) {
+    const { kind, path } = unsafeStore;
+    return { state: 'unsafe-store', kind, message: UNSAFE_STORE_HINTS[kind] ?? UNSAFE_STORE_HINTS.permissions, path };
+  }
+  if (fallback) return null;
   const message = KEYCHAIN_HINTS[state];
   return message ? { state, message } : null;
 }
 
-function apiProviderSetup(p, providers, checkSecrets) {
+// Where a stored key lives, for a row's detail line: decided per account, so a
+// key that is still only in the fallback file reads as such after the keychain
+// recovers.
+function storedSecretDetail(account) {
+  return isFallbackSecret(account) ? 'stored in private file' : 'stored in keychain';
+}
+
+// `keychainIssue`: the setup response's one keyring check (never asked per row).
+function apiProviderSetup(p, providers, checkSecrets, keychainIssue) {
   const configured = providers[p.id] || {};
-  const envName = AGENT_PROVIDER_ENV[p.id] || p.env;
-  const env = Boolean(envName && process.env[envName]);
+  // The environment variable the key resolver actually reads (aliases included);
+  // it wins over a stored key, so provenance follows it, not the stored secret.
+  const resolvedEnv = agentApiKeyEnvName(p.id);
+  const declaredEnv = AGENT_PROVIDER_ENV[p.id] || p.env;
+  const envName = resolvedEnv || declaredEnv;
+  const env = Boolean(resolvedEnv || (declaredEnv && process.env[declaredEnv]));
   const configuredEnabled = configured.enabled === true;
   const stored = checkSecrets ? hasStoredSecret(SECRET_ACCOUNTS.agentApiKey(p.id)) : false;
   const authenticated = env || stored || (checkSecrets ? Boolean(getAgentApiKey(p.id)) : configuredEnabled);
   let status = configuredEnabled ? 'No Key' : 'Off';
-  if (stored) status = 'Set';
-  else if (env) status = 'Env';
-  else if (authenticated) status = 'Set';
+  if (env) status = 'Env';
+  else if (stored || authenticated) status = 'Set';
+  // Where the effective credential comes from: environment | private-file | keychain.
+  let credentialSource = null;
   let detail = envName;
-  if (stored) detail = 'stored in keychain';
-  else if (env) detail = envName;
-  else if (authenticated) detail = 'runtime credential';
-  const keychainIssue = authenticated ? null : keychainIssueFor(checkSecrets);
-  if (keychainIssue) detail = keychainIssue.message;
+  if (env) {
+    credentialSource = 'environment';
+  } else if (stored) {
+    detail = storedSecretDetail(SECRET_ACCOUNTS.agentApiKey(p.id));
+    credentialSource = detail === 'stored in private file' ? 'private-file' : 'keychain';
+  } else if (authenticated) {
+    detail = 'runtime credential';
+  }
+  const rowIssue = authenticated ? null : keychainIssue;
+  if (rowIssue) detail = rowIssue.message;
   return {
     ...p,
-    ...(keychainIssue ? { keychainIssue } : {}),
+    ...(rowIssue ? { keychainIssue: rowIssue } : {}),
     group: 'api',
     type: 'api-key',
     enabled: configuredEnabled || authenticated,
@@ -356,6 +414,7 @@ function apiProviderSetup(p, providers, checkSecrets) {
     envName,
     status,
     detail,
+    ...(credentialSource ? { credentialSource } : {}),
   };
 }
 
@@ -469,7 +528,7 @@ function customProviderRow(id, entry, checkSecrets = true) {
   const stored = checkSecrets ? hasStoredSecret(SECRET_ACCOUNTS.agentApiKey(id)) : false;
   const unstoredStatus = configuredEnabled ? 'No Key' : 'Off';
   let status = stored ? 'Set' : unstoredStatus;
-  let detail = stored ? 'stored in keychain' : 'custom endpoint';
+  let detail = stored ? storedSecretDetail(SECRET_ACCOUNTS.agentApiKey(id)) : 'custom endpoint';
   if (apiKeyEnv) {
     status = envSet ? 'Env' : unstoredStatus;
     detail = apiKeyEnv;
@@ -533,7 +592,7 @@ export async function providerSetup(config = {}, options = {}) {
   return {
     ...(keychain ? { keychain } : {}),
     api: [
-      ...API_PROVIDERS.map((p) => apiProviderSetup(p, providers, checkSecrets)),
+      ...API_PROVIDERS.map((p) => apiProviderSetup(p, providers, checkSecrets, keychain)),
       ...customProviderRows(providers, checkSecrets),
     ],
     oauth: availableOAuthProviders().map((p) => oauthProviderSetup(p, providers, checkSecrets)),
@@ -885,7 +944,8 @@ export function listProviderAccounts(provider) {
         authenticated: auth.authenticated === true,
         reauthRequired: auth.reauthRequired === true,
         usage: row.usage || null,
-        blockedUntil: row.blockedUntil || null,
+        // When the limit shown lifts: the latest deadline of every block.
+        blockedUntil: providerAccountBlockedUntil(row) || null,
         // The limit holding the account now: account-wide, or only for one
         // model family ("7D Fable") while other models still run.
         limit: providerAccountLimit(row, now, { useCredits: pool.useCredits === true }),
@@ -1113,6 +1173,44 @@ export async function saveCustomProvider(cfgMod, rawInput) {
   return typed ? serializeCustomKeySave(id, commit) : commit();
 }
 
+// Replaces only the stored key of an existing custom provider. The provider's
+// settings are never read back and rewritten, so a concurrent edit of them
+// (or a removal) is never reverted.
+export async function saveCustomProviderKey(cfgMod, rawId, rawKey) {
+  requireLocalProviderManagement();
+  const id = String(rawId || '').trim();
+  if (typeof rawKey !== 'string' || rawKey.length > CUSTOM_API_KEY_MAX) throw new TypeError('custom provider apiKey is invalid');
+  const key = rawKey.trim();
+  if (!key) throw new Error('API key is required');
+  const takesStoredKey = () => {
+    const entry = existingCustomEntry(cfgMod.loadConfig(), id);
+    const config = storedCustomConfig(entry);
+    if ((config?.auth ?? entry.auth) === 'none') throw new Error('this custom provider needs no API key');
+    if (config?.apiKeyEnv) throw new Error(`this custom provider reads its key from ${config.apiKeyEnv}`);
+    return entry;
+  };
+  takesStoredKey();
+  // The provider's removal runs in the same queue, so it never lands between
+  // the checks and the write below; a removal queued earlier is seen by the
+  // check, before anything is written.
+  return serializeCustomKeySave(id, async () => {
+    takesStoredKey();
+    const account = SECRET_ACCOUNTS.agentApiKey(id);
+    const previousKey = getAgentApiKey(id);
+    await saveSecretAsync(account, key);
+    try {
+      return customProviderRow(id, takesStoredKey());
+    } catch (error) {
+      // Switched to keyless (or the provider is gone) meanwhile: the key written
+      // is dropped, and the previous one is only put back for a provider that exists.
+      const exists = isCustomProviderConfig(cfgMod.loadConfig().providers?.[id]);
+      if (exists && previousKey) await saveSecretAsync(account, previousKey);
+      else await deleteSecretAsync(account);
+      throw error;
+    }
+  });
+}
+
 const MODEL_PATCH_KEYS = new Set([
   'manual',
   'hidden',
@@ -1292,14 +1390,19 @@ export async function removeCustomProvider(cfgMod, rawId) {
   requireLocalProviderManagement();
   const id = String(rawId || '').trim();
   existingCustomEntry(cfgMod.loadConfig(), id);
-  // Secret first: a real keychain failure (locked, permission) leaves the
-  // provider registered so the removal can be retried. A missing secret
-  // (keyless provider) is not an error.
-  await deleteSecretAsync(SECRET_ACCOUNTS.agentApiKey(id));
-  const current = cfgMod.loadConfig();
-  const { [id]: _removed, ...providers } = current.providers || {};
-  cfgMod.saveConfig(withoutProviderReferences({ ...current, providers }, id), { baseConfig: current });
-  return { provider: id, type: 'custom', removed: true };
+  // In the provider's key queue: a key write in flight finishes first and
+  // none starts between the secret's deletion and the config's.
+  return serializeCustomKeySave(id, async () => {
+    existingCustomEntry(cfgMod.loadConfig(), id);
+    // Secret first: a real keychain failure (locked, permission) leaves the
+    // provider registered so the removal can be retried. A missing secret
+    // (keyless provider) is not an error.
+    await deleteSecretAsync(SECRET_ACCOUNTS.agentApiKey(id));
+    const current = cfgMod.loadConfig();
+    const { [id]: _removed, ...providers } = current.providers || {};
+    cfgMod.saveConfig(withoutProviderReferences({ ...current, providers }, id), { baseConfig: current });
+    return { provider: id, type: 'custom', removed: true };
+  });
 }
 
 export async function testCustomProvider(cfgMod, rawInput) {

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

@@ -21,6 +21,7 @@ import { MIXY_AGENT_ID, agentIdOfHomeSession } from '../../runtime/agent/orchest
 import { roomMemberOfSession } from '../../runtime/agent/orchestrator/session/agent-room.mjs';
 import { mixyDisplayName } from '../../runtime/agent/orchestrator/session/mixy-name.mjs';
 import { isAgentOwner } from '../../runtime/agent/orchestrator/agent-owner.mjs';
+import { isHeartbeatSession } from '../../runtime/shared/routine-trigger.mjs';
 import { unattendedRunOf } from '../held-requests.mjs';
 
 const INTERACTIVE_SOURCE_TYPES = new Set(['', 'lead', 'cli']);
@@ -40,6 +41,8 @@ function provenanceScope(session, id) {
   if (member) return { kind: 'room-member', agentId: member.agentId };
   const homeAgent = agentIdOfHomeSession(id);
   if (homeAgent) return homeAgent === MIXY_AGENT_ID ? { kind: 'human' } : { kind: 'agent', agentId: homeAgent };
+  // Mixy's hidden heartbeat session: her own scope, as her chat's routine turns get.
+  if (isHeartbeatSession(id)) return { kind: 'agent', agentId: MIXY_AGENT_ID };
   const headless =
     !id ||
     isAgentOwner(session) ||
@@ -108,6 +111,17 @@ export function assertOwnAgentSettings(scope, agentId, action) {
   }
 }
 
+/** Throws unless Mixy's heartbeat session `sessionId` may take setup `action`
+ *  with `args`: on her own she only pauses a routine or runs one again; every
+ *  other change she proposes (MIXY.md). Any other session passes. */
+export function assertHeartbeatSetupAction(sessionId, action, args) {
+  if (!isHeartbeatSession(sessionId)) return;
+  if (action === 'run_automation' || (action === 'set_automation_enabled' && args?.enabled === false)) return;
+  throw new Error(
+    `A heartbeat turn only pauses a routine or runs one again (setup ${action} is refused); propose other changes with session action suggest`
+  );
+}
+
 /** Throws when `scope` is a headless run: it reads settings, never changes
  *  them; an unattended run changes only its own bot's automations and route. */
 export function assertInteractiveCaller(scope, action) {

package/src/session-runtime/services/usage-dashboard-model.mjs

@@ -348,6 +348,7 @@ const PROVIDER_RANKS = {
   'command-code-oauth': 33.5,
   'mimo-oauth': 34,
   'cursor-oauth': 35,
+  'devin-oauth': 35.5,
   'antigravity-oauth': 36,
   'opencode-go-oauth': 38,
   openai: 50,

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

@@ -9,7 +9,7 @@ import { readAgentFrontmatterPermission } from '../services/agent-tool/helpers.m
 import { LEAD_DISALLOWED_TOOLS } from '../../runtime/agent/orchestrator/runtime-core/tool-defs.mjs';
 import { HEADLESS_TOOL_PROFILE } from '../../runtime/agent/orchestrator/runtime-core/tool-profile.mjs';
 import { AGENT_MODE, resolveSessionMode } from '../../runtime/agent/orchestrator/session/agent-mode.mjs';
-import { MIXY_AGENT_ID, agentIdOfHomeSession } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
+import { agentIdOfHomeSession } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
 import { roomMemberOfSession } from '../../runtime/agent/orchestrator/session/agent-room.mjs';
 import { unattendedApprovalPort } from '../../runtime/agent/orchestrator/session/human-gate/gate.mjs';
 
@@ -70,7 +70,7 @@ export function sessionOptions(deps, coreMemoryContext) {
   const workflowContext = packContext;
   const leadWorkflowParts = agentOwned
     ? undefined
-    : leadPromptParts({ agentMode: sessionMode === AGENT_MODE, mixy: actingAgent === MIXY_AGENT_ID });
+    : leadPromptParts({ agentMode: sessionMode === AGENT_MODE, agentId: actingAgent });
   const callerDisallowedTools = [
     ...(agentOwned ? [] : LEAD_DISALLOWED_TOOLS),
     ...(!agentOwned && rt.disallowDelegation ? ['agent'] : []),
@@ -88,17 +88,20 @@ export function sessionOptions(deps, coreMemoryContext) {
     lane: agentOwned ? 'agent' : 'cli',
     // One-shot `mixdog exec` runs carry their own source so session catalogs
     // can keep them out of the user's resumable list.
+    // A hidden run of an agent (Mixy's heartbeat) is an exec run too.
     sourceType: agentOwned
       ? sessionProfile?.sourceType || 'agent'
-      : rt.toolProfile === HEADLESS_TOOL_PROFILE
+      : rt.toolProfile === HEADLESS_TOOL_PROFILE || sessionProfile?.sourceType === 'exec'
         ? 'exec'
         : 'lead',
     sourceName: agentOwned
       ? sessionProfile?.sourceName || sessionProfile?.agent || 'agent'
       : taskOrigin
         ? `agent:${taskOrigin.agentId}${taskOriginSuffix(taskOrigin)}`
-        : 'main',
+        : clean(sessionProfile?.sourceName) || 'main',
     ...(taskOrigin ? { taskOrigin } : {}),
+    // The agent a run acts for (agent mode, its memory; agent-mode.mjs).
+    ...(!agentOwned && clean(sessionProfile?.ownerAgentId) ? { ownerAgentId: clean(sessionProfile.ownerAgentId) } : {}),
     ...(rt.approvalMode ? { approvalMode: rt.approvalMode } : {}),
     clientHostPid: sessionProfile?.clientHostPid || process.pid,
     mcpScopeId: rt.mcpScopeId,

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

@@ -1,4 +1,5 @@
-// Automation worker status, the system shell and self-update settings.
+// Automation worker status, the system shell, self-update, Mixy's heartbeat
+// and bots' reactions settings.
 export function createSystemSettings({
   getConfig,
   saveConfigAndAdopt,
@@ -49,6 +50,20 @@ export function createSystemSettings({
       });
       return this.getUpdateSettings();
     },
+    getHeartbeatSettings() {
+      return { heartbeat: getConfig()?.heartbeat !== false };
+    },
+    setHeartbeatEnabled(enabled) {
+      saveConfigAndAdopt({ ...getConfig(), heartbeat: enabled === true });
+      return this.getHeartbeatSettings();
+    },
+    getReactionSettings() {
+      return { reactions: getConfig()?.reactions !== false };
+    },
+    setReactionsEnabled(enabled) {
+      saveConfigAndAdopt({ ...getConfig(), reactions: enabled === true });
+      return this.getReactionSettings();
+    },
     async checkForUpdate(options = {}) {
       await checkForUpdateInternal({ force: options?.force === true });
       return this.getUpdateSettings();

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

@@ -12,6 +12,7 @@ import { SETUP_DESKTOP_DOMAINS, SETUP_HANDOFFS } from './settings-contract.mjs';
 import { executeExtendedSetupAction, publicAutomation, publicHookRule, validateMcpInput } from './extended-actions.mjs';
 import {
   assertAgentEditorAccess,
+  assertHeartbeatSetupAction,
   assertInteractiveCaller,
   assertOwnAgentSettings,
   scheduleCallerScope,
@@ -44,6 +45,12 @@ const ACTION_APPLIES_TO = {
     "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_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_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',
   set_system_shell: 'subsequent shell calls',
   save_automation: 'the automation worker; scheduled runs follow the saved timing',
@@ -54,7 +61,7 @@ const ACTION_APPLIES_TO = {
   add_hook_rule: 'subsequent tool calls; no restart required',
   set_hook_rule_enabled: 'subsequent tool calls; no restart required',
   delete_hook_rule: 'subsequent tool calls; no restart required',
-  set_media_default: 'media generations that omit lane/model, and the Studio selection',
+  set_media_default: 'media generations that name no lane/model; lane "" returns the kind to Auto',
 };
 
 const OPEN_TARGET_HINTS = Object.freeze({
@@ -65,11 +72,11 @@ const OPEN_TARGET_HINTS = Object.freeze({
   workflow: 'Desktop: Workflows · TUI: /workflow',
   agents: 'Desktop: Workflows → Agents · TUI: /agents',
   outputstyle: 'Desktop: Settings → Output style · TUI: /OutputStyle',
-  theme: 'Desktop: Settings → General → Theme · TUI: /theme',
+  theme: 'Desktop: Settings → Theme · TUI: /theme',
   profile: 'Desktop: Settings → General → Profile · TUI: /profile',
   autoclear: 'Desktop: Settings → Context · TUI: /autoclear',
   memory:
-    'Desktop: Extensions → Plugin → Built-in (Memory); core memories under Projects → project → Memories · TUI: /memory',
+    'Desktop: Extensions tab → Built-in (Memory); core memories under Projects → project → Memories · TUI: /memory',
   mcp: 'Desktop: Extensions → Connectors tab · TUI: /mcp',
   skills: 'Desktop: Skills (activity rail) · TUI: /skills',
   plugins:
@@ -79,7 +86,7 @@ const OPEN_TARGET_HINTS = Object.freeze({
   doctor: 'Desktop: Settings → System → Doctor, or /doctor in the composer · TUI: /doctor',
   context: 'Desktop: /context in the composer · TUI: /context',
   developer: 'Desktop: Settings → Developer options · TUI: /setting → Developer',
-  voice: 'Desktop: Extensions → Plugin → Built-in (Voice) · TUI: /setting → Voice',
+  voice: 'Desktop: Extensions tab → Built-in (Voice) · TUI: /setting → Voice',
   connection: 'Desktop only: Settings → Connection',
 });
 
@@ -277,16 +284,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 },
+    reactions: { enabled: config?.reactions !== false },
     voice: rt.getVoiceStatus ? voiceFeatureStatus(await rt.getVoiceStatus()) : null,
   };
 }
 
 async function mediaDefaults(rt) {
-  const rows = await Promise.all(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 {
-    defaults: Object.fromEntries(
-      MEDIA_KINDS.map((kind, i) => [kind, rows[i] ? { lane: rows[i].lane, model: rows[i].model } : null])
-    ),
+    // The default generator (Settings → Built-in → Media generation); null = Auto.
+    pinned: Object.fromEntries(MEDIA_KINDS.map((kind) => [kind, fieldsOf(pins[kind], ['lane', 'model', 'account'])])),
+    // The last generator used; applies only to a kind that is on Auto.
+    remembered: Object.fromEntries(MEDIA_KINDS.map((kind, i) => [kind, fieldsOf(rows[i], ['lane', 'model'])])),
   };
 }
 
@@ -324,7 +335,15 @@ const SETUP_STATUS_READERS = {
     features: await featureStatus(rt, getConfig),
     onboarding: rt.getOnboardingStatus?.() || null,
   }),
-  model: (rt) => ({ route: mainRoute(rt), effortOptions: rt.effortOptions || [] }),
+  model: (rt) => ({
+    route: {
+      ...mainRoute(rt),
+      autoEffort: rt.autoEffort !== false,
+      // The Lead preset (workflow-lead) holds the Lead route's fallback chain, as the Workflows page reads it.
+      fallbacks: (rt.listPresets?.() || []).find((preset) => preset?.id === 'workflow-lead')?.fallbacks || [],
+    },
+    effortOptions: rt.effortOptions || [],
+  }),
   agents: (rt) => ({
     agents: rt.listAgents?.() || [],
     orchestrationMode: rt.getOrchestrationMode(),
@@ -347,19 +366,23 @@ const SETUP_STATUS_READERS = {
     };
   },
   autoclear: (rt) => rt.getAutoClear?.() || {},
-  compaction: (rt) => rt.getCompactionSettings?.() || {},
+  compaction: (rt) => ({ ...(rt.getCompactionSettings?.() || {}), ...(rt.getSessionTitleSettings?.() || {}) }),
   memory: (rt) => ({ ...(rt.getToolModuleSettings?.()?.memory || {}), recap: rt.getRecapSettings?.() || null }),
   'local-provider': (rt) => rt.getToolModuleSettings().localProvider,
   features: (rt, { getConfig }) => featureStatus(rt, getConfig),
   shell: (rt) => rt.getSystemShell?.() || {},
   providers: async (rt, { detail }) => {
     const rows = publicProviderRows(await rt.getProviderSetup?.({}));
+    const quotaResume = rt.getQuotaAutoResume ? { quotaAutoResume: rt.getQuotaAutoResume() } : {};
     // Client mode: the desktop owns accounts, so the server roster is never read.
     if (rows.managedByClient) {
-      if (detail) return rows;
-      return { managedByClient: true, unavailable: rows.unavailable, ...configuredProviderRows(rows) };
+      if (detail) return { ...rows, ...quotaResume };
+      return { managedByClient: true, unavailable: rows.unavailable, ...configuredProviderRows(rows), ...quotaResume };
     }
-    if (!detail) return configuredProviderRows(rows, (id) => rt.getProviderAccounts(id).accounts.length);
+    if (!detail) {
+      return { ...configuredProviderRows(rows, (id) => rt.getProviderAccounts(id).accounts.length), ...quotaResume };
+    }
+    Object.assign(rows, quotaResume);
     rows.oauth = rows.oauth.map((row) =>
       row.authenticated ? { ...row, accounts: publicAccounts(rt.getProviderAccounts(row.id)) } : row
     );
@@ -597,6 +620,16 @@ const SETUP_ACTION_HANDLERS = {
     rt.deleteLocalProviderModel(requireText(args.confirmationToken, 'confirmationToken')),
   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_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);
+    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_reactions_enabled: (rt, args) => rt.setReactionsEnabled(requireBoolean(args.enabled)),
   set_worktree_settings: (rt, args) => rt.setWorktreeSettings(args.worktree),
   forget_provider_auth: async (rt, args) => {
     const name = requireText(args.name, 'name');
@@ -666,7 +699,7 @@ const SETUP_ACTION_HANDLERS = {
   // as Extensions → 커넥터. Nothing is connected here.
   connect_connector: async (rt, args) => {
     const entry = connectorById(requireText(args.connector, 'connector'));
-    if (!entry || entry.ownKey) throw new Error(`connector must be one of ${CONNECTOR_IDS.join(', ')}`);
+    if (!entry) throw new Error(`connector must be one of ${CONNECTOR_IDS.join(', ')}`);
     const server = (rt.mcpStatus?.()?.servers || []).find((row) => row.connector === entry.id) || null;
     const connected = server?.connected === true;
     return {
@@ -786,6 +819,8 @@ export function createSetupToolExecutor({
       }
       if (action === 'set_agent_route') assertOwnAgentSettings(scope, args.agent, action);
     }
+    // Mixy's heartbeat session takes only its two routine actions, reads included.
+    assertHeartbeatSetupAction(sessionId, action, args);
     const rt = action === 'status' || action === 'open' ? null : api();
     if (!Object.hasOwn(SETUP_ACTION_HANDLERS, action)) {
       return executeExtendedSetupAction(rt, args, requestDesktop, { sessionId, caller });

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

@@ -33,9 +33,16 @@ function compactModelRow(row) {
     efforts: (row.effortOptions || []).map((option) => option.value),
     ...(row.fastCapable === true ? { fast: true } : {}),
     ...(row.supportsVision === true ? { vision: true } : {}),
+    ...modelPreferenceFields(row),
   };
 }
 
+/** The model-management choices, only when set (savedHidden is an explicit /model visibility choice). */
+const modelPreferenceFields = (row) => ({
+  ...(typeof row.savedHidden === 'boolean' ? { hidden: row.savedHidden } : {}),
+  ...(row.favorite === true ? { favorite: true } : {}),
+});
+
 const isPresent = (value) =>
   value != null && value !== '' && value !== false && !(typeof value === 'object' && !Object.keys(value).length);
 
@@ -64,7 +71,7 @@ function modelDetail(row) {
     defaultModelParameters: row.defaultModelParameters,
     supportsMaxMode: row.supportsMaxMode,
   };
-  return Object.fromEntries(Object.entries(detail).filter(([, value]) => isPresent(value)));
+  return { ...Object.fromEntries(Object.entries(detail).filter(([, value]) => isPresent(value))), ...modelPreferenceFields(row) };
 }
 
 function findModel(rows, id, provider) {
@@ -283,6 +290,7 @@ export const EXTENDED_SETUP_HANDLERS = Object.freeze({
     if (kind === 'webhook' && ['time', 'at', 'timezone', 'days'].some((key) => own(input, key))) {
       throw new Error('Schedule fields (timing) are not accepted for webhooks');
     }
+    if (kind === 'webhook' && own(input, 'newName')) throw new Error('newName (rename) is schedule-only');
     if (kind === 'schedule' && own(input, 'parser')) throw new Error('parser is a webhook-only field');
     let previous = {};
     if (input.overwrite) {
@@ -363,6 +371,12 @@ export const EXTENDED_SETUP_HANDLERS = Object.freeze({
       .sections.flatMap((section) => section.options)
       .find((row) => row.id === args.name);
     if (!option) throw new Error(`Unknown developer option "${args.name}"; read status developer`);
+    // An agent must never remove its own approval cards: only the person turns this on.
+    if (args.enabled && option.id === 'allowAllActions') {
+      throw new Error(
+        `"${option.label}" cannot be turned on by an agent; only the person can turn it on in Settings → Developer options.`
+      );
+    }
     if (args.enabled && option.warning && !args.riskAccepted) {
       throw new Error(
         `Enabling ${option.label} requires riskAccepted:true after the user explicitly accepts: ${option.warning}`
@@ -401,7 +415,12 @@ export const EXTENDED_SETUP_HANDLERS = Object.freeze({
   },
   async set_media_default(rt, args) {
     if (!MEDIA_KINDS.includes(args.kind)) throw new Error(`kind must be one of ${MEDIA_KINDS.join(', ')}`);
-    const lane = (await rt.listMediaLanes()).find((row) => row.id === args.lane);
+    // A blank lane returns the kind to Auto, as the Settings control does.
+    if (!String(args.lane).trim()) {
+      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);
     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];
@@ -409,7 +428,14 @@ export const EXTENDED_SETUP_HANDLERS = Object.freeze({
     if (own(args, 'model') && !spec.models.some((model) => model.id === args.model)) {
       throw new Error(`model "${args.model}" is not available on ${lane.id}/${args.kind}`);
     }
-    return { media: await rt.setMediaDefault(pick(args, ['kind', 'lane', 'model'])) };
+    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`);
+      }
+    }
+    const pin = await rt.setMediaPin({ kind: args.kind, lane: args.lane, model: args.model, account: args.accountId });
+    return { kind: args.kind, media: pin };
   },
 });