amalgm 0.1.79 → 0.1.80

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.79",
+  "version": "0.1.80",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

package/runtime/lib/chatInput.js

@@ -58,7 +58,6 @@ const ChatInputSchema = z.object({
   }).default({}),
   tools: z.object({
     mcpAppIds: z.array(z.string()).default([]),
-    mode: z.enum(['all', 'selected']).default('all'),
     toolIds: z.array(z.string()).default([]),
   }).default({}),
   execution: z.object({
@@ -224,12 +223,9 @@ function normalizeChatInput(chatInput, legacy = {}) {
     },
     tools: {
       mcpAppIds: uniqueStrings(rawTools.mcpAppIds || legacy.mcpAppIds),
-      mode: rawTools.mode === 'selected' || legacy.toolMode === 'selected' ? 'selected' : 'all',
       toolIds: uniqueStrings(
         rawTools.toolIds
-        || rawTools.selectedToolIds
         || legacy.toolIds
-        || legacy.selectedToolIds,
       ),
     },
     execution: {

package/runtime/scripts/amalgm-mcp/agent-config/compiler/instructions.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const { normalizeAgentConfig } = require('../schema');
+
+function sourcePath(source) {
+  if (!source || typeof source !== 'object' || Array.isArray(source)) return '';
+  return typeof source.path === 'string' ? source.path.trim() : '';
+}
+
+function markdownListItem(title, details = []) {
+  const cleanTitle = String(title || '').trim();
+  if (!cleanTitle) return '';
+  const lines = [`- ${cleanTitle}`];
+  for (const detail of details.map((value) => String(value || '').trim()).filter(Boolean)) {
+    lines.push(`  ${detail}`);
+  }
+  return lines.join('\n');
+}
+
+function compileSkillsSection(skills) {
+  const enabled = (Array.isArray(skills) ? skills : []).filter((skill) => skill.enabled !== false);
+  if (enabled.length === 0) return '';
+
+  const lines = ['## Skills you should use'];
+  for (const skill of enabled) {
+    const title = skill.description
+      ? `${skill.name || skill.id}: ${skill.description}`
+      : `${skill.name || skill.id}`;
+    const path = sourcePath(skill.source);
+    const details = [
+      path ? `Path: ${path}` : '',
+      skill.content && path ? 'Read the skill file when the task matches this skill.' : '',
+      skill.content && !path ? skill.content.trim() : '',
+    ];
+    lines.push(markdownListItem(title, details));
+  }
+  return lines.join('\n');
+}
+
+function compileSubagentsSection(subagents) {
+  const enabled = (Array.isArray(subagents) ? subagents : []).filter((subagent) => subagent.enabled !== false);
+  if (enabled.length === 0) return '';
+
+  const lines = ['## Agents you should use'];
+  for (const subagent of enabled) {
+    const name = subagent.name || subagent.agentId;
+    const title = subagent.description
+      ? `${name}: ${subagent.description}`
+      : name;
+    lines.push(markdownListItem(title, [`Agent id: ${subagent.agentId}`]));
+  }
+  return lines.join('\n');
+}
+
+function compileAgentInstructions(config, options = {}) {
+  const normalized = normalizeAgentConfig(config);
+  const chunks = [
+    normalized.instructions,
+    compileSkillsSection(normalized.skills),
+    compileSubagentsSection(normalized.subagents),
+    options.extraMarkdown,
+  ];
+  return chunks.map((chunk) => String(chunk || '').trim()).filter(Boolean).join('\n\n');
+}
+
+module.exports = {
+  compileAgentInstructions,
+  compileSkillsSection,
+  compileSubagentsSection,
+};

package/runtime/scripts/amalgm-mcp/agent-config/loadout.js

@@ -0,0 +1,65 @@
+'use strict';
+
+function isObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function uniqueStrings(values) {
+  if (!Array.isArray(values)) return [];
+  return [...new Set(values
+    .filter((value) => typeof value === 'string')
+    .map((value) => value.trim())
+    .filter(Boolean))];
+}
+
+function rawToolIds(value) {
+  const raw = isObject(value) ? value : {};
+  return uniqueStrings(
+    raw.toolIds
+    || raw.selectedToolIds
+    || raw.selected
+    || raw.tools
+    || [],
+  );
+}
+
+function hasExplicitToolIds(value) {
+  if (!isObject(value)) return false;
+  return Object.prototype.hasOwnProperty.call(value, 'toolIds')
+    || Object.prototype.hasOwnProperty.call(value, 'selectedToolIds')
+    || Object.prototype.hasOwnProperty.call(value, 'selected')
+    || Object.prototype.hasOwnProperty.call(value, 'tools');
+}
+
+function normalizeLoadout(value, fallback = {}, options = {}) {
+  const raw = isObject(value) ? value : {};
+  const prior = isObject(fallback) ? fallback : {};
+  const explicit = rawToolIds(raw);
+  const previous = rawToolIds(prior);
+  const defaultToolIds = uniqueStrings(options.defaultToolIds || []);
+
+  if (hasExplicitToolIds(raw)) return { toolIds: explicit };
+  if (explicit.length > 0) return { toolIds: explicit };
+  if (hasExplicitToolIds(prior)) return { toolIds: previous };
+  if (previous.length > 0) return { toolIds: previous };
+
+  const isLegacyAll =
+    (raw.mode && raw.mode !== 'selected')
+    || (prior.mode && prior.mode !== 'selected');
+  if (isLegacyAll && defaultToolIds.length > 0) return { toolIds: defaultToolIds };
+
+  return { toolIds: [] };
+}
+
+function loadoutToolIds(configOrLoadout) {
+  if (isObject(configOrLoadout?.loadout)) {
+    return normalizeLoadout(configOrLoadout.loadout).toolIds;
+  }
+  return normalizeLoadout(configOrLoadout).toolIds;
+}
+
+module.exports = {
+  loadoutToolIds,
+  normalizeLoadout,
+  uniqueStrings,
+};

package/runtime/scripts/amalgm-mcp/agent-config/renderers/instructions.js

@@ -1,54 +1,14 @@
 'use strict';
 
-const { normalizeAgentConfig } = require('../schema');
-
-const AGENT_TO_AGENT_PROMPT = [
-  'You are an Amalgm agent. Other first-class Amalgm agents may be available as peers.',
-  'When a task is better handled by a configured peer, use the Amalgm agent-to-agent tool instead of inventing a hidden subagent.',
-].join(' ');
-
-function renderSkills(skills) {
-  const enabled = (Array.isArray(skills) ? skills : []).filter((skill) => skill.enabled !== false);
-  if (enabled.length === 0) return '';
-  const lines = ['Skills available to this agent:'];
-  for (const skill of enabled) {
-    if (skill.content) {
-      lines.push(`- ${skill.name || skill.id}: ${skill.description || 'see skill content below'}`);
-      lines.push('');
-      lines.push(`<skill id="${skill.id}" name="${skill.name || skill.id}">`);
-      lines.push(skill.content.trim());
-      lines.push('</skill>');
-    } else {
-      lines.push(`- ${skill.name || skill.id}${skill.description ? `: ${skill.description}` : ''}`);
-    }
-  }
-  return `<agent-skills>\n${lines.join('\n')}\n</agent-skills>`;
-}
-
-function renderSubagents(subagents) {
-  const enabled = (Array.isArray(subagents) ? subagents : []).filter((subagent) => subagent.enabled !== false);
-  if (enabled.length === 0) return '';
-  const lines = [
-    'Peer agents available through the Amalgm agent-to-agent tool:',
-    ...enabled.map((subagent) => (
-      `- ${subagent.name || subagent.agentId} (${subagent.agentId})${subagent.description ? `: ${subagent.description}` : ''}`
-    )),
-  ];
-  return `<agent-peers>\n${lines.join('\n')}\n</agent-peers>`;
-}
-
-function renderAgentInstructions(config, options = {}) {
-  const normalized = normalizeAgentConfig(config);
-  const chunks = [
-    normalized.instructions,
-    options.includeAgentToAgentPrompt === false ? '' : AGENT_TO_AGENT_PROMPT,
-    renderSkills(normalized.skills),
-    renderSubagents(normalized.subagents),
-  ];
-  return chunks.map((chunk) => String(chunk || '').trim()).filter(Boolean).join('\n\n');
-}
+const {
+  compileAgentInstructions,
+  compileSkillsSection,
+  compileSubagentsSection,
+} = require('../compiler/instructions');
 
 module.exports = {
-  AGENT_TO_AGENT_PROMPT,
-  renderAgentInstructions,
+  compileAgentInstructions,
+  compileSkillsSection,
+  compileSubagentsSection,
+  renderAgentInstructions: compileAgentInstructions,
 };

package/runtime/scripts/amalgm-mcp/agent-config/rest.js

@@ -8,8 +8,8 @@ const {
 } = require('../agents/store');
 const { importNativeConfigForHarness } = require('./importers');
 const {
+  agentFieldsFromConfig,
   getAgentConfig,
-  legacyFieldsFromConfig,
   upsertAgentConfig,
 } = require('./store');
 const {
@@ -59,7 +59,7 @@ function ensureImportedAgent(parentAgent, nativeAgent) {
   if (existing) {
     const config = upsertAgentConfig(existing.id, {
       instructions: nativeAgent.instructions || existing.systemPrompt || '',
-      tools: existing.tools || { mode: 'all', selectedToolIds: [] },
+      loadout: existing.loadout || existing.tools || { toolIds: [] },
       skills: existing.skills || [],
     }, { source: 'agent-config:import-native-subagent' });
     return { agent: { ...existing, config }, created: false };
@@ -73,24 +73,24 @@ function ensureImportedAgent(parentAgent, nativeAgent) {
     modelSettings: parentAgent.modelSettings,
     systemPrompt: nativeAgent.instructions || '',
     skills: [],
-    tools: { mode: 'all', selectedToolIds: [] },
+    loadout: { toolIds: [] },
     authMethod: parentAgent.authMethod,
   }, { source: 'agent-config:import-native-subagent' });
   const config = upsertAgentConfig(agent.id, {
     runtimeHomeLayout: 'per-agent',
     instructions: nativeAgent.instructions || '',
     skills: [],
-    tools: { mode: 'all', selectedToolIds: [] },
+    loadout: { toolIds: [] },
   }, { source: 'agent-config:import-native-subagent' });
   return { agent: { ...agent, config }, created: true };
 }
 
-function syncLegacyAgentFields(agentId, config) {
-  const legacy = legacyFieldsFromConfig(config);
+function syncAgentFields(agentId, config) {
+  const fields = agentFieldsFromConfig(config);
   try {
-    updateAgent(agentId, legacy, { source: 'agent-config:sync-legacy-fields' });
+    updateAgent(agentId, fields, { source: 'agent-config:sync-agent-fields' });
   } catch {
-    // Config is the source of truth; legacy sync is best-effort for older UI paths.
+    // Config is the source of truth; row projection is best-effort for list views.
   }
 }
 
@@ -110,7 +110,7 @@ async function handleUpdate(body, sendJson) {
   let saved;
   try {
     saved = upsertAgentConfig(agent_id, config || {}, { source: 'agent-config:update-rest' });
-    syncLegacyAgentFields(agent_id, saved);
+    syncAgentFields(agent_id, saved);
   } catch (error) {
     return sendJson(400, { error: error.message || 'Failed to update agent config' });
   }
@@ -148,7 +148,7 @@ async function handleImportNative(body, sendJson) {
   const existing = getAgentConfig(agent);
   const merged = mergeImportedConfig(existing, imported.config || {}, subagentRefs, replace === true);
   const saved = upsertAgentConfig(agent.id, merged, { source: 'agent-config:import-native' });
-  syncLegacyAgentFields(agent.id, saved);
+  syncAgentFields(agent.id, saved);
 
   return sendJson(200, {
     ok: true,

package/runtime/scripts/amalgm-mcp/agent-config/schema.js

@@ -5,6 +5,10 @@ const crypto = require('crypto');
 const CONFIG_VERSION = 1;
 const DEFAULT_RUNTIME_HOME_LAYOUT = 'legacy';
 const PER_AGENT_RUNTIME_HOME_LAYOUT = 'per-agent';
+const {
+  normalizeLoadout,
+  uniqueStrings,
+} = require('./loadout');
 
 function isObject(value) {
   return !!value && typeof value === 'object' && !Array.isArray(value);
@@ -14,14 +18,6 @@ function nonEmptyString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : '';
 }
 
-function uniqueStrings(values) {
-  if (!Array.isArray(values)) return [];
-  return [...new Set(values
-    .filter((value) => typeof value === 'string')
-    .map((value) => value.trim())
-    .filter(Boolean))];
-}
-
 function stableId(prefix, seed) {
   const clean = nonEmptyString(seed)
     .toLowerCase()
@@ -41,22 +37,6 @@ function cloneJson(value) {
   }
 }
 
-function normalizeTools(value, fallback = {}) {
-  const raw = isObject(value) ? value : {};
-  const prior = isObject(fallback) ? fallback : {};
-  const selectedToolIds = uniqueStrings(
-    raw.selectedToolIds
-    || raw.toolIds
-    || raw.selected
-    || prior.selectedToolIds
-    || [],
-  );
-  return {
-    mode: raw.mode === 'selected' || prior.mode === 'selected' ? 'selected' : 'all',
-    selectedToolIds,
-  };
-}
-
 function normalizeSkill(value, index = 0) {
   if (typeof value === 'string') {
     const name = nonEmptyString(value);
@@ -184,10 +164,12 @@ function normalizeRuntimeHomeLayout(value, fallback = DEFAULT_RUNTIME_HOME_LAYOU
     : DEFAULT_RUNTIME_HOME_LAYOUT;
 }
 
-function normalizeAgentConfig(input = {}, fallback = {}) {
+function normalizeAgentConfig(input = {}, fallback = {}, options = {}) {
   const raw = isObject(input) ? input : {};
   const prior = isObject(fallback) ? fallback : {};
   const agentId = nonEmptyString(raw.agentId || raw.agent_id || prior.agentId);
+  const rawLoadout = raw.loadout ?? raw.toolset ?? raw.tools;
+  const priorLoadout = prior.loadout ?? prior.toolset ?? prior.tools;
   return {
     version: CONFIG_VERSION,
     ...(agentId ? { agentId } : {}),
@@ -200,7 +182,9 @@ function normalizeAgentConfig(input = {}, fallback = {}) {
       typeof prior.instructions === 'string' ? prior.instructions : '',
     ),
     skills: normalizeSkills(raw.skills ?? prior.skills ?? []),
-    tools: normalizeTools(raw.tools, prior.tools),
+    loadout: normalizeLoadout(rawLoadout, priorLoadout, {
+      defaultToolIds: options.defaultLoadoutToolIds,
+    }),
     hooks: normalizeHooks(raw.hooks ?? prior.hooks ?? []),
     subagents: normalizeSubagents(raw.subagents ?? prior.subagents ?? []),
   };
@@ -211,13 +195,13 @@ function configFromAgent(agent = {}) {
     agentId: agent.id,
     instructions: agent.systemPrompt || '',
     skills: agent.skills || [],
-    tools: agent.tools || { mode: 'all', selectedToolIds: [] },
+    loadout: agent.loadout || agent.toolset || agent.tools || { toolIds: [] },
     hooks: agent.hooks || [],
     subagents: agent.subagents || [],
   });
 }
 
-function legacyFieldsFromConfig(config = {}) {
+function agentFieldsFromConfig(config = {}) {
   const normalized = normalizeAgentConfig(config);
   return {
     systemPrompt: normalized.instructions,
@@ -225,7 +209,7 @@ function legacyFieldsFromConfig(config = {}) {
       .filter((skill) => skill.enabled !== false)
       .map((skill) => skill.content || skill.name)
       .filter(Boolean),
-    tools: normalized.tools,
+    loadout: normalized.loadout,
     hooks: normalized.hooks,
     subagents: normalized.subagents,
   };
@@ -235,14 +219,14 @@ module.exports = {
   CONFIG_VERSION,
   DEFAULT_RUNTIME_HOME_LAYOUT,
   PER_AGENT_RUNTIME_HOME_LAYOUT,
+  agentFieldsFromConfig,
   configFromAgent,
-  legacyFieldsFromConfig,
   normalizeAgentConfig,
   normalizeHooks,
+  normalizeLoadout,
   normalizeRuntimeHomeLayout,
   normalizeSkills,
   normalizeSubagents,
-  normalizeTools,
   stableId,
   uniqueStrings,
 };

package/runtime/scripts/amalgm-mcp/agent-config/store.js

@@ -3,8 +3,8 @@
 const { openLocalDb } = require('../state/db');
 const { insertStateEvent, publishStateEvent } = require('../state/events');
 const {
+  agentFieldsFromConfig,
   configFromAgent,
-  legacyFieldsFromConfig,
   normalizeAgentConfig,
 } = require('./schema');
 
@@ -16,10 +16,24 @@ function readRow(db, agentId) {
   return db.prepare('SELECT * FROM agent_configs WHERE agent_id = ?').get(agentId);
 }
 
+function defaultLoadoutToolIds() {
+  try {
+    const { defaultToolboxService } = require('../toolbox/service');
+    return Object.values(defaultToolboxService.readCatalog().tools || {})
+      .filter((tool) => tool?.status === 'enabled')
+      .map((tool) => tool.id)
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
 function rowToConfig(row) {
   if (!row) return null;
   try {
-    return normalizeAgentConfig(JSON.parse(row.config_json || '{}'));
+    return normalizeAgentConfig(JSON.parse(row.config_json || '{}'), {}, {
+      defaultLoadoutToolIds: defaultLoadoutToolIds(),
+    });
   } catch {
     return null;
   }
@@ -49,7 +63,9 @@ function upsertAgentConfig(agentId, configPatch, options = {}) {
     ...existing,
     ...(configPatch || {}),
     agentId,
-  }, existing);
+  }, existing, {
+    defaultLoadoutToolIds: defaultLoadoutToolIds(),
+  });
   const updatedAt = nowIso();
   const event = db.transaction(() => {
     db.prepare(`
@@ -108,16 +124,16 @@ function agentWithConfig(agent) {
   const config = getAgentConfig(agent);
   return {
     ...agent,
-    ...legacyFieldsFromConfig(config),
+    ...agentFieldsFromConfig(config),
     config,
   };
 }
 
 module.exports = {
   agentWithConfig,
+  agentFieldsFromConfig,
   deleteAgentConfig,
   getAgentConfig,
-  legacyFieldsFromConfig,
   listAgentConfigs,
   upsertAgentConfig,
 };

package/runtime/scripts/amalgm-mcp/agents/rest.js

@@ -12,14 +12,17 @@ const {
 const { hydrateModelPreferences } = require('../lib/prefs');
 const credentialAdapter = require('../../credential-adapter');
 const {
+  agentFieldsFromConfig,
   agentWithConfig,
   deleteAgentConfig,
-  legacyFieldsFromConfig,
   upsertAgentConfig,
 } = require('../agent-config/store');
 const {
   defaultToolboxService: toolboxService,
 } = require('../toolbox/service');
+const {
+  normalizeLoadout,
+} = require('../agent-config/loadout');
 
 function coerceAuthMethodForHarness(harnessId, authMethod) {
   const supported = credentialAdapter.SUPPORTED_AUTH_BY_HARNESS?.[harnessId] || ['amalgm'];
@@ -34,30 +37,25 @@ function normalizeStringList(values) {
     .filter(Boolean))];
 }
 
-function derivedMcpTransportConfig(toolConfig) {
-  const appIds = toolboxService.externalMcpToolIdsForMode(
-    toolConfig.mode,
-    toolConfig.selectedToolIds,
-  );
+function defaultLoadout() {
+  return { toolIds: toolboxService.libraryToolIds() };
+}
+
+function derivedMcpTransportConfig(loadout) {
+  const appIds = toolboxService.externalMcpToolIdsForLoadout(loadout.toolIds);
   return {
-    inheritAll: toolConfig.mode !== 'selected',
+    inheritAll: false,
     customServers: [],
     appIds,
-    nativeMcps: [],
   };
 }
 
-function normalizeToolConfig(tools) {
-  const raw = tools && typeof tools === 'object' && !Array.isArray(tools) ? tools : null;
-  const selectedToolIds = normalizeStringList(
-    raw?.selectedToolIds
-    ?? raw?.selected
-    ?? [],
+function normalizeRequestLoadout(input, fallback = null) {
+  return normalizeLoadout(
+    input?.loadout ?? input?.toolset ?? input?.tools,
+    fallback?.loadout ?? fallback?.tools,
+    { defaultToolIds: toolboxService.libraryToolIds() },
   );
-  return {
-    mode: raw?.mode === 'selected' ? 'selected' : 'all',
-    selectedToolIds,
-  };
 }
 
 async function handleList(sendJson) {
@@ -82,15 +80,15 @@ async function handleCreate(body, sendJson) {
     systemPrompt,
     files,
     skills,
-    tools,
+    loadout,
     authMethod,
     config,
   } = body;
   if (!name || !name.trim()) return sendJson(400, { error: 'name is required' });
   if (!baseHarnessId) return sendJson(400, { error: 'baseHarnessId is required' });
 
-  const toolConfig = normalizeToolConfig(tools);
-  const mcpConfig = derivedMcpTransportConfig(toolConfig);
+  const agentLoadout = normalizeRequestLoadout({ loadout }, { loadout: defaultLoadout() });
+  const mcpConfig = derivedMcpTransportConfig(agentLoadout);
   let agent;
   try {
     const configPatch = config && typeof config === 'object' && !Array.isArray(config)
@@ -98,7 +96,7 @@ async function handleCreate(body, sendJson) {
       : {
           instructions: systemPrompt || '',
           skills: normalizeStringList(skills),
-          tools: toolConfig,
+          loadout: agentLoadout,
         };
     agent = createAgent({
       name: name.trim(),
@@ -110,8 +108,7 @@ async function handleCreate(body, sendJson) {
       files: normalizeStringList(files),
       skills: normalizeStringList(skills),
       mcpAppIds: mcpConfig.appIds,
-      nativeMcps: mcpConfig.nativeMcps,
-      tools: toolConfig,
+      loadout: agentLoadout,
       mcp: mcpConfig,
       authMethod: coerceAuthMethodForHarness(baseHarnessId, authMethod),
     });
@@ -121,7 +118,7 @@ async function handleCreate(body, sendJson) {
     }, { source: 'agents:create' });
     agent = {
       ...agent,
-      ...legacyFieldsFromConfig(savedConfig),
+      ...agentFieldsFromConfig(savedConfig),
       config: savedConfig,
     };
   } catch (error) {
@@ -144,11 +141,10 @@ async function handleUpdate(body, sendJson) {
     updates.authMethod = coerceAuthMethodForHarness(targetHarnessId, existing.authMethod);
   }
 
-  const toolConfig = normalizeToolConfig(updates.tools ?? existing.tools);
-  const mcpConfig = derivedMcpTransportConfig(toolConfig);
-  updates.tools = toolConfig;
+  const agentLoadout = normalizeRequestLoadout(updates, existing);
+  const mcpConfig = derivedMcpTransportConfig(agentLoadout);
+  updates.loadout = agentLoadout;
   updates.mcpAppIds = mcpConfig.appIds;
-  updates.nativeMcps = mcpConfig.nativeMcps;
   updates.mcp = mcpConfig;
 
   let agent;
@@ -158,19 +154,23 @@ async function handleUpdate(body, sendJson) {
       : {
           instructions: updates.systemPrompt ?? existing.systemPrompt ?? '',
           skills: normalizeStringList(updates.skills ?? existing.skills),
-          tools: toolConfig,
+          loadout: agentLoadout,
           hooks: Array.isArray(updates.hooks) ? updates.hooks : existing.config?.hooks,
           subagents: Array.isArray(updates.subagents) ? updates.subagents : existing.config?.subagents,
         };
     delete updates.config;
     const savedConfig = upsertAgentConfig(agent_id, configPatch, { source: 'agents:update' });
-    updates.systemPrompt = legacyFieldsFromConfig(savedConfig).systemPrompt;
-    updates.skills = legacyFieldsFromConfig(savedConfig).skills;
-    updates.tools = savedConfig.tools;
+    const agentFields = agentFieldsFromConfig(savedConfig);
+    const savedMcpConfig = derivedMcpTransportConfig(savedConfig.loadout);
+    updates.systemPrompt = agentFields.systemPrompt;
+    updates.skills = agentFields.skills;
+    updates.loadout = savedConfig.loadout;
+    updates.mcpAppIds = savedMcpConfig.appIds;
+    updates.mcp = savedMcpConfig;
     agent = updateAgent(agent_id, updates);
     agent = {
       ...agent,
-      ...legacyFieldsFromConfig(savedConfig),
+      ...agentFields,
       config: savedConfig,
     };
   } catch (error) {