amalgm 0.1.75 → 0.1.76

package/runtime/scripts/amalgm-mcp/lib/chat-payloads.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const { openLocalDb } = require('../state/db');
+const { insertStateEvent, publishStateEvent } = require('../state/events');
+
+const CHAT_PAYLOADS_META_KEY = 'chat_payloads';
+const CHAT_PAYLOADS_RESOURCE = 'chat_payloads';
+
+function isPlainObject(value) {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function cleanString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function parseStoredPayloads(value) {
+  if (typeof value !== 'string' || !value) return {};
+  try {
+    const parsed = JSON.parse(value);
+    return isPlainObject(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function readPayloadMap() {
+  const row = openLocalDb()
+    .prepare('SELECT value FROM local_meta WHERE key = ?')
+    .get(CHAT_PAYLOADS_META_KEY);
+  return parseStoredPayloads(row?.value);
+}
+
+function normalizeRecord(input, existing = null) {
+  const body = isPlainObject(input) ? input : {};
+  const id = cleanString(body.id || body.payloadId || existing?.id);
+  if (!id) throw new Error('chat payload id is required');
+
+  const payload = isPlainObject(body.payload)
+    ? body.payload
+    : isPlainObject(existing?.payload)
+      ? existing.payload
+      : null;
+  if (!payload) throw new Error('chat payload is required');
+
+  return {
+    id,
+    revision: cleanString(body.revision || body.payloadRevision || existing?.revision) || 'unknown',
+    payload,
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+function listChatPayloads() {
+  return readPayloadMap();
+}
+
+function getChatPayload(id) {
+  const payloadId = cleanString(id);
+  if (!payloadId) return null;
+  return readPayloadMap()[payloadId] || null;
+}
+
+function writeChatPayload(input, options = {}) {
+  const db = openLocalDb();
+  let record;
+  const event = db.transaction(() => {
+    const current = readPayloadMap();
+    record = normalizeRecord(input, current[cleanString(input?.id || input?.payloadId)] || null);
+    const next = {
+      ...current,
+      [record.id]: record,
+    };
+
+    db.prepare(`
+      INSERT INTO local_meta (key, value, updated_at)
+      VALUES (?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+      ON CONFLICT(key) DO UPDATE SET
+        value = excluded.value,
+        updated_at = excluded.updated_at
+    `).run(CHAT_PAYLOADS_META_KEY, JSON.stringify(next));
+
+    return insertStateEvent(db, {
+      resource: CHAT_PAYLOADS_RESOURCE,
+      op: 'update',
+      id: record.id,
+      value: record,
+      source: options.source || 'chat-payloads',
+    });
+  })();
+
+  publishStateEvent(event);
+  return record;
+}
+
+module.exports = {
+  CHAT_PAYLOADS_RESOURCE,
+  getChatPayload,
+  listChatPayloads,
+  writeChatPayload,
+};

package/runtime/scripts/amalgm-mcp/server/core-tools.js

@@ -28,32 +28,32 @@ function group(id, name, description, tools) {
 
 const CORE_TOOL_GROUPS = [
   group(
-    'amalgm.automations',
-    'Amalgm Automations',
+    'automations',
+    'Automations',
     'Create, inspect, and run scheduled or event-driven automations.',
     require('../automations/tools'),
   ),
   group(
-    'amalgm.notifications',
-    'Amalgm Notifications',
+    'notifications',
+    'Notifications',
     'Notify the user about important results, completions, and failures.',
     require('../notify'),
   ),
   group(
-    'amalgm.agents',
-    'Amalgm Agents',
+    'agents',
+    'Agents',
     'Discover and talk to other agents on the platform.',
     require('../agents/tools'),
   ),
   group(
-    'amalgm.apps',
-    'Amalgm Apps',
+    'apps',
+    'Apps',
     'Register, run, and route local-first Amalgm apps.',
     require('../apps/tools'),
   ),
   group(
-    'amalgm.browser',
-    'Amalgm Browser',
+    'browser',
+    'Browser',
     "Use Amalgm's visible browser session for navigation, interaction, and screenshots.",
     require('../browser/tools'),
   ),

package/runtime/scripts/amalgm-mcp/server/local-service-router.js

@@ -12,6 +12,7 @@ const { handleHealthRoutes } = require('./routes/health');
 const { handleStateRoutes } = require('./routes/state');
 const { handleBrowserRoutes } = require('./routes/browser');
 const { handlePreferenceRoutes } = require('./routes/preferences');
+const { handleChatPayloadRoutes } = require('./routes/chat-payloads');
 const { handleAgentRoutes } = require('./routes/agents');
 const { handleEventRoutes } = require('./routes/events');
 const { handleAutomationRoutes } = require('./routes/automations');
@@ -28,6 +29,7 @@ const DEFAULT_ROUTE_GROUPS = [
   handleStateRoutes,
   handleBrowserRoutes,
   handlePreferenceRoutes,
+  handleChatPayloadRoutes,
   handleAgentRoutes,
   handleEventRoutes,
   handleAutomationRoutes,

package/runtime/scripts/amalgm-mcp/server/routes/agents.js

@@ -1,8 +1,21 @@
 'use strict';
 
 const agentsRest = require('../../agents/rest');
+const agentConfigRest = require('../../agent-config/rest');
 
 async function handleAgentRoutes(ctx) {
+  if (ctx.pathname === '/agent-config/get' && ctx.method === 'POST') {
+    agentConfigRest.handleGet(await ctx.readJsonBody(), ctx.sendJson);
+    return true;
+  }
+  if (ctx.pathname === '/agent-config/update' && ctx.method === 'POST') {
+    agentConfigRest.handleUpdate(await ctx.readJsonBody(), ctx.sendJson);
+    return true;
+  }
+  if (ctx.pathname === '/agent-config/import-native' && ctx.method === 'POST') {
+    agentConfigRest.handleImportNative(await ctx.readJsonBody(), ctx.sendJson);
+    return true;
+  }
   if (ctx.pathname === '/agents/list' && ctx.method === 'GET') {
     agentsRest.handleList(ctx.sendJson);
     return true;

package/runtime/scripts/amalgm-mcp/server/routes/chat-payloads.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const chatPayloads = require('../../lib/chat-payloads');
+
+async function handleChatPayloadRoutes(ctx) {
+  if (ctx.pathname === '/chat-payloads' && ctx.method === 'GET') {
+    const query = ctx.getQuery();
+    const payload = query.id ? chatPayloads.getChatPayload(query.id) : null;
+    ctx.sendJson(payload ? 200 : (query.id ? 404 : 200), {
+      ...(query.id ? { payload } : {}),
+      payloads: chatPayloads.listChatPayloads(),
+      ...(query.id && !payload ? { error: 'Chat payload not found' } : {}),
+    });
+    return true;
+  }
+
+  if (ctx.pathname === '/chat-payloads/get' && ctx.method === 'POST') {
+    const body = await ctx.readJsonBody();
+    const payload = chatPayloads.getChatPayload(body?.id || body?.payloadId);
+    if (!payload) {
+      ctx.sendJson(404, { error: 'Chat payload not found' });
+      return true;
+    }
+    ctx.sendJson(200, { payload });
+    return true;
+  }
+
+  if (ctx.pathname === '/chat-payloads' && (ctx.method === 'PUT' || ctx.method === 'POST')) {
+    const payload = chatPayloads.writeChatPayload(await ctx.readJsonBody());
+    ctx.sendJson(200, { success: true, payload });
+    return true;
+  }
+
+  return false;
+}
+
+module.exports = { handleChatPayloadRoutes };

package/runtime/scripts/amalgm-mcp/state/db.js

@@ -296,6 +296,17 @@ function migrate(database = openLocalDb()) {
     CREATE INDEX IF NOT EXISTS agents_builtin_idx
       ON agents(builtin);
 
+    CREATE TABLE IF NOT EXISTS agent_configs (
+      agent_id TEXT PRIMARY KEY,
+      version INTEGER NOT NULL DEFAULT 1,
+      updated_at TEXT NOT NULL,
+      config_json TEXT NOT NULL,
+      FOREIGN KEY(agent_id) REFERENCES agents(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS agent_configs_updated_idx
+      ON agent_configs(updated_at DESC);
+
     CREATE TABLE IF NOT EXISTS workspaces (
       id TEXT PRIMARY KEY,
       name TEXT NOT NULL,

package/runtime/scripts/amalgm-mcp/state/snapshot.js

@@ -2,7 +2,7 @@
 
 const { currentSeq } = require('./events');
 
-const DEFAULT_RESOURCES = ['automations', 'triggers', 'workflows', 'automation_runs', 'workflow_cell_runs', 'agents', 'apps', 'toolbox', 'tools', 'tool_actions', 'hooks', 'projects', 'workspaces', 'memories', 'mcp_connections', 'browser_profiles', 'browser_auth_bundles', 'browser_login_sessions'];
+const DEFAULT_RESOURCES = ['automations', 'triggers', 'workflows', 'automation_runs', 'workflow_cell_runs', 'agents', 'agent_configs', 'apps', 'toolbox', 'tools', 'tool_actions', 'hooks', 'projects', 'workspaces', 'memories', 'user_preferences', 'chat_payloads', 'mcp_connections', 'browser_profiles', 'browser_auth_bundles', 'browser_login_sessions'];
 
 function normalizeResources(resources) {
   const values = resources ? String(resources).split(',') : DEFAULT_RESOURCES;
@@ -33,8 +33,14 @@ function readResource(resource, cache) {
     case 'workflows':
       cache.workflows ||= require('../automations/store').listWorkflows();
       return cache.workflows;
-    case 'agents':
-      return require('../agents/store').getAllAgentsWithBuiltins();
+    case 'agents': {
+      const { agentWithConfig } = require('../agent-config/store');
+      return require('../agents/store').getAllAgentsWithBuiltins()
+        .map((agent) => agentWithConfig(agent))
+        .filter(Boolean);
+    }
+    case 'agent_configs':
+      return require('../agent-config/store').listAgentConfigs();
     case 'apps':
       return require('../apps/store').loadApps().apps;
     case 'toolbox':
@@ -55,6 +61,10 @@ function readResource(resource, cache) {
     }
     case 'memories':
       return require('../../chat-core/tooling/active-memory').collectActiveMemoryFiles();
+    case 'user_preferences':
+      return require('../lib/prefs').readUserPreferences();
+    case 'chat_payloads':
+      return require('../lib/chat-payloads').listChatPayloads();
     case 'uploads':
       return require('../fs/rest')._private.buildUploadsResource();
     case 'mcp_connections':

package/runtime/scripts/amalgm-mcp/tests/agent-config.test.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const test = require('node:test');
+const { importCodexConfig } = require('../agent-config/importers/codex');
+const { normalizeAgentConfig } = require('../agent-config/schema');
+const { toCodexHooksJson } = require('../agent-config/renderers/hooks');
+
+function withNativeHome(fn) {
+  const previousNativeHome = process.env.AMALGM_NATIVE_HOME;
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-agent-config-'));
+  process.env.AMALGM_NATIVE_HOME = root;
+  try {
+    return fn(root);
+  } finally {
+    if (previousNativeHome === undefined) delete process.env.AMALGM_NATIVE_HOME;
+    else process.env.AMALGM_NATIVE_HOME = previousNativeHome;
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+test('codex native import ports command hooks without inheriting MCP or auth config', () => {
+  withNativeHome((home) => {
+    const codexHome = path.join(home, '.codex');
+    fs.mkdirSync(codexHome, { recursive: true });
+    fs.writeFileSync(path.join(codexHome, 'AGENTS.md'), 'Use project memory when it helps.\n');
+    fs.writeFileSync(path.join(codexHome, 'auth.json'), '{"auth_mode":"chatgpt","secret":"do-not-import"}');
+    fs.writeFileSync(path.join(codexHome, 'config.toml'), [
+      '[mcp_servers.supermemory]',
+      'url = "https://example.test/mcp"',
+      '',
+      '[mcp_servers.supermemory.http_headers]',
+      'Authorization = "Bearer do-not-import"',
+      '',
+    ].join('\n'));
+    fs.writeFileSync(path.join(codexHome, 'hooks.json'), JSON.stringify({
+      UserPromptSubmit: [{
+        hooks: [{
+          type: 'command',
+          command: 'node ~/.codex/supermemory/recall.js',
+          timeout: 90,
+          statusMessage: 'Searching memories...',
+        }],
+      }],
+      Stop: [{
+        hooks: [{
+          type: 'command',
+          command: 'node ~/.codex/supermemory/save.js',
+          timeout: 60,
+          statusMessage: 'Saving to memory...',
+        }],
+      }],
+    }, null, 2));
+
+    const imported = importCodexConfig();
+    const config = normalizeAgentConfig({ agentId: 'agent-memory', ...imported.config });
+
+    assert.equal(config.instructions, 'Use project memory when it helps.\n');
+    assert.equal(config.hooks.length, 2);
+    assert.deepEqual(config.hooks.map((hook) => hook.event), ['UserPromptSubmit', 'Stop']);
+    assert.equal(config.hooks[0].command, 'node ~/.codex/supermemory/recall.js');
+    assert.equal(config.hooks[0].timeout, 90);
+    assert.equal(config.hooks[0].statusMessage, 'Searching memories...');
+    assert.equal(config.hooks[0].source.provider, 'codex');
+    assert.equal(config.tools.mode, 'all');
+
+    const serialized = JSON.stringify(config);
+    assert.equal(serialized.includes('mcp_servers'), false);
+    assert.equal(serialized.includes('Authorization'), false);
+    assert.equal(serialized.includes('do-not-import'), false);
+
+    const hooksJson = toCodexHooksJson(config);
+    assert.match(hooksJson, /Searching memories/);
+    assert.match(hooksJson, /Saving to memory/);
+    assert.match(hooksJson, /node ~\/\.codex\/supermemory\/recall\.js/);
+  });
+});

package/runtime/scripts/amalgm-mcp/tests/automations-store-runner.test.js

@@ -158,18 +158,30 @@ test('workflow compiler accepts compact tool and agent helpers', () => {
   trigger: event("github.push"),
   cells: [
     code("greet", async () => ({ message: "hello" })),
-    tool("notify", "amalgm.notifications.notify_user", ({ cells }) => ({ message: cells.greet.output.message })),
+    tool("notify", "notifications.notify_user", ({ cells }) => ({ message: cells.greet.output.message })),
     agent("ask_codex", "Codex", { prompt: "Review this", run_in_background: true })
   ]
 })`);
 
-  assert.equal(ir.cells[1].toolId, 'amalgm.notifications');
+  assert.equal(ir.cells[1].toolId, 'notifications');
   assert.equal(ir.cells[1].actionName, 'notify_user');
-  assert.equal(ir.cells[2].toolId, 'amalgm.agents');
+  assert.equal(ir.cells[2].toolId, 'agents');
   assert.equal(ir.cells[2].actionName, 'talk_to_agent');
   assert.equal(ir.cells[2].args.agent, 'Codex');
 });
 
+test('workflow tool resolver accepts legacy first-party action refs', async () => {
+  const valid = await validateWorkflowText(`export default workflow({
+  trigger: event("test.legacy"),
+  cells: [
+    tool("notify", "amalgm.notify_user", { message: "hello" }),
+    tool("notify2", "amalgm.notifications.notify_user", { message: "hello again" })
+  ]
+})`);
+
+  assert.equal(valid.ok, true);
+});
+
 test('workflow compiler splits dotted toolbox action refs on the last dot', () => {
   const ir = compileWorkflowText(`export default workflow({
   trigger: event("test.dotted"),
@@ -187,7 +199,7 @@ test('automation validator catches dry-run cell reference failures without persi
   trigger: event("test.validate"),
   cells: [
     code("greet", async () => ({ message: "hello" })),
-    tool("notify", "amalgm.notifications.notify_user", ({ cells }) => ({ message: cells.greet.output.message }))
+    tool("notify", "notifications.notify_user", ({ cells }) => ({ message: cells.greet.output.message }))
   ]
 })`);
 
@@ -198,7 +210,7 @@ test('automation validator catches dry-run cell reference failures without persi
   trigger: event("test.validate"),
   cells: [
     code("greet", async () => ({ message: "hello" })),
-    tool("notify", "amalgm.notifications.notify_user", ({ cells }) => ({ message: cells.missing.output.message }))
+    tool("notify", "notifications.notify_user", ({ cells }) => ({ message: cells.missing.output.message }))
   ]
 })`);
 

package/runtime/scripts/amalgm-mcp/tests/chat-payloads.test.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-chat-payloads-test-'));
+process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
+
+const { closeLocalDb, openLocalDb } = require('../state/db');
+const {
+  getChatPayload,
+  listChatPayloads,
+  writeChatPayload,
+} = require('../lib/chat-payloads');
+const { buildSnapshot } = require('../state/snapshot');
+
+test.after(() => {
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+test('chat payloads persist in local SQLite and snapshot by id', () => {
+  const payload = {
+    machineId: 'machine-a',
+    harness: 'codex',
+    resolvedHarnessId: 'codex',
+    modelId: 'openai/gpt-5.5',
+    modelSettings: { effort: 'high', fastMode: true },
+    authMethod: 'amalgm',
+    cwd: '/tmp/project',
+    customAgentId: null,
+    systemPrompt: null,
+    mcpAppIds: ['github'],
+    tools: { mode: 'selected', selectedToolIds: ['tool.search'] },
+    pendingWorktree: false,
+  };
+
+  const record = writeChatPayload({
+    id: 'chat-view:test',
+    revision: 'rev-1',
+    payload,
+  });
+
+  assert.equal(record.id, 'chat-view:test');
+  assert.equal(record.revision, 'rev-1');
+  assert.deepEqual(getChatPayload('chat-view:test').payload, payload);
+  assert.deepEqual(listChatPayloads()['chat-view:test'].payload, payload);
+
+  const snapshot = buildSnapshot('chat_payloads,user_preferences');
+  assert.equal(snapshot.resources.chat_payloads['chat-view:test'].revision, 'rev-1');
+  assert.ok(snapshot.resources.user_preferences);
+
+  const rows = openLocalDb()
+    .prepare('SELECT resource, id FROM event_log WHERE resource = ?')
+    .all('chat_payloads');
+  assert.deepEqual(rows.map((row) => row.id), ['chat-view:test']);
+});
+
+test('chat payload revision updates can reuse the existing payload body', () => {
+  const updated = writeChatPayload({
+    id: 'chat-view:test',
+    revision: 'rev-2',
+  });
+
+  assert.equal(updated.revision, 'rev-2');
+  assert.equal(updated.payload.authMethod, 'amalgm');
+  assert.equal(getChatPayload('chat-view:test').revision, 'rev-2');
+});

package/runtime/scripts/amalgm-mcp/tests/core-tools.test.js

@@ -7,11 +7,11 @@ const { CORE_TOOL_GROUPS, CORE_TOOLS } = require('../server/core-tools');
 
 test('core tools are grouped into first-party toolbox-style defaults', () => {
   assert.deepEqual(CORE_TOOL_GROUPS.map((group) => group.id), [
-    'amalgm.automations',
-    'amalgm.notifications',
-    'amalgm.agents',
-    'amalgm.apps',
-    'amalgm.browser',
+    'automations',
+    'notifications',
+    'agents',
+    'apps',
+    'browser',
   ]);
   assert.equal(CORE_TOOL_GROUPS.every((group) => group.origin === 'system'), true);
   assert.equal(CORE_TOOL_GROUPS.every((group) => group.owner === 'amalgm'), true);
@@ -30,8 +30,8 @@ test('core tool actions carry stable toolbox ids', () => {
   const browserNavigate = CORE_TOOLS.find((tool) => tool.name === 'browser_navigate');
   const notifyUser = CORE_TOOLS.find((tool) => tool.name === 'notify_user');
 
-  assert.equal(browserNavigate.toolboxToolId, 'amalgm.browser');
-  assert.equal(browserNavigate.toolboxActionId, 'amalgm.browser.browser_navigate');
-  assert.equal(notifyUser.toolboxToolId, 'amalgm.notifications');
-  assert.equal(notifyUser.toolboxActionId, 'amalgm.notifications.notify_user');
+  assert.equal(browserNavigate.toolboxToolId, 'browser');
+  assert.equal(browserNavigate.toolboxActionId, 'browser.browser_navigate');
+  assert.equal(notifyUser.toolboxToolId, 'notifications');
+  assert.equal(notifyUser.toolboxActionId, 'notifications.notify_user');
 });

package/runtime/scripts/amalgm-mcp/tests/mcp-surface.test.js

@@ -149,6 +149,35 @@ test('MCP surface filters static tools in selected-tool mode', async () => {
   assert.equal(unselectedResult.content[0].text, 'Unknown tool: toolbox__amalgm_failures_static_fail');
 });
 
+test('MCP surface accepts legacy selected ids for first-party tools', async () => {
+  const surface = createToolboxMcpSurface({
+    staticTools: [{
+      name: 'browser_navigate',
+      description: 'Navigate.',
+      inputSchema: { type: 'object', properties: {} },
+      toolboxToolId: 'browser',
+      toolboxActionId: 'browser.browser_navigate',
+      async handler() {
+        return textResult('ok');
+      },
+    }],
+    async listDynamicTools() {
+      return [];
+    },
+  });
+
+  const listed = await surface.listTools({
+    sessionMetadata: {
+      tools: {
+        mode: 'selected',
+        selectedToolIds: ['amalgm.browser'],
+      },
+    },
+  });
+
+  assert.deepEqual(listed.map((tool) => tool.name), ['toolbox__browser_browser_navigate']);
+});
+
 test('MCP surface converts static handler errors into MCP errors', async () => {
   const surface = createToolboxMcpSurface({ staticTools: staticTools() });
   const result = await surface.callTool('toolbox__amalgm_failures_static_fail', {}, {});

package/runtime/scripts/amalgm-mcp/tests/system-catalog.test.js

@@ -12,20 +12,21 @@ const {
 test('system toolbox catalog exposes first-party default tools', () => {
   const catalog = buildSystemToolboxCatalog();
 
-  assert.equal(catalog.tools['amalgm.browser'].name, 'Amalgm Browser');
-  assert.equal(catalog.tools['amalgm.browser'].origin, 'system');
-  assert.equal(catalog.tools['amalgm.browser'].policy.firstParty, true);
+  assert.equal(catalog.tools.browser.name, 'Browser');
+  assert.equal(catalog.tools.browser.owner, 'amalgm');
+  assert.equal(catalog.tools.browser.origin, 'system');
+  assert.equal(catalog.tools.browser.policy.firstParty, true);
   assert.equal(
-    catalog.toolActions['amalgm.browser.browser_navigate'].sourceAction.mcpToolName,
-    'toolbox__amalgm_browser_browser_navigate',
+    catalog.toolActions['browser.browser_navigate'].sourceAction.mcpToolName,
+    'toolbox__browser_browser_navigate',
   );
   assert.equal(
-    catalog.toolActions['amalgm.browser.browser_navigate'].sourceAction.handlerName,
+    catalog.toolActions['browser.browser_navigate'].sourceAction.handlerName,
     'browser_navigate',
   );
   assert.equal(
-    catalog.toolActions['amalgm.notifications.notify_user'].sourceAction.mcpToolName,
-    'toolbox__amalgm_notifications_notify_user',
+    catalog.toolActions['notifications.notify_user'].sourceAction.mcpToolName,
+    'toolbox__notifications_notify_user',
   );
 });
 
@@ -33,8 +34,8 @@ test('system toolbox catalog merge preserves persisted records', () => {
   const merged = mergeSystemToolboxCatalog({
     version: 1,
     tools: {
-      'amalgm.browser': {
-        id: 'amalgm.browser',
+      browser: {
+        id: 'browser',
         name: 'Persisted Browser',
         origin: 'system',
       },
@@ -45,37 +46,41 @@ test('system toolbox catalog merge preserves persisted records', () => {
       },
     },
     toolActions: {
-      'amalgm.browser.browser_navigate': {
-        id: 'amalgm.browser.browser_navigate',
-        toolId: 'amalgm.browser',
+      'browser.browser_navigate': {
+        id: 'browser.browser_navigate',
+        toolId: 'browser',
         name: 'persisted_navigate',
       },
     },
   });
 
-  assert.equal(merged.tools['amalgm.browser'].name, 'Persisted Browser');
+  assert.equal(merged.tools.browser.name, 'Persisted Browser');
   assert.equal(merged.tools['custom.cli'].name, 'Custom CLI');
   assert.equal(
-    merged.toolActions['amalgm.browser.browser_navigate'].name,
+    merged.toolActions['browser.browser_navigate'].name,
     'persisted_navigate',
   );
-  assert.equal(merged.toolActions['amalgm.apps.apps_list'].name, 'apps_list');
+  assert.equal(merged.toolActions['apps.apps_list'].name, 'apps_list');
 });
 
 test('system toolbox catalog omits legacy aggregate amalgm records', () => {
   const filtered = persistedCatalogWithoutLegacyAggregate({
     tools: {
       amalgm: { id: 'amalgm', origin: 'system' },
+      'amalgm.browser': { id: 'amalgm.browser', origin: 'system' },
       'custom.cli': { id: 'custom.cli', origin: 'user' },
     },
     toolActions: {
       'amalgm.notify_user': { id: 'amalgm.notify_user', toolId: 'amalgm' },
+      'amalgm.browser.browser_navigate': { id: 'amalgm.browser.browser_navigate', toolId: 'amalgm.browser' },
       'custom.cli.run': { id: 'custom.cli.run', toolId: 'custom.cli' },
     },
   });
 
   assert.equal(filtered.tools.amalgm, undefined);
+  assert.equal(filtered.tools['amalgm.browser'], undefined);
   assert.equal(filtered.toolActions['amalgm.notify_user'], undefined);
+  assert.equal(filtered.toolActions['amalgm.browser.browser_navigate'], undefined);
   assert.equal(filtered.tools['custom.cli'].id, 'custom.cli');
   assert.equal(filtered.toolActions['custom.cli.run'].id, 'custom.cli.run');
 });