amalgm 0.1.80 → 0.1.81

package/package.json

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

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

@@ -21,7 +21,10 @@ 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'];
+  const lines = [
+    '## Skills to use',
+    'Use these skills when relevant to complete tasks.',
+  ];
   for (const skill of enabled) {
     const title = skill.description
       ? `${skill.name || skill.id}: ${skill.description}`
@@ -41,7 +44,10 @@ 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'];
+  const lines = [
+    '## Subagents',
+    'The user wants you to use these subagents when relevant.',
+  ];
   for (const subagent of enabled) {
     const name = subagent.name || subagent.agentId;
     const title = subagent.description
@@ -54,8 +60,15 @@ function compileSubagentsSection(subagents) {
 
 function compileAgentInstructions(config, options = {}) {
   const normalized = normalizeAgentConfig(config);
+  const userInstructions = normalized.instructions
+    ? [
+        '## Instructions',
+        "Here are instructions from the user on how they'd like you to operate.",
+        normalized.instructions,
+      ].join('\n')
+    : '';
   const chunks = [
-    normalized.instructions,
+    userInstructions,
     compileSkillsSection(normalized.skills),
     compileSubagentsSection(normalized.subagents),
     options.extraMarkdown,

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

@@ -72,6 +72,7 @@ async function handleGet(body, sendJson) {
 
 async function handleCreate(body, sendJson) {
   const {
+    id,
     name,
     description,
     baseHarnessId,
@@ -99,6 +100,7 @@ async function handleCreate(body, sendJson) {
           loadout: agentLoadout,
         };
     agent = createAgent({
+      ...(typeof id === 'string' && id.trim() ? { id: id.trim() } : {}),
       name: name.trim(),
       description: description || '',
       baseHarnessId,

package/runtime/scripts/chat-core/chat-payload.js

@@ -3,6 +3,7 @@
 const { chatInputToLegacyFields, normalizeChatInput } = require('../../lib/chatInput');
 const { getChatPayload } = require('../amalgm-mcp/lib/chat-payloads');
 const { buildLocalMcpServerConfigs } = require('../amalgm-mcp/lib/mcp-resolver');
+const { getAgentConfig } = require('../amalgm-mcp/agent-config/store');
 const { normalizeLoadout } = require('../amalgm-mcp/agent-config/loadout');
 
 function isObject(value) {
@@ -33,6 +34,10 @@ function applyPayloadRecord(body, record) {
   const rawAgent = isObject(rawChatInput.agent) ? rawChatInput.agent : {};
   const rawTools = isObject(rawChatInput.tools) ? rawChatInput.tools : {};
   const rawExecution = isObject(rawChatInput.execution) ? rawChatInput.execution : {};
+  const agentConfigSnapshot = isObject(payload.agentConfigSnapshot) ? payload.agentConfigSnapshot : null;
+  const snapshotAgentConfig = isObject(agentConfigSnapshot?.config) ? agentConfigSnapshot.config : null;
+  const snapshotAgentId = nullableString(agentConfigSnapshot?.agentId);
+  const snapshotCompiledAgentInstructions = nullableString(agentConfigSnapshot?.compiledInstructions);
   const modelSettings = isObject(payload.modelSettings)
     ? payload.modelSettings
     : isObject(body.modelSettings)
@@ -55,11 +60,27 @@ function applyPayloadRecord(body, record) {
     || nullableString(body.authMethod);
   const customAgentId =
     nullableString(payload.customAgentId)
-    || nullableString(rawAgent.customAgentId);
-  const systemPrompt =
+    || nullableString(rawAgent.customAgentId)
+    || snapshotAgentId;
+  const agentConfigId =
+    snapshotAgentId
+    || nullableString(payload.agentConfigId)
+    || nullableString(body.agentConfigId)
+    || customAgentId;
+  const agentConfig =
+    snapshotAgentConfig
+    || (isObject(payload.agentConfig) && payload.agentConfig)
+    || (isObject(body.agentConfig) && body.agentConfig)
+    || (agentConfigId ? getAgentConfig(agentConfigId) : null);
+  const compiledAgentInstructions =
+    snapshotCompiledAgentInstructions
+    || nullableString(payload.compiledAgentInstructions)
+    || nullableString(body.compiledAgentInstructions);
+  const legacySystemPrompt =
     nullableString(payload.systemPrompt)
     || nullableString(rawAgent.systemPrompt)
     || nullableString(body.systemPrompt);
+  const systemPrompt = agentConfig || compiledAgentInstructions ? null : legacySystemPrompt;
   const cwd =
     nullableString(body.cwd)
     || nullableString(rawExecution.cwd)
@@ -122,7 +143,9 @@ function applyPayloadRecord(body, record) {
     mcpAppIds,
     modelSettings,
     agentId: customAgentId || harnessToAgent(harness),
-    ...(customAgentId ? { agentConfigId: customAgentId } : {}),
+    ...(agentConfigId ? { agentConfigId } : {}),
+    ...(agentConfig ? { agentConfig } : {}),
+    ...(compiledAgentInstructions ? { compiledAgentInstructions } : {}),
     ...(reasoningEffort ? { reasoningEffort } : {}),
     ...(modelSettings.fastMode === true ? { fastMode: true } : {}),
   };

package/runtime/scripts/chat-core/contract.js

@@ -202,11 +202,22 @@ function frozenRuntimeFields(input) {
     .sort((a, b) => `${a.name}\0${a.type}\0${a.url}`.localeCompare(`${b.name}\0${b.type}\0${b.url}`));
   return {
     sessionId: input.sessionId,
+    userId: input.userId,
     computerId: input.computerId,
     harness: input.harness,
     authMethod: input.authMethod,
     auth: authIdentity,
+    modelId: input.modelId,
+    usageModelId: input.usageModelId,
+    cliModel: input.cliModel,
+    reasoningEffort: input.reasoningEffort || null,
+    fastMode: input.fastMode === true,
+    contextWindow: input.contextWindow ?? null,
+    maxTokens: input.maxTokens ?? null,
+    cwd: input.cwd,
+    runtimeHomeLayout: input.runtimeHomeLayout,
     systemPrompt: fingerprint(input.systemPrompt || ''),
+    compiledAgentInstructions: fingerprint(input.compiledAgentInstructions || ''),
     agentConfig: fingerprint(JSON.stringify(input.agentConfig || null)),
     origin: fingerprint(JSON.stringify(input.origin || null)),
     mcpServers: fingerprint(JSON.stringify(mcpServers)),
@@ -233,13 +244,50 @@ function frozenContractChangedError(current, next) {
   const changed = changedRuntimeFields(current, next);
   const label = changed.length ? ` (${changed.join(', ')})` : '';
   const err = new Error(
-    `Frozen session contract changed${label}; start a new session for auth/harness/computer/system-prompt/MCP changes`,
+    `Frozen session contract changed${label}; start a new session for auth/harness/computer/instruction/MCP changes`,
   );
   err.code = 'FROZEN_SESSION_CONTRACT_CHANGED';
   err.changedFields = changed;
   return err;
 }
 
+function continueFrozenRuntimeContract(current, next) {
+  if (!current) return next;
+  const changed = changedRuntimeFields(current, next);
+  if (changed.length === 0) return next;
+
+  return {
+    ...next,
+    userId: current.userId,
+    computerId: current.computerId,
+    agentId: current.agentId,
+    agentConfigId: current.agentConfigId,
+    agentConfig: current.agentConfig,
+    runtimeHomeLayout: current.runtimeHomeLayout,
+    harness: current.harness,
+    authMethod: current.authMethod,
+    modelId: current.modelId,
+    usageModelId: current.usageModelId,
+    cliModel: current.cliModel,
+    reasoningEffort: current.reasoningEffort,
+    fastMode: current.fastMode,
+    contextWindow: current.contextWindow,
+    maxTokens: current.maxTokens,
+    cwd: current.cwd,
+    origin: current.origin,
+    constructs: current.constructs,
+    localBaseUrl: current.localBaseUrl,
+    mcpServers: current.mcpServers,
+    systemPrompt: current.systemPrompt,
+    compiledAgentInstructions: current.compiledAgentInstructions,
+    usageOwner: current.usageOwner,
+    auth: current.auth,
+    runtimeFields: current.runtimeFields,
+    runtimeKey: current.runtimeKey,
+    continuedFromChangedContract: changed,
+  };
+}
+
 function expandHome(value) {
   const raw = String(value || '').trim();
   if (!raw) return '';
@@ -403,6 +451,7 @@ function createContract(payload, options = {}) {
     localBaseUrl,
     mcpServers: Array.isArray(payload.mcpServers) ? payload.mcpServers : [],
     systemPrompt: payload.systemPrompt || '',
+    compiledAgentInstructions: payload.compiledAgentInstructions || '',
     usageOwner: auth.method === 'amalgm' ? 'platform_proxy' : 'local_user',
     auth,
   };
@@ -424,6 +473,7 @@ module.exports = {
   canonicalModel,
   changedRuntimeFields,
   cliModelFor,
+  continueFrozenRuntimeContract,
   createContract,
   frozenRuntimeFields,
 };

package/runtime/scripts/chat-core/engine.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { PartAccumulator } = require('./parts');
-const { assertSameContract, createContract } = require('./contract');
+const { changedRuntimeFields, continueFrozenRuntimeContract, createContract } = require('./contract');
 const { done, errorEvent } = require('./events');
 const { normalizeInput } = require('./input');
 const { frameFor, titleFrame, withSseId } = require('./sse');
@@ -80,9 +80,22 @@ class ChatCore {
   contractFor(payload) {
     const next = createContract(payload, this.options);
     const existing = this.contracts.get(next.sessionId);
-    if (existing) assertSameContract(existing, next);
-    this.contracts.set(next.sessionId, next);
-    return next;
+    if (!existing) {
+      this.contracts.set(next.sessionId, next);
+      return next;
+    }
+
+    const changed = changedRuntimeFields(existing, next);
+    const contract = changed.length > 0
+      ? continueFrozenRuntimeContract(existing, next)
+      : next;
+    if (changed.length > 0) {
+      console.warn(
+        `[ChatCore] Ignoring changed frozen session contract fields for ${next.sessionId}: ${changed.join(', ')}`,
+      );
+    }
+    this.contracts.set(contract.sessionId, contract);
+    return contract;
   }
 
   active(sessionId) {

package/runtime/scripts/chat-core/tests/chat-payload.test.js

@@ -12,6 +12,8 @@ process.env.AMALGM_COMPUTER_ID = 'machine-local';
 
 const { closeLocalDb } = require('../../amalgm-mcp/state/db');
 const { writeChatPayload } = require('../../amalgm-mcp/lib/chat-payloads');
+const { createAgent } = require('../../amalgm-mcp/agents/store');
+const { upsertAgentConfig } = require('../../amalgm-mcp/agent-config/store');
 const { resolveMachineChatPayload } = require('../chat-payload');
 
 test.after(() => {
@@ -63,6 +65,147 @@ test('chat-core resolves launch payload from the local machine cache', async ()
   assert.equal(resolved.cliModel, undefined);
 });
 
+test('chat-core hydrates latest agent config when resolving local machine payloads', async () => {
+  createAgent({
+    id: 'custom-agent-test',
+    name: 'Custom Agent Test',
+    baseHarnessId: 'codex',
+    baseModelId: 'openai/gpt-5.5',
+    loadout: { toolIds: ['tool.search'] },
+  });
+  upsertAgentConfig('custom-agent-test', {
+    instructions: 'test code = 1234',
+    skills: [{
+      id: 'skill-test',
+      name: 'Test skill',
+      content: 'Use the configured skill.',
+      enabled: true,
+    }],
+    subagents: [{
+      id: 'subagent-reviewer',
+      agentId: 'reviewer',
+      name: 'Reviewer',
+      description: 'Use for review tasks.',
+      enabled: true,
+    }],
+    loadout: { toolIds: ['tool.search'] },
+    hooks: [],
+  });
+
+  writeChatPayload({
+    id: 'chat-view:agent-config',
+    revision: 'rev-agent-config',
+    payload: {
+      machineId: 'machine-local',
+      harness: 'codex',
+      resolvedHarnessId: 'codex',
+      modelId: 'openai/gpt-5.5',
+      modelSettings: {},
+      authMethod: 'amalgm',
+      cwd: '/tmp/amalgm-project',
+      customAgentId: 'custom-agent-test',
+      systemPrompt: 'stale legacy prompt',
+      mcpAppIds: [],
+      loadout: { toolIds: ['tool.search'] },
+      pendingWorktree: false,
+    },
+  });
+
+  const resolved = await resolveMachineChatPayload({
+    chatPayloadId: 'chat-view:agent-config',
+    chatPayloadRevision: 'rev-agent-config',
+    prompt: 'hello',
+  });
+
+  assert.equal(resolved.agentConfigId, 'custom-agent-test');
+  assert.equal(resolved.agentConfig.instructions, 'test code = 1234');
+  assert.equal(resolved.agentConfig.skills[0].content, 'Use the configured skill.');
+  assert.equal(resolved.agentConfig.subagents[0].agentId, 'reviewer');
+});
+
+test('chat-core resolves agent config snapshot from the machine payload before live config', async () => {
+  createAgent({
+    id: 'custom-agent-snapshot',
+    name: 'Custom Agent Snapshot',
+    baseHarnessId: 'codex',
+    baseModelId: 'openai/gpt-5.5',
+    loadout: { toolIds: ['tool.live'] },
+  });
+  upsertAgentConfig('custom-agent-snapshot', {
+    instructions: 'live config should not win',
+    skills: [],
+    subagents: [],
+    loadout: { toolIds: ['tool.live'] },
+    hooks: [],
+  });
+
+  const snapshotConfig = {
+    instructions: 'payload snapshot wins',
+    skills: [{
+      id: 'skill-snapshot',
+      name: 'Snapshot skill',
+      content: 'Use the payload snapshot skill.',
+      enabled: true,
+    }],
+    subagents: [{
+      id: 'subagent-snapshot-reviewer',
+      agentId: 'snapshot-reviewer',
+      name: 'Snapshot Reviewer',
+      description: 'Review from the payload snapshot.',
+      enabled: true,
+    }],
+    loadout: { toolIds: ['tool.snapshot'] },
+    hooks: [],
+  };
+  const compiledInstructions = [
+    '## Instructions',
+    "Here are instructions from the user on how they'd like you to operate.",
+    'payload snapshot wins',
+    '',
+    '## Skills to use',
+    'Use these skills when relevant to complete tasks.',
+    '- Snapshot skill',
+    '  Use the payload snapshot skill.',
+  ].join('\n');
+
+  writeChatPayload({
+    id: 'chat-view:agent-config-snapshot',
+    revision: 'rev-agent-config-snapshot',
+    payload: {
+      machineId: 'machine-local',
+      harness: 'codex',
+      resolvedHarnessId: 'codex',
+      modelId: 'openai/gpt-5.5',
+      modelSettings: {},
+      authMethod: 'amalgm',
+      cwd: '/tmp/amalgm-project',
+      customAgentId: 'custom-agent-snapshot',
+      systemPrompt: 'stale legacy prompt',
+      agentConfigSnapshot: {
+        agentId: 'custom-agent-snapshot',
+        revision: 'rev-snapshot',
+        config: snapshotConfig,
+        compiledInstructions,
+      },
+      mcpAppIds: [],
+      loadout: { toolIds: ['tool.snapshot'] },
+      pendingWorktree: false,
+    },
+  });
+
+  const resolved = await resolveMachineChatPayload({
+    chatPayloadId: 'chat-view:agent-config-snapshot',
+    chatPayloadRevision: 'rev-agent-config-snapshot',
+    prompt: 'hello',
+  });
+
+  assert.equal(resolved.agentConfigId, 'custom-agent-snapshot');
+  assert.equal(resolved.agentConfig.instructions, 'payload snapshot wins');
+  assert.equal(resolved.compiledAgentInstructions, compiledInstructions);
+  assert.equal(resolved.systemPrompt, null);
+  assert.deepEqual(resolved.chatInput.tools.toolIds, ['tool.snapshot']);
+});
+
 test('chat-core rejects stale chat payload revisions', async () => {
   await assert.rejects(
     () => resolveMachineChatPayload({

package/runtime/scripts/chat-core/tests/engine.test.js

@@ -53,6 +53,79 @@ function runTurnWithFrames(core, turnPayload) {
   return { run, frames };
 }
 
+function agentConfig(instructions) {
+  return {
+    version: 1,
+    agentId: 'codex',
+    runtimeHomeLayout: 'legacy',
+    instructions,
+    skills: [],
+    loadout: { toolIds: [] },
+    hooks: [],
+    subagents: [],
+  };
+}
+
+test('existing sessions keep their original frozen contract when payload config changes', async () => {
+  const contracts = [];
+  const db = {
+    saveUserMessage: async () => true,
+    ensureAssistantMessage: async () => true,
+    saveAssistantMessage: async () => true,
+    mergeSessionMetadata: async () => {},
+    logUsage: async () => {},
+  };
+  const fakeRuntime = {
+    get: () => ({ warm: true }),
+    stop: async () => {},
+    destroy: async () => true,
+    async *prompt(contract) {
+      contracts.push(contract);
+      yield textDelta('hi');
+      yield done({ providerSessionId: 'provider-test' });
+    },
+  };
+  const core = new ChatCore({
+    db,
+    runtime: fakeRuntime,
+    turns: new TurnStore(),
+    options: {
+      beginTurn: async () => {},
+    },
+  });
+
+  await core.runTurn(payload({
+    agentId: 'codex',
+    modelId: 'openai/gpt-5.5',
+    assistantMessageId: 'assistant-1',
+    userMessageId: 'user-1',
+    agentConfig: agentConfig('old instructions'),
+    compiledAgentInstructions: 'compiled old instructions',
+    mcpServers: [],
+  }));
+  await core.runTurn(payload({
+    agentId: 'codex',
+    modelId: 'openai/gpt-4.1',
+    assistantMessageId: 'assistant-2',
+    userMessageId: 'user-2',
+    agentConfig: agentConfig('new instructions'),
+    compiledAgentInstructions: 'compiled new instructions',
+    mcpServers: [{ name: 'new-tools', type: 'http', url: 'https://example.test/mcp' }],
+  }));
+
+  assert.equal(contracts.length, 2);
+  assert.equal(contracts[1].assistantMessageId, 'assistant-2');
+  assert.equal(contracts[1].userMessageId, 'user-2');
+  assert.equal(contracts[1].modelId, 'openai/gpt-5.5');
+  assert.equal(contracts[1].agentConfig.instructions, 'old instructions');
+  assert.equal(contracts[1].compiledAgentInstructions, 'compiled old instructions');
+  assert.deepEqual(contracts[1].mcpServers, []);
+  assert.deepEqual(
+    contracts[1].continuedFromChangedContract.sort(),
+    ['agentConfig', 'cliModel', 'compiledAgentInstructions', 'mcpServers', 'modelId', 'usageModelId'].sort(),
+  );
+});
+
 test('title generation waits for user save and does not block a fast turn', async () => {
   let resolveUserSave;
   let resolveTitle;

package/runtime/scripts/chat-core/tests/system-prompt.test.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { composeSystemPrompt } = require('../tooling/system-prompt');
+
+test('composeSystemPrompt renders agent config instructions over legacy systemPrompt', () => {
+  const prompt = composeSystemPrompt({
+    systemPrompt: 'legacy stale prompt',
+    agentConfig: {
+      agentId: 'agent-codex',
+      instructions: 'test code = 1234',
+      skills: [{
+        id: 'skill-debug',
+        name: 'Debug skill',
+        content: 'Use the debug checklist.',
+        enabled: true,
+      }],
+      subagents: [{
+        id: 'agent-reviewer',
+        agentId: 'reviewer',
+        name: 'Reviewer',
+        description: 'Review risky changes.',
+        enabled: true,
+      }],
+      loadout: { toolIds: [] },
+      hooks: [],
+    },
+  });
+
+  assert.match(prompt, /test code = 1234/);
+  assert.match(prompt, /## Instructions/);
+  assert.match(prompt, /Here are instructions from the user/);
+  assert.match(prompt, /## Skills to use/);
+  assert.match(prompt, /Use the debug checklist/);
+  assert.match(prompt, /## Subagents/);
+  assert.match(prompt, /Reviewer: Review risky changes\./);
+  assert.doesNotMatch(prompt, /legacy stale prompt/);
+});
+
+test('composeSystemPrompt prefers compiled payload instructions over agent config recompute', () => {
+  const prompt = composeSystemPrompt({
+    systemPrompt: 'legacy stale prompt',
+    compiledAgentInstructions: 'compiled payload text wins',
+    agentConfig: {
+      agentId: 'agent-codex',
+      instructions: 'live agent config should not win',
+      skills: [],
+      subagents: [],
+      loadout: { toolIds: [] },
+      hooks: [],
+    },
+  });
+
+  assert.match(prompt, /compiled payload text wins/);
+  assert.doesNotMatch(prompt, /live agent config should not win/);
+  assert.doesNotMatch(prompt, /legacy stale prompt/);
+});
+
+test('composeSystemPrompt falls back to legacy systemPrompt without agent config instructions', () => {
+  const prompt = composeSystemPrompt({
+    systemPrompt: 'legacy fallback prompt',
+  });
+
+  assert.match(prompt, /legacy fallback prompt/);
+});

package/runtime/scripts/chat-core/tooling/system-prompt.js

@@ -12,8 +12,10 @@ function trimBlock(value) {
 function composeSystemPrompt(contract) {
   const parts = [];
   const platform = trimBlock(PLATFORM_CONTEXT);
-  const custom = trimBlock(contract?.systemPrompt)
+  const compiledAgentInstructions =
+    trimBlock(contract?.compiledAgentInstructions)
     || trimBlock(renderAgentInstructions(contract?.agentConfig, { includeAgentToAgentPrompt: false }));
+  const custom = compiledAgentInstructions || trimBlock(contract?.systemPrompt);
   const instructions = contract?.providerSessionId ? '' : trimBlock(instructionsContextBlock(contract));
   const active = contract?.providerSessionId ? '' : trimBlock(activeMemoryContextBlock(contract));
   const passive = contract?.providerSessionId ? '' : trimBlock(passiveMemoryContextBlock());