amalgm 0.1.75 → 0.1.76

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

@@ -0,0 +1,248 @@
+'use strict';
+
+const crypto = require('crypto');
+
+const CONFIG_VERSION = 1;
+const DEFAULT_RUNTIME_HOME_LAYOUT = 'legacy';
+const PER_AGENT_RUNTIME_HOME_LAYOUT = 'per-agent';
+
+function isObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+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()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 80);
+  if (clean) return `${prefix}-${clean}`;
+  return `${prefix}-${crypto.randomUUID()}`;
+}
+
+function cloneJson(value) {
+  if (value == null) return value;
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return null;
+  }
+}
+
+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);
+    if (!name) return null;
+    return {
+      id: stableId('skill', name),
+      name,
+      description: '',
+      content: '',
+      enabled: true,
+      source: { kind: 'amalgm' },
+    };
+  }
+  if (!isObject(value)) return null;
+  const name = nonEmptyString(value.name || value.id || `Skill ${index + 1}`);
+  const content = typeof value.content === 'string' ? value.content : '';
+  if (!name && !content) return null;
+  return {
+    id: nonEmptyString(value.id) || stableId('skill', name || content.slice(0, 80)),
+    name: name || `Skill ${index + 1}`,
+    description: typeof value.description === 'string' ? value.description : '',
+    content,
+    enabled: value.enabled !== false,
+    source: isObject(value.source) ? cloneJson(value.source) : { kind: 'amalgm' },
+  };
+}
+
+function normalizeSkills(values) {
+  if (!Array.isArray(values)) return [];
+  const byId = new Map();
+  values.map(normalizeSkill).filter(Boolean).forEach((skill) => {
+    byId.set(skill.id, skill);
+  });
+  return [...byId.values()];
+}
+
+function normalizeHook(value, index = 0) {
+  if (!isObject(value)) return null;
+  const command = nonEmptyString(value.command);
+  const type = nonEmptyString(value.type) || (command ? 'command' : 'native');
+  if (type === 'command' && !command) return null;
+  const event = nonEmptyString(value.event) || nonEmptyString(value.phase) || 'UserPromptSubmit';
+  const phase = nonEmptyString(value.phase) || event;
+  const label = nonEmptyString(value.label || value.name) || (command ? command.split(/\s+/).slice(0, 3).join(' ') : event);
+  const timeout = Number(value.timeout);
+  return {
+    id: nonEmptyString(value.id) || stableId('hook', `${event}-${label}-${index}`),
+    name: label,
+    enabled: value.enabled !== false,
+    event,
+    phase,
+    matcher: typeof value.matcher === 'string' ? value.matcher : '',
+    type,
+    ...(command ? { command } : {}),
+    ...(Number.isFinite(timeout) && timeout > 0 ? { timeout } : {}),
+    ...(typeof value.statusMessage === 'string' && value.statusMessage.trim()
+      ? { statusMessage: value.statusMessage.trim() }
+      : {}),
+    source: isObject(value.source)
+      ? cloneJson(value.source)
+      : {
+          kind: value.source === 'native' ? 'native-import' : 'amalgm',
+          ...(nonEmptyString(value.harnessId) ? { harnessId: nonEmptyString(value.harnessId) } : {}),
+          ...(nonEmptyString(value.sourcePath) ? { path: nonEmptyString(value.sourcePath) } : {}),
+        },
+  };
+}
+
+function normalizeHooks(values) {
+  if (!Array.isArray(values)) return [];
+  const byId = new Map();
+  values.map(normalizeHook).filter(Boolean).forEach((hook) => {
+    byId.set(hook.id, hook);
+  });
+  return [...byId.values()];
+}
+
+function normalizeSubagent(value, index = 0) {
+  if (typeof value === 'string') {
+    const agentId = nonEmptyString(value);
+    if (!agentId) return null;
+    return {
+      id: stableId('subagent', agentId),
+      agentId,
+      name: '',
+      description: '',
+      enabled: true,
+      source: { kind: 'amalgm' },
+    };
+  }
+  if (!isObject(value)) return null;
+  const agentId = nonEmptyString(value.agentId || value.agent_id || value.id);
+  if (!agentId) return null;
+  return {
+    id: nonEmptyString(value.id) || stableId('subagent', `${agentId}-${index}`),
+    agentId,
+    name: nonEmptyString(value.name),
+    description: typeof value.description === 'string' ? value.description : '',
+    enabled: value.enabled !== false,
+    source: isObject(value.source) ? cloneJson(value.source) : { kind: 'amalgm' },
+  };
+}
+
+function normalizeSubagents(values) {
+  if (!Array.isArray(values)) return [];
+  const byAgent = new Map();
+  values.map(normalizeSubagent).filter(Boolean).forEach((subagent) => {
+    byAgent.set(subagent.agentId, subagent);
+  });
+  return [...byAgent.values()];
+}
+
+function normalizeInstructions(value, fallback = '') {
+  if (isObject(value)) {
+    return typeof value.text === 'string' ? value.text : fallback;
+  }
+  return typeof value === 'string' ? value : fallback;
+}
+
+function normalizeRuntimeHomeLayout(value, fallback = DEFAULT_RUNTIME_HOME_LAYOUT) {
+  if (value === PER_AGENT_RUNTIME_HOME_LAYOUT) return PER_AGENT_RUNTIME_HOME_LAYOUT;
+  if (value === DEFAULT_RUNTIME_HOME_LAYOUT) return DEFAULT_RUNTIME_HOME_LAYOUT;
+  return fallback === PER_AGENT_RUNTIME_HOME_LAYOUT
+    ? PER_AGENT_RUNTIME_HOME_LAYOUT
+    : DEFAULT_RUNTIME_HOME_LAYOUT;
+}
+
+function normalizeAgentConfig(input = {}, fallback = {}) {
+  const raw = isObject(input) ? input : {};
+  const prior = isObject(fallback) ? fallback : {};
+  const agentId = nonEmptyString(raw.agentId || raw.agent_id || prior.agentId);
+  return {
+    version: CONFIG_VERSION,
+    ...(agentId ? { agentId } : {}),
+    runtimeHomeLayout: normalizeRuntimeHomeLayout(
+      raw.runtimeHomeLayout ?? raw.runtime_home_layout,
+      prior.runtimeHomeLayout,
+    ),
+    instructions: normalizeInstructions(
+      raw.instructions ?? raw.systemPrompt,
+      typeof prior.instructions === 'string' ? prior.instructions : '',
+    ),
+    skills: normalizeSkills(raw.skills ?? prior.skills ?? []),
+    tools: normalizeTools(raw.tools, prior.tools),
+    hooks: normalizeHooks(raw.hooks ?? prior.hooks ?? []),
+    subagents: normalizeSubagents(raw.subagents ?? prior.subagents ?? []),
+  };
+}
+
+function configFromAgent(agent = {}) {
+  return normalizeAgentConfig({
+    agentId: agent.id,
+    instructions: agent.systemPrompt || '',
+    skills: agent.skills || [],
+    tools: agent.tools || { mode: 'all', selectedToolIds: [] },
+    hooks: agent.hooks || [],
+    subagents: agent.subagents || [],
+  });
+}
+
+function legacyFieldsFromConfig(config = {}) {
+  const normalized = normalizeAgentConfig(config);
+  return {
+    systemPrompt: normalized.instructions,
+    skills: normalized.skills
+      .filter((skill) => skill.enabled !== false)
+      .map((skill) => skill.content || skill.name)
+      .filter(Boolean),
+    tools: normalized.tools,
+    hooks: normalized.hooks,
+    subagents: normalized.subagents,
+  };
+}
+
+module.exports = {
+  CONFIG_VERSION,
+  DEFAULT_RUNTIME_HOME_LAYOUT,
+  PER_AGENT_RUNTIME_HOME_LAYOUT,
+  configFromAgent,
+  legacyFieldsFromConfig,
+  normalizeAgentConfig,
+  normalizeHooks,
+  normalizeRuntimeHomeLayout,
+  normalizeSkills,
+  normalizeSubagents,
+  normalizeTools,
+  stableId,
+  uniqueStrings,
+};

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

@@ -0,0 +1,123 @@
+'use strict';
+
+const { openLocalDb } = require('../state/db');
+const { insertStateEvent, publishStateEvent } = require('../state/events');
+const {
+  configFromAgent,
+  legacyFieldsFromConfig,
+  normalizeAgentConfig,
+} = require('./schema');
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function readRow(db, agentId) {
+  return db.prepare('SELECT * FROM agent_configs WHERE agent_id = ?').get(agentId);
+}
+
+function rowToConfig(row) {
+  if (!row) return null;
+  try {
+    return normalizeAgentConfig(JSON.parse(row.config_json || '{}'));
+  } catch {
+    return null;
+  }
+}
+
+function defaultConfigForAgent(agentOrId) {
+  if (agentOrId && typeof agentOrId === 'object') {
+    return configFromAgent(agentOrId);
+  }
+  const { resolveAgent } = require('../agents/store');
+  const agent = resolveAgent(agentOrId);
+  return agent ? configFromAgent(agent) : normalizeAgentConfig({ agentId: agentOrId });
+}
+
+function getAgentConfig(agentOrId, db = openLocalDb()) {
+  const agentId = typeof agentOrId === 'object' ? agentOrId?.id : agentOrId;
+  if (!agentId) return normalizeAgentConfig({});
+  return rowToConfig(readRow(db, agentId)) || defaultConfigForAgent(agentOrId);
+}
+
+function upsertAgentConfig(agentId, configPatch, options = {}) {
+  if (!agentId) throw new Error('agent_id is required');
+  const db = openLocalDb();
+  const existing = getAgentConfig(agentId, db);
+  const hadRow = Boolean(readRow(db, agentId));
+  const config = normalizeAgentConfig({
+    ...existing,
+    ...(configPatch || {}),
+    agentId,
+  }, existing);
+  const updatedAt = nowIso();
+  const event = db.transaction(() => {
+    db.prepare(`
+      INSERT INTO agent_configs (agent_id, version, updated_at, config_json)
+      VALUES (@agent_id, @version, @updated_at, @config_json)
+      ON CONFLICT(agent_id) DO UPDATE SET
+        version = excluded.version,
+        updated_at = excluded.updated_at,
+        config_json = excluded.config_json
+    `).run({
+      agent_id: agentId,
+      version: config.version,
+      updated_at: updatedAt,
+      config_json: JSON.stringify(config),
+    });
+    return insertStateEvent(db, {
+      resource: 'agent_configs',
+      op: hadRow ? 'update' : 'insert',
+      id: agentId,
+      value: config,
+      clientMutationId: options.clientMutationId,
+      source: options.source || 'agent-config:update',
+    });
+  })();
+  publishStateEvent(event);
+  return config;
+}
+
+function deleteAgentConfig(agentId, options = {}) {
+  if (!agentId) throw new Error('agent_id is required');
+  const db = openLocalDb();
+  const existing = rowToConfig(readRow(db, agentId));
+  if (!existing) return null;
+  const event = db.transaction(() => {
+    db.prepare('DELETE FROM agent_configs WHERE agent_id = ?').run(agentId);
+    return insertStateEvent(db, {
+      resource: 'agent_configs',
+      op: 'delete',
+      id: agentId,
+      source: options.source || 'agent-config:delete',
+    });
+  })();
+  publishStateEvent(event);
+  return existing;
+}
+
+function listAgentConfigs(db = openLocalDb()) {
+  return db.prepare('SELECT * FROM agent_configs ORDER BY updated_at DESC, agent_id ASC')
+    .all()
+    .map(rowToConfig)
+    .filter(Boolean);
+}
+
+function agentWithConfig(agent) {
+  if (!agent) return null;
+  const config = getAgentConfig(agent);
+  return {
+    ...agent,
+    ...legacyFieldsFromConfig(config),
+    config,
+  };
+}
+
+module.exports = {
+  agentWithConfig,
+  deleteAgentConfig,
+  getAgentConfig,
+  legacyFieldsFromConfig,
+  listAgentConfigs,
+  upsertAgentConfig,
+};

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

@@ -178,5 +178,7 @@ function collectNativeHooks() {
 }
 
 module.exports = {
+  collectClaudeHooks,
+  collectCodexHooks,
   collectNativeHooks,
 };

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

@@ -11,6 +11,12 @@ const {
 } = require('./store');
 const { hydrateModelPreferences } = require('../lib/prefs');
 const credentialAdapter = require('../../credential-adapter');
+const {
+  agentWithConfig,
+  deleteAgentConfig,
+  legacyFieldsFromConfig,
+  upsertAgentConfig,
+} = require('../agent-config/store');
 const {
   defaultToolboxService: toolboxService,
 } = require('../toolbox/service');
@@ -56,14 +62,14 @@ function normalizeToolConfig(tools) {
 
 async function handleList(sendJson) {
   await hydrateModelPreferences();
-  sendJson(200, { agents: getAllAgentsWithBuiltins() });
+  sendJson(200, { agents: getAllAgentsWithBuiltins().map(agentWithConfig) });
 }
 
 async function handleGet(body, sendJson) {
   const { agent_id } = body;
   const agent = resolveAgent(agent_id);
   if (!agent) return sendJson(404, { error: `Agent not found: ${agent_id}` });
-  sendJson(200, { agent });
+  sendJson(200, { agent: agentWithConfig(agent) });
 }
 
 async function handleCreate(body, sendJson) {
@@ -78,6 +84,7 @@ async function handleCreate(body, sendJson) {
     skills,
     tools,
     authMethod,
+    config,
   } = body;
   if (!name || !name.trim()) return sendJson(400, { error: 'name is required' });
   if (!baseHarnessId) return sendJson(400, { error: 'baseHarnessId is required' });
@@ -86,6 +93,13 @@ async function handleCreate(body, sendJson) {
   const mcpConfig = derivedMcpTransportConfig(toolConfig);
   let agent;
   try {
+    const configPatch = config && typeof config === 'object' && !Array.isArray(config)
+      ? config
+      : {
+          instructions: systemPrompt || '',
+          skills: normalizeStringList(skills),
+          tools: toolConfig,
+        };
     agent = createAgent({
       name: name.trim(),
       description: description || '',
@@ -101,6 +115,15 @@ async function handleCreate(body, sendJson) {
       mcp: mcpConfig,
       authMethod: coerceAuthMethodForHarness(baseHarnessId, authMethod),
     });
+    const savedConfig = upsertAgentConfig(agent.id, {
+      ...configPatch,
+      runtimeHomeLayout: 'per-agent',
+    }, { source: 'agents:create' });
+    agent = {
+      ...agent,
+      ...legacyFieldsFromConfig(savedConfig),
+      config: savedConfig,
+    };
   } catch (error) {
     return sendJson(400, { error: error.message || 'Failed to create agent' });
   }
@@ -130,7 +153,26 @@ async function handleUpdate(body, sendJson) {
 
   let agent;
   try {
+    const configPatch = updates.config && typeof updates.config === 'object' && !Array.isArray(updates.config)
+      ? updates.config
+      : {
+          instructions: updates.systemPrompt ?? existing.systemPrompt ?? '',
+          skills: normalizeStringList(updates.skills ?? existing.skills),
+          tools: toolConfig,
+          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;
     agent = updateAgent(agent_id, updates);
+    agent = {
+      ...agent,
+      ...legacyFieldsFromConfig(savedConfig),
+      config: savedConfig,
+    };
   } catch (error) {
     const message = error.message || 'Failed to update agent';
     return sendJson(message.includes('not found') ? 404 : 400, { error: message });
@@ -144,6 +186,7 @@ async function handleDelete(body, sendJson) {
   if (!agent_id) return sendJson(400, { error: 'agent_id is required' });
   let deleted;
   try {
+    deleteAgentConfig(agent_id, { source: 'agents:delete' });
     deleted = deleteAgent(agent_id);
   } catch (error) {
     const message = error.message || 'Failed to delete agent';

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

@@ -38,6 +38,8 @@ const {
   getChatInputText,
   normalizeChatInput,
 } = require('../../../lib/chatInput');
+const { getAgentConfig, legacyFieldsFromConfig } = require('../agent-config/store');
+const { renderAgentInstructions } = require('../agent-config/renderers/instructions');
 const credentialAdapter = require('../../credential-adapter');
 const { buildLocalMcpServerConfigs } = require('../lib/mcp-resolver');
 const {
@@ -128,6 +130,12 @@ function buildAgentInstructions(systemPrompt, files, skills) {
     .join('\n\n');
 }
 
+function buildAgentFilesBlock(files) {
+  const normalizedFiles = normalizeStringList(files);
+  if (normalizedFiles.length === 0) return '';
+  return `<agent-resources>\nFiles available to this agent:\n${normalizedFiles.map((file) => `- ${file}`).join('\n')}\n</agent-resources>`;
+}
+
 function buildReturnChannelInstructions(context = {}) {
   const callerConversationId = normalizeConversationId(context.callerSessionId);
   if (!callerConversationId || !hasSupabase()) return '';
@@ -590,15 +598,20 @@ async function handleTalkToAgent(args, context = {}) {
     agent.baseHarnessId,
     agent.authMethod || preferredAuthMethod,
   );
+  const agentConfig = getAgentConfig(agent);
+  const configLegacy = legacyFieldsFromConfig(agentConfig);
   const agentFiles = normalizeStringList(agent.files);
-  const agentSkills = normalizeStringList(agent.skills);
-  const agentTools = agent.tools || { mode: 'all', selectedToolIds: [] };
+  const agentSkills = normalizeStringList(configLegacy.skills);
+  const agentTools = configLegacy.tools || agent.tools || { mode: 'all', selectedToolIds: [] };
   const agentMcpAppIds = toolboxService.externalMcpToolIdsForMode(
     agentTools.mode,
     agentTools.selectedToolIds,
   );
-  const baseAgentSystemPrompt = buildAgentInstructions(
-    agent.systemPrompt,
+  const baseAgentSystemPrompt = [
+    renderAgentInstructions(agentConfig, { includeAgentToAgentPrompt: true }),
+    buildAgentFilesBlock(agentFiles),
+  ].filter(Boolean).join('\n\n') || buildAgentInstructions(
+    configLegacy.systemPrompt || agent.systemPrompt,
     agentFiles,
     agentSkills,
   );
@@ -771,6 +784,7 @@ async function handleTalkToAgent(args, context = {}) {
             skills: agentSkills,
             mcpAppIds: agentMcpAppIds,
             tools: agentTools,
+            agentConfig,
             ...(parentOrigin || {}),
           },
         });
@@ -826,6 +840,8 @@ async function handleTalkToAgent(args, context = {}) {
       cwd: legacyChatFields.cwd || DEFAULT_CWD,
       authMethod: legacyChatFields.authMethod || defaultAuthMethod,
       mcpServers,
+      agentConfig,
+      agentConfigId: agent.id,
       ...(legacyChatFields.systemPrompt ? { systemPrompt: legacyChatFields.systemPrompt } : {}),
       ...(longMessageContext ? { longMessageContext } : {}),
       ...(!isNewConversation ? { resumeSessionId: sessionId } : {}),

package/runtime/scripts/amalgm-mcp/automations/tool-actions.js

@@ -8,17 +8,17 @@ const {
 function firstPartyToolGroups() {
   return [
     {
-      id: 'amalgm.notifications',
+      id: 'notifications',
       kind: 'first_party',
       tools: require('../notify'),
     },
     {
-      id: 'amalgm.agents',
+      id: 'agents',
       kind: 'first_party',
       tools: require('../agents/tools'),
     },
     {
-      id: 'amalgm.apps',
+      id: 'apps',
       kind: 'first_party',
       tools: require('../apps/tools'),
     },
@@ -33,16 +33,58 @@ function normalizeRef(value) {
   return String(value || '').trim().toLowerCase().replace(/[^a-z0-9]+/g, '');
 }
 
-function resolveFirstPartyToolAction(toolId, actionName) {
-  const normalizedToolId = String(toolId || '').trim();
+function findFirstPartyAction(group, actionName) {
   const normalizedActionName = String(actionName || '').trim();
-  const group = firstPartyToolGroups().find((candidate) => candidate.id === normalizedToolId);
-  if (!group) return null;
-  const tool = group.tools.find((candidate) => (
+  return group.tools.find((candidate) => (
     candidate.name === normalizedActionName
     || candidate.name === normalizedActionName.replace(/\./g, '_')
-  ));
+  )) || null;
+}
+
+function canonicalFirstPartyRef(toolId, actionName) {
+  let normalizedToolId = String(toolId || '').trim();
+  if (normalizedToolId.startsWith('amalgm.')) {
+    normalizedToolId = normalizedToolId.slice('amalgm.'.length);
+  }
+
+  if (normalizedToolId === 'amalgm') {
+    for (const group of firstPartyToolGroups()) {
+      const tool = findFirstPartyAction(group, actionName);
+      if (tool) return { group, actionName: tool.name };
+    }
+    return null;
+  }
+
+  const group = firstPartyToolGroups().find((candidate) => candidate.id === normalizedToolId);
+  if (!group) return null;
+  const tool = findFirstPartyAction(group, actionName);
   if (!tool) return null;
+  return { group, actionName: tool.name };
+}
+
+function workflowActionKeys(toolId, actionName) {
+  const raw = actionKey(toolId, actionName);
+  const canonical = canonicalFirstPartyRef(toolId, actionName);
+  if (!canonical) return [raw];
+  const keys = new Set([
+    raw,
+    actionKey(canonical.group.id, canonical.actionName),
+    actionKey(`amalgm.${canonical.group.id}`, canonical.actionName),
+  ]);
+  if (canonical.group.id === 'notifications' && canonical.actionName === 'notify_user') {
+    keys.add('amalgm.notify_user');
+  }
+  if (canonical.group.id === 'agents' && canonical.actionName === 'talk_to_agent') {
+    keys.add('amalgm.talk_to_agent');
+  }
+  return Array.from(keys);
+}
+
+function resolveFirstPartyToolAction(toolId, actionName) {
+  const canonical = canonicalFirstPartyRef(toolId, actionName);
+  if (!canonical) return null;
+  const { group, actionName: canonicalActionName } = canonical;
+  const tool = findFirstPartyAction(group, canonicalActionName);
   return {
     kind: 'first_party',
     ref: actionKey(group.id, tool.name),
@@ -170,5 +212,6 @@ module.exports = {
   resolveWorkflowToolAction,
   suggestWorkflowToolActions,
   validateWorkflowToolActions,
+  workflowActionKeys,
   workflowActionSummaries,
 };

package/runtime/scripts/amalgm-mcp/automations/tools.js

@@ -24,10 +24,10 @@ const WORKFLOW_DESCRIPTION = [
   'The script is the workflow. A trigger decides when it runs; cells decide what happens.',
   'Workflow `trigger` refs are `source.event` strings such as `github.push`; `github.*` means any GitHub event; `*.push` means a push from any source; `*.*` means any source and event.',
   'Cells can call `code(name, fn)`, gated local `cli(name, config)`, gated `http(name, config)`, and `tool(name, "tool.action", args)`.',
-  'Agents are tools too: use `agent(name, agentIdOrName, { prompt, run_in_background: true })` or `tool(name, "amalgm.agents.talk_to_agent", args)`.',
+  'Agents are tools too: use `agent(name, agentIdOrName, { prompt, run_in_background: true })` or `tool(name, "agents.talk_to_agent", args)`.',
   'Every function receives one ctx object: `{ automation, trigger, workflow, event, payload, headers, previous, outputs, cells, secrets, stop }`.',
   'Cell outputs are available as `ctx.cells.cellName.output`, `ctx.cells.cellName.field` for object outputs, `ctx.outputs.cellName`, and top-level `ctx.cellName`.',
-  'Example: `tool("notify", "amalgm.notifications.notify_user", ({ cells }) => ({ message: cells.greet.output.message }))`.',
+  'Example: `tool("notify", "notifications.notify_user", ({ cells }) => ({ message: cells.greet.output.message }))`.',
 ].join('\n\n');
 
 function compactAutomation(automation, includeWorkflowText = true) {
@@ -180,7 +180,7 @@ module.exports = [
   {
     name: 'automations_list_actions',
     description:
-      'List workflow-callable tool actions for automation scripts. Use these refs in workflow cells like `tool("name", "tool.ref", args)`. This includes built-in `http.fetch`, first-party Toolbox actions such as `amalgm.notifications.notify_user`, and runnable Toolbox CLI/API actions.',
+      'List workflow-callable tool actions for automation scripts. Use these refs in workflow cells like `tool("name", "tool.ref", args)`. This includes built-in `http.fetch`, first-party Toolbox actions such as `notifications.notify_user`, and runnable Toolbox CLI/API actions.',
     inputSchema: {
       type: 'object',
       properties: {

package/runtime/scripts/amalgm-mcp/events/internal-workflows.js

@@ -28,7 +28,7 @@ function engineNpmPublishWorkflow(repoPath) {
   allowlist: {
     localCompute: true,
     secrets: ["NODE_AUTH_TOKEN"],
-    actions: ["amalgm.notifications.notify_user"]
+    actions: ["notifications.notify_user"]
   },
 
   limits: {
@@ -116,7 +116,7 @@ function engineNpmPublishWorkflow(repoPath) {
       timeoutMs: 600000
     }),
 
-    tool("notify_user", "amalgm.notifications.notify_user", {
+    tool("notify_user", "notifications.notify_user", {
       subject: "amalgm npm publish complete",
       level: "success",
       message: ({ outputs }) => {
@@ -153,7 +153,7 @@ function internalWorkflowSeeds() {
       allowlist: {
         localCompute: true,
         secrets: ['NODE_AUTH_TOKEN'],
-        actions: ['amalgm.notifications.notify_user'],
+        actions: ['notifications.notify_user'],
       },
       limits: {
         maxConcurrentRuns: 1,