mixdog 1.3.4 → 1.4.0

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/seeds.mjs

@@ -49,34 +49,6 @@ export function ensureStandaloneEnvironment({ rootDir, dataDir }) {
       /* marker only; the sweep simply repeats */
     }
   }
-  cleanupRetiredChannelSecrets(dataDir);
-}
-
-// One-shot keychain cleanup: Discord/Telegram messaging is retired, so any
-// stored bot tokens are orphans. Marker-gated so the (potentially slow) OS
-// keychain roundtrip runs once per install; lazy import so shared config
-// resolves its paths only after the env above is established.
-function cleanupRetiredChannelSecrets(dataDir) {
-  const marker = join(dataDir, '.retired-channel-secrets-cleaned');
-  if (existsSync(marker)) return;
-  void import('../../runtime/shared/config.mjs')
-    .then(async ({ deleteSecretAsync }) => {
-      for (const account of ['discord.token', 'telegram.token']) {
-        try {
-          await deleteSecretAsync(account);
-        } catch {
-          /* best-effort */
-        }
-      }
-      try {
-        writeFileAtomicSync(marker, `${new Date().toISOString()}\n`);
-      } catch {
-        /* marker only */
-      }
-    })
-    .catch(() => {
-      /* cleanup is best-effort */
-    });
 }
 
 // Shipped definitions live in code (read in place from the package); the data

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-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

@@ -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';
 
@@ -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)
@@ -70,7 +71,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 +89,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-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,4 +1,10 @@
-// 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.
+import {
+  normalizeHeartbeatIntervalMinutes,
+  requireHeartbeatIntervalMinutes,
+} from '../runtime/shared/heartbeat-interval.mjs';
+
 export function createSystemSettings({
   getConfig,
   saveConfigAndAdopt,
@@ -49,6 +55,27 @@ export function createSystemSettings({
       });
       return this.getUpdateSettings();
     },
+    getHeartbeatSettings() {
+      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 };
+    },
+    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/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,
+  }),
+};