mixdog 1.3.0 → 1.3.2

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

@@ -9,7 +9,20 @@ 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 } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
+import { MIXY_AGENT_ID, 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';
+
+/** Where a bot created its task session, recorded after its id in the
+ *  session's `sourceName` (`agent:<id>@home|room|run`): the desktop lets the
+ *  task act as the bot (its standing allows, "always allow") only when it came
+ *  from the bot's own attended chat. None when the origin is anything else. */
+function taskOriginSuffix(taskOrigin) {
+  const from = clean(taskOrigin?.sessionId);
+  if (roomMemberOfSession(from)) return '@room';
+  if (unattendedApprovalPort()?.runOf?.(from)) return '@run';
+  return agentIdOfHomeSession(from) === clean(taskOrigin?.agentId) ? '@home' : '';
+}
 
 // Ownership and permission fields an agent-owned session inherits from its profile.
 function agentOwnedSessionFields(sessionProfile) {
@@ -83,7 +96,7 @@ export function sessionOptions(deps, coreMemoryContext) {
     sourceName: agentOwned
       ? sessionProfile?.sourceName || sessionProfile?.agent || 'agent'
       : taskOrigin
-        ? `agent:${taskOrigin.agentId}`
+        ? `agent:${taskOrigin.agentId}${taskOriginSuffix(taskOrigin)}`
         : 'main',
     ...(taskOrigin ? { taskOrigin } : {}),
     ...(rt.approvalMode ? { approvalMode: rt.approvalMode } : {}),

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

@@ -8,8 +8,10 @@ import {
   setBuiltinInstalledInConfig,
 } from '../runtime/agent/orchestrator/runtime-core/builtin-features.mjs';
 import { featureEnvOverride, moduleEnabled } from '../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
+import { normalizeAgentAvatar } from '../runtime/shared/agent-avatar.mjs';
 import { LOCAL_PROVIDER_ID } from '../runtime/local-provider/managed-runtime.mjs';
 import { INSTRUCTION_FILES_MODES, normalizeInstructionFilesMode } from '../runtime/shared/instruction-files-mode.mjs';
+import { AUTO_EFFORT_BASES, autoEffortBase } from '../runtime/agent/orchestrator/providers/auto-effort.mjs';
 import { getEmbeddingInfo } from '../runtime/memory/lib/embedding-provider.mjs';
 import { onnxRuntimeSupported } from '../runtime/shared/onnx-runtime-support.mjs';
 import {
@@ -21,6 +23,14 @@ import {
   shutdownEffortJudge,
 } from '../runtime/effort-judge/judge-client.mjs';
 
+const MAX_BOT_ORDER_IDS = 500;
+const isBotOrderId = (id) => typeof id === 'string' && id.trim().length > 0 && id.trim().length <= 128;
+/** A stored bot order as trimmed, de-duplicated ids; anything else is no order (null). */
+function normalizeBotOrder(value) {
+  if (!Array.isArray(value)) return null;
+  return [...new Set(value.filter(isBotOrderId).map((id) => id.trim()))].slice(0, MAX_BOT_ORDER_IDS);
+}
+
 const TOGGLEABLE_BUILTINS = ['git', 'office', 'tidy', 'localProvider', 'autoEffort', 'visualize', 'media'];
 
 function setLocalProviderEnabledInConfig(configLike, enabled) {
@@ -85,12 +95,50 @@ export function createBuiltinToolSettings(
       saveConfigAndAdopt({ ...getConfig(), aiSessionTitles: enabled !== false });
       return this.getSessionTitleSettings();
     },
+    // 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.
+    getLeadAppearance() {
+      const avatar = normalizeAgentAvatar(getConfig()?.leadAvatar);
+      return { avatar: avatar?.kind === 'mascot' ? avatar : null };
+    },
+    setLeadAppearance(avatar) {
+      const config = { ...getConfig() };
+      if (avatar == null) {
+        delete config.leadAvatar;
+      } else {
+        const normalized = normalizeAgentAvatar(avatar);
+        if (normalized?.kind !== 'mascot') throw new Error('usage: setLeadAppearance(a mascot appearance or null)');
+        config.leadAvatar = normalized;
+      }
+      saveConfigAndAdopt(config);
+      return this.getLeadAppearance();
+    },
+    // The one bot order every device that follows this host shows (Bots page
+    // and the Sessions bot section): agent ids only. Mixy is pinned first by
+    // the UI and is not part of it; ids of unknown or deleted bots are ignored
+    // where the order is applied. No key = the UI's current order.
+    getBotOrder() {
+      return { order: normalizeBotOrder(getConfig()?.botOrder) ?? [] };
+    },
+    setBotOrder(order) {
+      if (!Array.isArray(order) || order.length > MAX_BOT_ORDER_IDS || order.some((id) => !isBotOrderId(id))) {
+        throw new Error('usage: setBotOrder(an array of agent ids)');
+      }
+      const config = { ...getConfig() };
+      const ids = normalizeBotOrder(order);
+      if (!ids.length) delete config.botOrder;
+      else config.botOrder = ids;
+      saveConfigAndAdopt(config);
+      return this.getBotOrder();
+    },
     getToolModuleSettings() {
       const config = getConfig();
       const localProvider = getLocalProviderStatus?.() || {};
       const localProviderRuntimeInstalled = localProvider?.runtime?.installed === true;
       return {
         instructionFiles: normalizeInstructionFilesMode(config?.instructionFiles),
+        autoEffortBase: autoEffortBase(config?.autoEffortBase),
         webSearch: { enabled: webSearchEnabled() },
         memory: {
           enabled: memoryToolsEnabledFn(),
@@ -152,6 +200,14 @@ export function createBuiltinToolSettings(
       await refreshEmptySessionToolPolicy?.();
       return this.getToolModuleSettings();
     },
+    /** The global "Auto reasoning base": the effort Auto works around. */
+    setAutoEffortBase(level) {
+      if (!AUTO_EFFORT_BASES.includes(level)) {
+        throw new TypeError(`Auto reasoning base must be one of ${AUTO_EFFORT_BASES.join(', ')}.`);
+      }
+      saveConfigAndAdopt({ ...getConfig(), autoEffortBase: level });
+      return this.getToolModuleSettings();
+    },
     async setMemoryToolsEnabled(enabled) {
       const config = getConfig();
       const memoryEnabled = enabled !== false;
@@ -202,11 +258,17 @@ export function createBuiltinToolSettings(
     /** Extensions → Built-in Install: run the feature's preparation adapter
      *  (model pre-download, component verification), then mark it installed
      *  and enabled in one step. New sessions pick up the tool surface. */
-    async installBuiltinFeature(name) {
+    async installBuiltinFeature(name, options = null) {
       if (!INSTALLABLE_BUILTIN_IDS.includes(name)) {
         throw new TypeError('Built-in feature must be git, memory, office, tidy, localProvider, or autoEffort.');
       }
       if (name === 'autoEffort' && !onnxRuntimeSupported()) throw new Error(EFFORT_JUDGE_UNSUPPORTED);
+      // Code Tidy retry for named engines: fetch just those and leave the
+      // feature's installed/enabled state exactly as the user set it.
+      if (name === 'tidy' && Array.isArray(options?.engines)) {
+        await prepareBuiltinFeature?.(name, { engines: options.engines });
+        return this.getToolModuleSettings();
+      }
       await prepareBuiltinFeature?.(name);
       const config = getConfig();
       let nextConfig = setBuiltinInstalledInConfig({ ...config }, name, true);

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

@@ -3,6 +3,8 @@ import {
   refreshLiveSessionsProviderCacheOpts,
   refreshSessionProviderCacheOpts,
 } from '../runtime/agent/orchestrator/session/manager/session-lifecycle.mjs';
+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.
@@ -32,9 +34,60 @@ const SESSION_COMPACTION_KEYS = [
   'recallWindowSize',
   'recallConcurrency',
   'recallCycle1DeadlineMs',
+  // Replaced by summaryMode.
+  'useMaintainer',
   ...MAIN_BUFFER_KEYS,
 ];
 
+// Unlimited (never auto-clear) typed as a duration.
+const UNLIMITED_DURATION = /^(?:unlimited|never)$/i;
+
+/** Fold the recognised compaction input fields into `next` (mutated and returned). */
+function applyCompactionInput(next, input, hasOwn) {
+  if (hasOwn(input, 'auto')) next.auto = input.auto !== false;
+  if (hasOwn(input, 'enabled')) next.auto = input.enabled !== false;
+  if (hasOwn(input, 'onModelChange')) next.onModelChange = input.onModelChange !== false;
+  if (hasOwn(input, 'summaryMode')) {
+    if (!COMPACTION_SUMMARY_MODES.includes(input.summaryMode)) {
+      throw new Error(`usage: summaryMode ${COMPACTION_SUMMARY_MODES.join(' | ')}`);
+    }
+    next.summaryMode = input.summaryMode;
+  }
+  // Legacy Compact type fields are intentionally ignored. There is one
+  // fresh-context Compact contract for every session.
+  // A new budget representation replaces the previous one. Otherwise a
+  // saved token override silently outranks a later percentage edit.
+  if (MAIN_BUFFER_KEYS.some((key) => hasOwn(input, key))) {
+    for (const old of MAIN_BUFFER_KEYS) delete next[old];
+  }
+  for (const key of MAIN_BUFFER_KEYS) {
+    if (hasOwn(input, key)) next[key] = input[key];
+  }
+  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 —
+// not the full built-in table.
+function enabledProviderKeys(config, provider) {
+  const enabledProviders = new Set(
+    Object.entries(config?.providers || {})
+      .filter(([, v]) => v && typeof v === 'object' && v.enabled !== false)
+      .map(([k]) => String(k).toLowerCase())
+  );
+  if (provider) enabledProviders.add(String(provider).toLowerCase());
+  return enabledProviders;
+}
+
 export function createCompactionSettings({
   getConfig,
   getRoute,
@@ -63,9 +116,21 @@ export function createCompactionSettings({
     if (input.resetProvider === true || (hasOwn(input, 'idleMs') && input.idleMs == null)) {
       delete providerIdleMs[providerKey];
     } else {
-      const idleMs = hasOwn(input, 'duration') ? parseDurationMs(input.duration) : Number(input.idleMs);
-      if (!idleMs || !Number.isFinite(idleMs) || idleMs <= 0) throw new Error('usage: duration like 10m, 1h, or 24h');
-      providerIdleMs[providerKey] = Math.max(60_000, Math.round(idleMs));
+      // Unlimited (never auto-clear) is stored as 0: `unlimited: true`, a
+      // duration of 'unlimited'/'never', or idleMs 0.
+      const unlimited =
+        input.unlimited === true ||
+        (hasOwn(input, 'duration') && UNLIMITED_DURATION.test(String(input.duration ?? '').trim())) ||
+        (!hasOwn(input, 'duration') && hasOwn(input, 'idleMs') && input.idleMs === 0);
+      if (unlimited) {
+        providerIdleMs[providerKey] = 0;
+      } else {
+        const idleMs = hasOwn(input, 'duration') ? parseDurationMs(input.duration) : Number(input.idleMs);
+        if (!idleMs || !Number.isFinite(idleMs) || idleMs <= 0) {
+          throw new Error('usage: duration like 10m, 1h, 24h, or unlimited');
+        }
+        providerIdleMs[providerKey] = Math.max(60_000, Math.round(idleMs));
+      }
     }
     saveConfigAndAdopt({ ...config, autoClear: { ...next, providerIdleMs } });
     refreshLeadCacheOpts();
@@ -79,28 +144,10 @@ export function createCompactionSettings({
     setCompactionSettings(input = {}) {
       const config = getConfig();
       const current = normalizeCompactionConfig(config.compaction);
-      const next = { ...current };
-      if (hasOwn(input, 'auto')) next.auto = input.auto !== false;
-      if (hasOwn(input, 'enabled')) next.auto = input.enabled !== false;
-      if (hasOwn(input, 'onModelChange')) next.onModelChange = input.onModelChange !== false;
-      // Legacy Compact type fields are intentionally ignored. There is one
-      // fresh-context Compact contract for every session.
-      // A new budget representation replaces the previous one. Otherwise a
-      // saved token override silently outranks a later percentage edit.
-      if (MAIN_BUFFER_KEYS.some((key) => hasOwn(input, key))) {
-        for (const old of MAIN_BUFFER_KEYS) delete next[old];
-      }
-      for (const key of MAIN_BUFFER_KEYS) {
-        if (hasOwn(input, key)) next[key] = input[key];
-      }
+      const next = applyCompactionInput({ ...current }, input, hasOwn);
       saveConfigAndAdopt({ ...config, compaction: normalizeCompactionConfig(next) });
       const saved = normalizeCompactionConfig(getConfig().compaction);
-      const session = getSession();
-      if (session) {
-        const currentSessionCompaction = { ...(session.compaction || {}) };
-        for (const key of SESSION_COMPACTION_KEYS) delete currentSessionCompaction[key];
-        session.compaction = { ...currentSessionCompaction, ...saved };
-      }
+      adoptSessionCompaction(getSession(), saved);
       invalidateContextStatusCache();
       return saved;
     },
@@ -113,22 +160,17 @@ export function createCompactionSettings({
       const idleMs = resolveAutoClearIdleMs(config, provider);
       const key = String(provider || '').toLowerCase();
       const providerCustom = Boolean(key && key !== 'default' && normalized.providerIdleMs?.[key]);
-      // 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 —
-      // not the full built-in table.
-      const enabledProviders = new Set(
-        Object.entries(config?.providers || {})
-          .filter(([, v]) => v && typeof v === 'object' && v.enabled !== false)
-          .map(([k]) => String(k).toLowerCase())
-      );
-      if (provider) enabledProviders.add(String(provider).toLowerCase());
-      const providerDefaults = autoClearProviderDefaults(normalized.providerIdleMs).filter(
+      const enabledProviders = enabledProviderKeys(config, provider);
+      // Every enabled provider gets its row, including ones without a
+      // built-in window (they resolve through the 'default' row).
+      const providerDefaults = autoClearProviderDefaults(normalized.providerIdleMs, [...enabledProviders]).filter(
         (entry) => entry.provider === 'default' || entry.custom === true || enabledProviders.has(entry.provider)
       );
       return {
         enabled: normalized.enabled,
         idleMs,
+        unlimited: isAutoClearUnlimited(idleMs),
+        label: isAutoClearUnlimited(idleMs) ? 'unlimited' : formatDurationMs(idleMs),
         custom: normalized.custom,
         providerCustom,
         providerDefault,
@@ -148,11 +190,17 @@ export function createCompactionSettings({
           throw new Error('autoclear minContextPercent must be a number between 0 and 100');
         next.minContextPercent = Math.min(100, Math.max(0, Math.round(rawMinPct)));
       }
-      const providerKey = String(input.provider || '')
+      // `/autoclear unlimited` names no provider: it means the current route's.
+      const wantsUnlimited = hasOwn(input, 'duration') && UNLIMITED_DURATION.test(String(input.duration ?? '').trim());
+      const providerKey = String(input.provider || (wantsUnlimited ? getRoute()?.provider : '') || '')
         .trim()
         .toLowerCase();
       const editsProviderDefault =
-        providerKey && (input.resetProvider === true || hasOwn(input, 'duration') || hasOwn(input, 'idleMs'));
+        providerKey &&
+        (input.resetProvider === true ||
+          input.unlimited === true ||
+          hasOwn(input, 'duration') ||
+          hasOwn(input, 'idleMs'));
       if (editsProviderDefault) {
         saveProviderIdle(config, next, providerKey, input);
       } else {
@@ -165,15 +213,14 @@ export function createCompactionSettings({
         }
         if (hasOwn(input, 'duration')) {
           const idleMs = parseDurationMs(input.duration);
-          if (!idleMs) throw new Error('usage: /autoclear [on|off|status|<minutes|1h|90m>]');
+          if (!idleMs) throw new Error('usage: /autoclear [on|off|status|<minutes|1h|90m>|unlimited]');
           next.idleMs = idleMs;
           if (!hasOwn(input, 'enabled')) next.enabled = true;
         }
         saveConfigAndAdopt({ ...config, autoClear: next });
         refreshLeadCacheOpts();
       }
-      const resolved = this.getAutoClear();
-      return { ...resolved, label: formatDurationMs(resolved.idleMs) };
+      return this.getAutoClear();
     },
   };
 }

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

@@ -5,6 +5,7 @@
  *  registers the tool executor before it finishes assembling the API object. */
 import { builtinFeatureActive } from '../../runtime/agent/orchestrator/runtime-core/builtin-features.mjs';
 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 { MEDIA_KINDS } from '../../runtime/media/tool-defs.mjs';
 import { SETUP_DESKTOP_DOMAINS, SETUP_HANDOFFS } from './settings-contract.mjs';
@@ -377,6 +378,17 @@ const SETUP_STATUS_READERS = {
 // schema, the per-action field list and the route/object-argument minimums.
 function validateSetupInput(args) {
   const action = requireEnum(args?.action, SETUP_ACTIONS, 'action');
+  // Old callers still ask to connect GitHub: it is the signed-in GitHub CLI, not a catalog connector.
+  if (
+    action === 'connect_connector' &&
+    String(args.connector ?? '')
+      .trim()
+      .toLowerCase() === 'github'
+  ) {
+    throw new Error(
+      'GitHub uses the signed-in GitHub CLI; no connector needed. Use the github tool or Settings → Git.'
+    );
+  }
   const validationError = schemaValueError({ ...args, action }, SETUP_TOOL_DEFS[0].inputSchema, 'setup');
   if (validationError) throw new Error(`[tool-input-validation] ${validationError}`);
   const fields = SETUP_ACTION_FIELDS[action].split(' ').filter(Boolean);
@@ -392,8 +404,11 @@ function validateSetupInput(args) {
     if (action !== 'set_agent_route' && Object.hasOwn(args.route, 'disabled')) {
       throw new Error('route.disabled is only accepted by set_agent_route');
     }
-    if (Object.hasOwn(args.route, 'fallbacks') && !['set_agent_route', 'set_web_search_route'].includes(action)) {
-      throw new Error('route.fallbacks is only accepted by set_agent_route and set_web_search_route');
+    if (
+      Object.hasOwn(args.route, 'fallbacks') &&
+      !['set_route', 'set_agent_route', 'set_web_search_route'].includes(action)
+    ) {
+      throw new Error('route.fallbacks is only accepted by set_route, set_agent_route and set_web_search_route');
     }
     for (const field of ['contextPercent', 'contextTokens', 'autoEffort']) {
       if (action !== 'set_route' && action !== 'set_agent_route' && Object.hasOwn(args.route, field)) {
@@ -522,6 +537,8 @@ const SETUP_ACTION_HANDLERS = {
   set_web_search_enabled: (rt, args) => rt.setWebSearchEnabled(requireBoolean(args.enabled)),
   set_instruction_files: (rt, args) =>
     rt.setInstructionFiles(requireEnum(args.instructionFiles, INSTRUCTION_FILES_MODES, 'instructionFiles')),
+  set_auto_effort_base: (rt, args) =>
+    rt.setAutoEffortBase(requireEnum(args.autoEffortBase, AUTO_EFFORT_BASES, 'autoEffortBase')),
   set_builtin_enabled: (rt, args, { requestDesktop }) => {
     const name = requireEnum(args.name, SETUP_BUILTIN_TOGGLE_FEATURES, 'name');
     if (DESKTOP_HOSTED_FEATURES.includes(name)) return requestDesktop(args);
@@ -647,7 +664,7 @@ const SETUP_ACTION_HANDLERS = {
     const entry = connectorById(requireText(args.connector, 'connector'));
     if (!entry || entry.ownKey) 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 = entry.backend.kind === 'builtin' ? null : server?.connected === true;
+    const connected = server?.connected === true;
     return {
       connector: entry.id,
       name: entry.name,

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

@@ -1,7 +1,9 @@
 import { SETUP_EXTENDED_PROPERTIES, SETUP_DESKTOP_ACTIONS } from './settings-contract.mjs';
 import { MEDIA_KINDS } from '../../runtime/media/tool-defs.mjs';
 import { OPENAI_COMPAT_PRESETS } from '../../runtime/agent/orchestrator/providers/openai-compat-presets.mjs';
-import { agentIdOfHomeSession } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
+import { MIXY_AGENT_ID, agentIdOfHomeSession } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
+import { AGENT_MODE, resolveSessionMode } from '../../runtime/agent/orchestrator/session/agent-mode.mjs';
+import { BOT_AGENT_KIND, WORKFLOW_AGENT_KIND } from '../../runtime/shared/agent-route-config.mjs';
 import { assertAutomationAccess, scheduleCallerScope } from '../services/schedule-access.mjs';
 
 const own = (value, key) => Object.hasOwn(value || {}, key);
@@ -164,13 +166,20 @@ async function readDefinition(rt, kind, name) {
   };
 }
 
-async function saveDefinition(rt, args) {
+// A created agent's explicit marker: the one given, else a bot when Mixy's
+// agent-mode chat creates it (Mixy creates bots), else a workflow agent.
+function createdAgentKind(input, caller) {
+  if (own(input, 'kind')) return input.kind;
+  const { mode, agentId } = resolveSessionMode({ session: caller });
+  return mode === AGENT_MODE && agentId === MIXY_AGENT_ID ? BOT_AGENT_KIND : WORKFLOW_AGENT_KIND;
+}
+
+async function saveDefinition(rt, args, context = {}) {
   const kind = args.definitionKind;
   const input = args.definition;
-  const allowed =
-    kind === 'skill'
-      ? ['originalName', 'name', 'description', 'body', 'whenToUse', 'toolDependencies']
-      : ['id', 'name', 'description', 'body'];
+  let allowed = ['id', 'name', 'description', 'body'];
+  if (kind === 'skill') allowed = ['originalName', 'name', 'description', 'body', 'whenToUse', 'toolDependencies'];
+  else if (kind === 'agent') allowed = [...allowed, 'kind'];
   const unexpected = Object.keys(input).find((key) => !allowed.includes(key));
   if (unexpected) throw new Error(`${unexpected} is not a ${kind} definition field`);
   const creating = args.action === 'create_definition';
@@ -200,7 +209,10 @@ async function saveDefinition(rt, args) {
       const agents = await rt.listAgents();
       if (agents.some((agent) => agent.id === input.id)) throw new Error(`agent "${input.id}" already exists`);
     }
-    return rt.saveAgentDefinition(creating ? next : { ...next, id: current.id });
+    if (creating) return rt.saveAgentDefinition({ ...next, kind: createdAgentKind(input, context.caller) });
+    // The stored kind is kept as it is; an edit naming one is refused by the editor.
+    const { kind: _storedKind, ...edit } = { ...pick(current, definitionKeys), ...input };
+    return rt.saveAgentDefinition({ ...edit, ...(own(input, 'kind') ? { kind: input.kind } : {}), id: current.id });
   }
   return creating ? rt.addSkill(next) : rt.saveSkill({ ...next, originalName: current.originalName });
 }

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

@@ -157,7 +157,17 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
     name: text,
     description: text,
     body: text,
-    whenToUse: text,
+    kind: {
+      type: 'string',
+      enum: ['bot', 'agent'],
+      description:
+        'Agent create only: "bot" (a contact the user chats with) or "agent" (a workflow sub-agent). Omitted: a bot when created from the representative bot\'s chat, else a workflow agent. Fixed after creation.',
+    },
+    whenToUse: {
+      ...text,
+      description:
+        'Skill only: the SKILL.md when_to_use trigger line shown in the model\'s skill listing; "" clears it.',
+    },
     toolDependencies: {
       type: ['array', 'null'],
       items: object({ type: { type: 'string', enum: ['tool', 'mcp'] }, value: text }, ['type', 'value']),
@@ -232,6 +242,32 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
     markdownDefaultView: { type: 'string', enum: ['preview', 'rich', 'source'] },
     linkPreview: boolean,
     toolActivityExpansion: { type: 'string', enum: ['collapsed', 'commands', 'all'] },
+    uiFont: { ...text, description: 'Installed font family for the UI; "" restores the built-in font.' },
+    codeFont: { ...text, description: 'Installed font family for code; "" restores the built-in font.' },
+    skinTransparency: {
+      type: 'integer',
+      minimum: 0,
+      maximum: 100,
+      description: 'Sets both skin transparency sliders at once, 0-100 (defaults: outer 20, main 40).',
+    },
+    skinOuterTransparency: {
+      type: 'integer',
+      minimum: 0,
+      maximum: 100,
+      description:
+        'How much of the skin picture shows through the outer panels (window frame, titlebar, rail, sidebar, side dock), 0-100 (default 20).',
+    },
+    skinMainTransparency: {
+      type: 'integer',
+      minimum: 0,
+      maximum: 100,
+      description:
+        'How much of the skin picture shows through the main panel (conversation area, composer card, status island), 0-100 (default 40).',
+    },
+    colorTheme: {
+      ...text,
+      description: 'Imported JSON color theme id from status appearance colorThemes; "builtin" turns themes off.',
+    },
   }),
   hookRule: object(
     {

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

@@ -6,6 +6,7 @@ import {
 } from './settings-contract.mjs';
 import { MEDIA_KINDS } from '../../runtime/media/tool-defs.mjs';
 import { INSTRUCTION_FILES_MODES } from '../../runtime/shared/instruction-files-mode.mjs';
+import { AUTO_EFFORT_BASES } from '../../runtime/agent/orchestrator/providers/auto-effort.mjs';
 import { WORKTREE_NEW_TASK_DEFAULTS } from '../../runtime/shared/worktrees/settings.mjs';
 import { CONNECTOR_IDS } from '../../runtime/shared/connector-catalog.mjs';
 
@@ -83,6 +84,7 @@ export const SETUP_ACTION_FIELDS = Object.freeze({
   set_recap_enabled: 'enabled',
   set_web_search_enabled: 'enabled',
   set_instruction_files: 'instructionFiles',
+  set_auto_effort_base: 'autoEffortBase',
   set_builtin_enabled: 'name enabled',
   install_builtin: 'name',
   install_local_model: 'modelId',
@@ -160,7 +162,8 @@ const ROUTE_SCHEMA = {
 
 ROUTE_SCHEMA.properties.fallbacks = {
   type: 'array',
-  description: 'Agent and Web Search routes only: ordered fallback models; [] clears the list.',
+  description:
+    'Lead (set_route), agent (bots included) and Web Search routes only: ordered fallback models tried when the model hits its usage limit or is unavailable; [] clears the list.',
   items: {
     type: 'object',
     additionalProperties: false,
@@ -224,8 +227,16 @@ export const SETUP_TOOL_DEFS = Object.freeze([
           additionalProperties: false,
           properties: {
             enabled: { type: 'boolean' },
-            duration: { type: 'string', description: 'Idle window such as "45m" or "2h"; minimum 1m.' },
-            provider: { type: 'string', description: 'Scope the duration to one provider.' },
+            duration: {
+              type: 'string',
+              description:
+                'Idle window such as "45m" or "2h" (minimum 1m), or "unlimited"/"never" to stop idle clearing. Without provider, "unlimited" applies to the current route provider.',
+            },
+            provider: {
+              type: 'string',
+              description:
+                'Scope the duration to one provider; "default" is the fallback for providers without a built-in window.',
+            },
             reset: { type: 'boolean', description: 'Restore the global idle duration default.' },
             resetProvider: { type: 'boolean', description: 'Restore the given provider idle duration default.' },
             minContextPercent: { type: 'number', minimum: 0, maximum: 100 },
@@ -251,6 +262,12 @@ export const SETUP_TOOL_DEFS = Object.freeze([
           description:
             "set_instruction_files: which user instruction files new sessions load (global ~/.codex/AGENTS.md, ~/.claude/CLAUDE.md, then the Project root's AGENTS.md/CLAUDE.md).",
         },
+        autoEffortBase: {
+          type: 'string',
+          enum: [...AUTO_EFFORT_BASES],
+          description:
+            "set_auto_effort_base: the reasoning effort Auto works around (global; default medium). Auto moves one step down to two steps up from it, within the model's supported efforts.",
+        },
         name: {
           type: 'string',
           description: `set_builtin_enabled: ${SETUP_BUILTIN_TOGGLE_FEATURES.join('|')}; install_builtin also accepts memory. Memory toggles use set_memory_enabled. revoke_linked_device: client id from status connection, not its display name; set_developer_option: option id from status developer; read_definition/delete_definition: the definition id; reconnect_mcp: optional MCP server name (omit for all); else MCP/plugin/provider id.`,

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

@@ -1,8 +1,9 @@
 // Skill surface (status listing, resource load, tool envelope, global skill
 // creation/editing). The runtime facade only wires the mutable cwd and the
 // context module into it.
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { holdsNoData, writeFileAtomicSync } from '../runtime/shared/atomic-file.mjs';
 import { resolvePluginData } from '../runtime/shared/plugin-paths.mjs';
 import {
   createSkillDocument,
@@ -21,6 +22,10 @@ import { loadSkillToolDependencies } from '../runtime/agent/orchestrator/runtime
 
 const DEFAULT_SKILL_BODY = '# Instructions\n\nDescribe how to use this skill.';
 
+// SKILL.md is user-authored: written atomically (a crash never leaves it torn
+// or NUL-filled), the replaced copy kept as SKILL.md.bak.
+const writeSkillFile = (filePath, text) => writeFileAtomicSync(filePath, text, { backup: true, mode: 0o644 });
+
 export function createSkillsApi({ contextMod, getCwd, getTools = () => [] }) {
   const globalSkillsRoot = () => resolve(resolvePluginData(), 'skills');
 
@@ -114,9 +119,11 @@ export function createSkillsApi({ contextMod, getCwd, getTools = () => [] }) {
         : normalizeSkillToolDependencies(input.toolDependencies, { strict: true });
     const dir = join(globalSkillsRoot(), name);
     const filePath = join(dir, 'SKILL.md');
-    if (existsSync(filePath)) throw new Error(`skill already exists: ${name}`);
+    // A SKILL.md holding no data (empty, NUL-filled by a crash) is no skill:
+    // creating over it is allowed.
+    if (existsSync(filePath) && !holdsNoData(readFileSync(filePath))) throw new Error(`skill already exists: ${name}`);
     mkdirSync(dir, { recursive: true });
-    writeFileSync(filePath, createSkillDocument({ name, description, whenToUse, body }), 'utf8');
+    writeSkillFile(filePath, createSkillDocument({ name, description, whenToUse, body }));
     if (dependencies !== undefined) saveSkillToolDependencies(filePath, dependencies);
     invalidateSkills();
     return { name, filePath };
@@ -177,13 +184,13 @@ export function createSkillsApi({ contextMod, getCwd, getTools = () => [] }) {
       renameSync(currentDir, nextDir);
       filePath = join(nextDir, 'SKILL.md');
       try {
-        writeFileSync(filePath, updated, 'utf8');
+        writeSkillFile(filePath, updated);
       } catch (error) {
         renameSync(nextDir, currentDir);
         throw error;
       }
     } else {
-      writeFileSync(filePath, updated, 'utf8');
+      writeSkillFile(filePath, updated);
     }
     if (dependencies !== undefined) saveSkillToolDependencies(filePath, dependencies);
     else if (filePath !== resource.filePath && resource.dependencySource === 'override') {