amalgm 0.1.88 → 0.1.89

package/runtime/scripts/amalgm-mcp/tests/project-context.test.js

@@ -0,0 +1,328 @@
+'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-project-context-test-'));
+process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
+process.env.AMALGM_WORKSPACES_DIR = path.join(process.env.AMALGM_DIR, 'workspaces');
+process.env.AMALGM_COMPUTER_ID = 'computer-test';
+
+const { closeLocalDb } = require('../state/db');
+const { currentSeq, listEventsAfter } = require('../state/events');
+const { upsertWorkspace } = require('../workspace/store');
+const store = require('../project-context/store');
+const prompt = require('../project-context/prompt');
+const {
+  changeLogEntriesSince,
+  changeLogRecentWindow,
+  insertChangeLogEntry,
+  latestChangeLogEntry,
+  localTimestamp,
+  sanitizeChangeLogBody,
+} = require('../project-context/paths');
+
+function makeProject(name) {
+  const projectPath = fs.realpathSync(fs.mkdtempSync(path.join(tempRoot, `${name}-`)));
+  const workspace = upsertWorkspace({ path: projectPath, name, source: 'computer' }, { source: 'test' });
+  return { projectPath, workspace };
+}
+
+function readContextFile(projectPath, fileName) {
+  return fs.readFileSync(path.join(projectPath, '.amalgm', 'context', fileName), 'utf8');
+}
+
+test.after(() => {
+  store.stopProjectContextService();
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+test('ensureProjectContext creates the three docs and a row, additively', () => {
+  const { projectPath, workspace } = makeProject('ensure');
+  const preexisting = path.join(projectPath, 'keep.txt');
+  fs.writeFileSync(preexisting, 'keep me');
+
+  const record = store.ensureProjectContext(workspace, { source: 'test' });
+
+  assert.deepEqual(
+    fs.readdirSync(path.join(projectPath, '.amalgm', 'context')).sort(),
+    ['change-log.md', 'instructions.md', 'project-state.md'],
+  );
+  assert.equal(fs.readFileSync(preexisting, 'utf8'), 'keep me');
+  assert.equal(record.projectId, workspace.id);
+  assert.ok(record.contextRevision);
+  // Existing content is never clobbered by a second ensure.
+  fs.writeFileSync(path.join(projectPath, '.amalgm/context/instructions.md'), '# Instructions\n\nKeep these.\n');
+  store.ensureProjectContext(workspace, { source: 'test' });
+  assert.match(readContextFile(projectPath, 'instructions.md'), /Keep these\./);
+});
+
+test('appendChangeLog stamps runtime timestamps and prepends under the title', () => {
+  const { projectPath, workspace } = makeProject('append');
+  store.ensureProjectContext(workspace);
+
+  const first = store.appendChangeLog(projectPath, '- Completed: first thing.');
+  const second = store.appendChangeLog(
+    path.join(projectPath),
+    '## 2099-01-01T00:00:00Z\n- Completed: model tried to write its own timestamp.',
+  );
+
+  const content = readContextFile(projectPath, 'change-log.md');
+  const lines = content.split('\n');
+  assert.equal(lines[0], '# Change Log');
+  // Newest entry sits directly under the title.
+  assert.equal(lines[2], `## ${second.timestamp.iso} [${second.timestamp.timeZone}]`);
+  assert.ok(content.indexOf('first thing') > content.indexOf('model tried'));
+  // The model-written timestamp heading was stripped, runtime timestamp won.
+  assert.ok(!content.includes('2099-01-01'));
+  assert.match(first.timestamp.iso, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2}$/);
+
+  assert.throws(() => store.appendChangeLog(projectPath, '   '), /body is required/);
+  assert.throws(
+    () => store.appendChangeLog(path.join(tempRoot, 'not-registered'), '- x'),
+    /No registered Amalgm project/,
+  );
+});
+
+test('appendChangeLog self-heals a mangled title', () => {
+  const { projectPath, workspace } = makeProject('selfheal');
+  store.ensureProjectContext(workspace);
+  fs.writeFileSync(path.join(projectPath, '.amalgm/context/change-log.md'), 'stray content, no heading\n');
+
+  store.appendChangeLog(projectPath, '- Completed: healed.');
+  const content = readContextFile(projectPath, 'change-log.md');
+  assert.ok(content.startsWith('# Change Log\n'));
+  assert.ok(content.includes('- Completed: healed.'));
+  assert.ok(content.includes('stray content, no heading'));
+});
+
+test('writeProjectState is latest-write-wins with revision metadata', () => {
+  const { projectPath, workspace } = makeProject('state');
+  store.ensureProjectContext(workspace);
+
+  const first = store.writeProjectState(projectPath, '# Project State\n\nDraft.');
+  const second = store.writeProjectState(projectPath, '# Project State\n\nFinal.');
+
+  assert.equal(readContextFile(projectPath, 'project-state.md'), '# Project State\n\nFinal.\n');
+  assert.notEqual(
+    first.record.files.projectState.revision,
+    second.record.files.projectState.revision,
+  );
+  assert.notEqual(first.record.contextRevision, second.record.contextRevision);
+});
+
+test('reconcile is idempotent and catches out-of-band edits', () => {
+  const { projectPath, workspace } = makeProject('reconcile');
+  store.ensureProjectContext(workspace);
+  store.appendChangeLog(projectPath, '- Completed: baseline.');
+
+  const before = currentSeq();
+  store.reconcileProjectContext(projectPath);
+  assert.equal(currentSeq(), before, 'unchanged disk must not emit events');
+
+  fs.appendFileSync(path.join(projectPath, '.amalgm/context/project-state.md'), '\nEdited in VS Code.\n');
+  store.notifyProjectContextPathChanged(path.join(projectPath, '.amalgm/context/project-state.md'), 'fs:write');
+
+  const events = listEventsAfter(before).filter((event) => event.resource === 'project_context');
+  assert.equal(events.length, 1);
+  assert.ok(events[0].value.prompt.projectState.includes('Edited in VS Code.'));
+});
+
+test('snapshot resource lists project contexts', () => {
+  const { workspace } = makeProject('snapshot');
+  store.ensureProjectContext(workspace);
+  const snapshot = require('../state/snapshot').buildSnapshot('project_context');
+  assert.ok(Array.isArray(snapshot.resources.project_context));
+  assert.ok(snapshot.resources.project_context.some((row) => row.projectId === workspace.id));
+});
+
+test('change-log window cuts on entry boundaries', () => {
+  const stamp = '## 2026-06-09T10:00:00-07:00 [America/Los_Angeles]';
+  let content = '# Change Log\n';
+  for (let i = 0; i < 5; i += 1) {
+    content = insertChangeLogEntry(content, `${stamp}\n\n- Entry ${i} ${'x'.repeat(50)}`);
+  }
+  const windowed = changeLogRecentWindow(content, 150);
+  assert.ok(windowed.startsWith('## '), 'window starts at an entry boundary');
+  assert.ok(windowed.includes('[older entries truncated]'));
+  // Never a dangling half-entry: every kept chunk begins with its heading.
+  for (const chunk of windowed.split('\n\n## ')) {
+    assert.ok(!chunk.startsWith('- Entry') || chunk.includes('##') === false);
+  }
+});
+
+test('changeLogEntriesSince returns only newer entries', () => {
+  let content = '# Change Log\n';
+  content = insertChangeLogEntry(content, '## 2026-06-09T10:00:00-07:00 [America/Los_Angeles]\n\n- old');
+  content = insertChangeLogEntry(content, '## 2026-06-09T11:00:00-07:00 [America/Los_Angeles]\n\n- new');
+  const since = changeLogEntriesSince(content, Date.parse('2026-06-09T10:30:00-07:00'));
+  assert.ok(since.includes('- new'));
+  assert.ok(!since.includes('- old'));
+  assert.equal(changeLogEntriesSince(content, Date.parse('2026-06-09T12:00:00-07:00')), '');
+});
+
+test('helper edge cases: sanitize, latest entry, timestamps', () => {
+  assert.equal(sanitizeChangeLogBody('## 2026-01-01T00:00:00Z [UTC]\n\n- body'), '- body');
+  assert.equal(sanitizeChangeLogBody('### Sub-heading stays\n- body'), '### Sub-heading stays\n- body');
+  const latest = latestChangeLogEntry('# Change Log\n\n## 2026-06-09T10:00:00-07:00 [America/Los_Angeles]\n\n- x');
+  assert.equal(latest.iso, '2026-06-09T10:00:00-07:00');
+  assert.equal(latest.ms, Date.parse('2026-06-09T10:00:00-07:00'));
+  const stamp = localTimestamp(new Date('2026-06-09T12:34:56-07:00'));
+  assert.match(stamp.iso, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2}$/);
+  assert.ok(stamp.timeZone.length > 0);
+});
+
+test('fresh threads get the full prompt block; resumed threads get deltas', async () => {
+  const { projectPath, workspace } = makeProject('prompt');
+  store.ensureProjectContext(workspace);
+  store.appendChangeLog(projectPath, '- Completed: baseline work.');
+  store.writeProjectState(projectPath, '# Project State\n\nBaseline state.');
+
+  const fresh = { sessionId: 'sess-prompt', cwd: projectPath, providerSessionId: null };
+  const block = prompt.projectContextPromptBlock(fresh);
+  assert.ok(block.includes('<project_context>'));
+  assert.ok(block.includes('Baseline state.'));
+  assert.ok(block.includes('baseline work.'));
+  assert.ok(block.includes('toolbox__memories_append_change_log'));
+  // Empty instructions are omitted entirely.
+  assert.ok(!block.includes('<project_instructions'));
+
+  const resumed = { sessionId: 'sess-prompt', cwd: projectPath, providerSessionId: 'prov-1' };
+  assert.equal(prompt.projectContextPromptBlock(resumed), '', 'resumed threads skip the system block');
+  assert.equal(prompt.projectContextTurnUpdateBlock(resumed), '', 'no changes -> no update');
+
+  // Same-second append must still surface (second-resolution timestamps).
+  store.appendChangeLog(projectPath, '- Completed: same-second follow-up.');
+  const update = prompt.projectContextTurnUpdateBlock(resumed);
+  assert.ok(update.includes('<project_context_update>'));
+  assert.ok(update.includes('same-second follow-up.'));
+  assert.ok(!update.includes('Baseline state.'), 'unchanged state stays out of the delta');
+  assert.equal(prompt.projectContextTurnUpdateBlock(resumed), '', 'update settles');
+
+  // State rewrite -> full new state in the delta.
+  store.writeProjectState(projectPath, '# Project State\n\nNew state.');
+  const stateUpdate = prompt.projectContextTurnUpdateBlock(resumed);
+  assert.ok(stateUpdate.includes('New state.'));
+  assert.ok(!stateUpdate.includes('new_change_log_entries'));
+
+  // A session with no seen-state (predates the feature) gets the full context once.
+  const legacy = { sessionId: 'sess-legacy', cwd: projectPath, providerSessionId: 'prov-2' };
+  const legacyUpdate = prompt.projectContextTurnUpdateBlock(legacy);
+  assert.ok(legacyUpdate.includes('project_memory_protocol'));
+
+  // Outside any registered project -> nothing.
+  assert.equal(
+    prompt.projectContextPromptBlock({ sessionId: 's', cwd: path.join(tempRoot, 'unregistered') }),
+    '',
+  );
+});
+
+test('memories tools resolve the session project and enforce registration', async () => {
+  const { projectPath, workspace } = makeProject('tools');
+  store.ensureProjectContext(workspace);
+  const tools = require('../project-context/tools');
+  const byName = Object.fromEntries(tools.map((tool) => [tool.name, tool]));
+  const context = { callerSessionId: 'sess-tools', sessionMetadata: { cwd: projectPath } };
+
+  const appended = await byName.append_change_log.handler({ body: '- Completed: via tool.' }, context);
+  assert.ok(!appended.isError);
+  assert.ok(readContextFile(projectPath, 'change-log.md').includes('via tool.'));
+
+  const wrote = await byName.write_project_state.handler({ content: '# Project State\n\nTool state.' }, context);
+  assert.ok(!wrote.isError);
+
+  const read = await byName.read_project_context.handler({}, context);
+  assert.ok(read.content[0].text.includes('Tool state.'));
+
+  const missing = await byName.append_change_log.handler({ body: '- x' }, { callerSessionId: 'no-cwd' });
+  assert.ok(missing.isError);
+  assert.match(missing.content[0].text, /No registered Amalgm project/);
+});
+
+test('system scope: instructions-only record, guarded writes, canonical save path', () => {
+  const systemContextDir = path.join(process.env.AMALGM_DIR, 'context');
+  const systemInstructionsPath = path.join(systemContextDir, 'instructions.md');
+
+  // The boot pass owns file creation for the system scope.
+  store.startProjectContextService();
+
+  const records = store.listProjectContexts();
+  const system = records.find((record) => record.kind === 'system');
+  assert.ok(system, 'system row present');
+  assert.equal(records[0].kind, 'system', 'system row sorts first');
+  assert.equal(system.id, 'system');
+  assert.equal(system.name, 'Amalgm System');
+  assert.equal(system.paths.instructions, systemInstructionsPath);
+  assert.equal(system.paths.changeLog, undefined, 'system has no change log');
+  assert.equal(system.files.projectState, undefined, 'system has no project state');
+  assert.ok(fs.existsSync(systemInstructionsPath), 'boot/list ensured the file');
+  assert.deepEqual(
+    fs.readdirSync(systemContextDir).filter((name) => name.endsWith('.md')).sort(),
+    ['instructions.md'],
+    'only instructions.md is created for the system scope',
+  );
+
+  // The UI editor saves by file path — it must resolve to the system scope.
+  const before = currentSeq();
+  const written = store.writeInstructions(systemInstructionsPath, '# Instructions\n\nAlways be definitive.');
+  assert.equal(written.project.id, 'system');
+  const events = listEventsAfter(before).filter((event) => event.resource === 'project_context');
+  assert.equal(events.length, 1);
+  assert.equal(events[0].id, 'system');
+  assert.ok(events[0].value.prompt.instructions.includes('Always be definitive.'));
+
+  // System scope rejects per-project docs.
+  assert.throws(() => store.appendChangeLog(systemInstructionsPath, '- x'), /instructions only/);
+  assert.throws(() => store.writeProjectState(systemContextDir, '# Project State'), /instructions only/);
+});
+
+test('system instructions prompt block reads the canonical file', () => {
+  const { systemInstructionsBlock, systemInstructionsPath } = require('../../chat-core/tooling/system-instructions');
+  const filePath = systemInstructionsPath();
+
+  fs.writeFileSync(filePath, '# Instructions\n\nNo instructions for Amalgm System yet.\n');
+  assert.equal(systemInstructionsBlock(), '', 'legacy placeholder counts as empty');
+
+  fs.writeFileSync(filePath, '# Instructions\n\nPrefer pnpm everywhere.\n');
+  const block = systemInstructionsBlock();
+  assert.ok(block.includes('<system_instructions'));
+  assert.ok(block.includes('Prefer pnpm everywhere.'));
+
+  fs.writeFileSync(filePath, '# Instructions\n');
+  assert.equal(systemInstructionsBlock(), '', 'blank doc injects nothing');
+});
+
+test('workspace removal drops the project_context row', () => {
+  const { workspace } = makeProject('remove');
+  store.ensureProjectContext(workspace);
+  assert.ok(store.getProjectContext(workspace.path, { reconcile: false }));
+  store.removeProjectContext(workspace.id, { source: 'test' });
+  assert.equal(store.getProjectContext(workspace.path, { reconcile: false }), null);
+});
+
+test('watcher reconciles direct disk edits', async () => {
+  const { projectPath, workspace } = makeProject('watch');
+  store.ensureProjectContext(workspace);
+  const before = store.getProjectContext(projectPath, { reconcile: false }).contextRevision;
+
+  fs.writeFileSync(
+    path.join(projectPath, '.amalgm/context/project-state.md'),
+    '# Project State\n\nWatched edit.\n',
+  );
+
+  // fs.watch + 200ms debounce; poll the row instead of guessing exact timing.
+  const deadline = Date.now() + 3000;
+  let row = null;
+  while (Date.now() < deadline) {
+    row = store.getProjectContext(projectPath, { reconcile: false });
+    if (row && row.contextRevision !== before) break;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  assert.ok(row, 'row exists');
+  assert.notEqual(row.contextRevision, before, 'watcher updated the row');
+  assert.ok(row.prompt.projectState.includes('Watched edit.'));
+});

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

@@ -17,12 +17,12 @@ test('system toolbox catalog exposes first-party default tools', () => {
   assert.equal(catalog.tools.browser.origin, 'system');
   assert.equal(catalog.tools.browser.policy.firstParty, true);
   assert.equal(
-    catalog.toolActions['browser.browser_navigate'].sourceAction.mcpToolName,
-    'toolbox__browser_browser_navigate',
+    catalog.toolActions['browser.browser_open'].sourceAction.mcpToolName,
+    'toolbox__browser_browser_open',
   );
   assert.equal(
-    catalog.toolActions['browser.browser_navigate'].sourceAction.handlerName,
-    'browser_navigate',
+    catalog.toolActions['browser.browser_open'].sourceAction.handlerName,
+    'browser_open',
   );
   assert.equal(
     catalog.toolActions['notifications.notify_user'].sourceAction.mcpToolName,
@@ -46,8 +46,8 @@ test('system toolbox catalog merge preserves persisted records', () => {
       },
     },
     toolActions: {
-      'browser.browser_navigate': {
-        id: 'browser.browser_navigate',
+      'browser.browser_open': {
+        id: 'browser.browser_open',
         toolId: 'browser',
         name: 'persisted_navigate',
       },
@@ -57,7 +57,7 @@ test('system toolbox catalog merge preserves persisted records', () => {
   assert.equal(merged.tools.browser.name, 'Persisted Browser');
   assert.equal(merged.tools['custom.cli'].name, 'Custom CLI');
   assert.equal(
-    merged.toolActions['browser.browser_navigate'].name,
+    merged.toolActions['browser.browser_open'].name,
     'persisted_navigate',
   );
   assert.equal(merged.toolActions['apps.apps_list'].name, 'apps_list');
@@ -72,7 +72,7 @@ test('system toolbox catalog omits legacy aggregate amalgm records', () => {
     },
     toolActions: {
       'amalgm.notify_user': { id: 'amalgm.notify_user', toolId: 'amalgm' },
-      'amalgm.browser.browser_navigate': { id: 'amalgm.browser.browser_navigate', toolId: 'amalgm.browser' },
+      'amalgm.browser.browser_open': { id: 'amalgm.browser.browser_open', toolId: 'amalgm.browser' },
       'custom.cli.run': { id: 'custom.cli.run', toolId: 'custom.cli' },
     },
   });
@@ -80,7 +80,7 @@ test('system toolbox catalog omits legacy aggregate amalgm records', () => {
   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.toolActions['amalgm.browser.browser_open'], undefined);
   assert.equal(filtered.tools['custom.cli'].id, 'custom.cli');
   assert.equal(filtered.toolActions['custom.cli.run'].id, 'custom.cli.run');
 });

package/runtime/scripts/amalgm-mcp/tests/toolbox-service.test.js

@@ -161,7 +161,7 @@ test('toolbox service overlays first-party system catalog entries', () => {
   const service = createToolboxService(createRepository());
   const catalog = service.readCatalog();
   const browser = service.getTool('browser', { includeActions: false });
-  const navigate = service.getAction('browser.browser_navigate');
+  const navigate = service.getAction('browser.browser_open');
 
   assert.equal(catalog.tools.amalgm, undefined);
   assert.equal(catalog.toolActions['amalgm.notify_user'], undefined);
@@ -170,7 +170,7 @@ test('toolbox service overlays first-party system catalog entries', () => {
   assert.equal(catalog.tools.browser.owner, 'amalgm');
   assert.equal(browser.tool.name, 'Browser');
   assert.equal(browser.actions, undefined);
-  assert.equal(navigate.action.sourceAction.mcpToolName, 'toolbox__browser_browser_navigate');
+  assert.equal(navigate.action.sourceAction.mcpToolName, 'toolbox__browser_browser_open');
   assert.equal(service.listTools({ origin: 'system' }).tools.some((tool) => tool.id === 'browser'), true);
 });
 

package/runtime/scripts/amalgm-mcp/toolbox/loadout-context.js

@@ -5,6 +5,7 @@ const { loadoutToolIds } = require('../agent-config/loadout');
 const FIRST_PARTY_TOOL_IDS = new Set([
   'automations',
   'notifications',
+  'memories',
   'agents',
   'apps',
   'browser',

package/runtime/scripts/amalgm-mcp/toolbox/store.js

@@ -16,7 +16,6 @@ const { AMALGM_DIR } = require('../config');
 const { ensureDir, readJson, writeJsonAtomic } = require('../lib/storage');
 const { openLocalDb } = require('../state/db');
 const { insertStateEvent, publishStateEvent } = require('../state/events');
-const activeMemory = require('../../chat-core/tooling/active-memory');
 
 const TOOLBOX_VERSION = 1;
 const TOOLBOX_DIR = path.join(AMALGM_DIR, 'toolbox');
@@ -658,13 +657,6 @@ function upsertTool(input) {
     return inserted;
   })();
   publishCommittedEvents(events);
-  if (tool.origin !== 'system') {
-    activeMemory.ensureConstructMemory({
-      type: 'tool',
-      id: tool.id,
-      name: tool.name,
-    }, { source: 'toolbox:upsert-tool' });
-  }
   return { tool, actions };
 }
 
@@ -741,13 +733,6 @@ function updateTool(input) {
     })];
   })();
   publishCommittedEvents(events);
-  if (tool.origin !== 'system') {
-    activeMemory.ensureConstructMemory({
-      type: 'tool',
-      id: tool.id,
-      name: tool.name,
-    }, { source: 'toolbox:update-tool' });
-  }
   return { tool, actions: toolActionsForTool(toolbox, tool.id) };
 }
 

package/runtime/scripts/amalgm-mcp/toolbox/system-catalog.js

@@ -40,6 +40,8 @@ function systemToolForGroup(group) {
     display: {
       icon: '/assets/images/amalgm_logo.svg',
       description: group.description,
+      ...(group.family ? { family: group.family } : {}),
+      ...(group.capability ? { capability: group.capability } : {}),
     },
     policy: {
       system: true,

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

@@ -8,7 +8,6 @@ const path = require('path');
 const { execFile } = require('child_process');
 const { promisify } = require('util');
 const { AMALGM_DIR, DEFAULT_CWD } = require('../config');
-const activeMemory = require('../../chat-core/tooling/active-memory');
 const {
   listWorkspaces,
   removeWorkspace,
@@ -50,12 +49,14 @@ async function ensureWorkspaceRoot() {
 
 function ensureProjectMemory(workspace, source = 'workspace') {
   if (!workspace) return;
-  activeMemory.ensureConstructMemory({
-    type: 'project',
-    id: workspace.id,
-    name: workspace.name,
-    projectPath: workspace.path,
-  }, { source });
+  // Project memory lives in .amalgm/context/{instructions,change-log,project-state}.md,
+  // owned by the project-context store (row + Local Live event + watcher).
+  try {
+    require('../project-context/store').ensureProjectContext(workspace, { source });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[Workspace] project context setup failed for ${workspace.path}: ${message}`);
+  }
 }
 
 async function uniqueProjectPath(workspaceRoot, requestedName) {
@@ -249,6 +250,9 @@ async function handleProjectDelete(body, sendJson) {
 
   try {
     const workspace = removeWorkspace(identifier, { source: 'workspace:delete' });
+    if (workspace?.id) {
+      require('../project-context/store').removeProjectContext(workspace.id, { source: 'workspace:delete' });
+    }
     sendJson(200, { success: true, workspace });
   } catch (error) {
     sendJson(500, {

package/runtime/scripts/chat-core/adapters/opencode.js

@@ -362,7 +362,7 @@ class OpenCodeAdapter {
             model,
             agent: process.env.CHAT_CORE_OPENCODE_AGENT || 'build',
             system: composeSystemPrompt(contract) || undefined,
-            parts: openCodeParts(input),
+            parts: openCodeParts(input, contract),
           },
         });
     promptPromise.then((result) => {

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

@@ -278,9 +278,17 @@ class ChatCore {
           }));
         }
       } catch (err) {
-        append(errorEvent(err.message, { providerSessionId }));
-        append(done({ providerSessionId, stopReason: 'error' }));
         stopReason = 'error';
+        // Error finalization must never throw: if the raw stream write also
+        // fails (e.g. the turn was aborted or sealed mid-stream), the turn
+        // would skip mark() below and hold a tempstore slot forever, which
+        // blocks runtime idle (and with it auto-update restarts).
+        try {
+          append(errorEvent(err.message, { providerSessionId }));
+          append(done({ providerSessionId, stopReason: 'error' }));
+        } catch (finalizeErr) {
+          console.error('[ChatCore] failed to finalize errored turn stream:', finalizeErr.message);
+        }
       }
       entry.streamEnded = true;
       this.turns.mark(turnId, stopReason === 'error' ? 'error' : stopReason === 'cancelled' ? 'cancelled' : 'complete');
@@ -314,6 +322,12 @@ class ChatCore {
       this.turns.clear(turnId);
       return { providerSessionId, usage, parts: savedParts, stopReason };
     } finally {
+      // Safety net: whatever path exits runTurn, the turn must end in a
+      // terminal state or it permanently occupies a tempstore slot.
+      const current = this.turns.get(turnId);
+      if (current && ['streaming', 'cancelling'].includes(current.status)) {
+        this.turns.mark(turnId, 'error');
+      }
       if (resolveStreamCompleted) resolveStreamCompleted();
       if (resolveFinalized) resolveFinalized();
     }

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

@@ -24,8 +24,24 @@ function normalizeInput(payload) {
   };
 }
 
+// Resumed provider threads cannot change their system prompt without busting
+// the provider's prompt cache, so context freshness rides on the turn instead:
+// when the project context revision moved since this session last saw it, the
+// turn gets a compact update block prepended. Empty in the common case.
+function projectContextTurnUpdate(contract) {
+  try {
+    return require('../amalgm-mcp/project-context/prompt').projectContextTurnUpdateBlock(contract) || '';
+  } catch (error) {
+    const message = error instanceof Error ? error.message.split('\n')[0] : String(error);
+    console.warn('[chat-core] project context turn update failed:', message);
+    return '';
+  }
+}
+
 function promptText(input, contract) {
   const chunks = [];
+  const contextUpdate = projectContextTurnUpdate(contract);
+  if (contextUpdate) chunks.push(contextUpdate);
   if (input.files?.length) {
     chunks.push(`<files>\n${input.files.map((file) => JSON.stringify(file)).join('\n')}\n</files>`);
   }
@@ -33,9 +49,11 @@ function promptText(input, contract) {
   return chunks.filter(Boolean).join('\n\n');
 }
 
-function openCodeParts(input) {
+function openCodeParts(input, contract) {
   const text = input.text || input.parts.map(textFromPart).filter(Boolean).join('\n');
   const out = [];
+  const contextUpdate = projectContextTurnUpdate(contract);
+  if (contextUpdate) out.push({ type: 'text', text: contextUpdate });
   if (text) out.push({ type: 'text', text });
   for (const file of input.files || []) {
     if (file?.path) out.push({ type: 'file', path: file.path });

package/runtime/scripts/chat-core/tool-shape.js

@@ -78,13 +78,15 @@ function toolKind(name = '', input = {}, metadata = {}) {
 function titleFromMcp(tool, input = {}) {
   const name = String(tool || '');
   const action = name.replace(/^browser_/, '');
-  if (name === 'browser_navigate') return input.url ? `Opening ${hostLabel(input.url)}` : 'Opening browser page';
-  if (name === 'browser_tabs_new') return input.url ? `Opening browser tab ${hostLabel(input.url)}` : 'Opening browser tab';
+  if (name === 'browser_open') return input.url ? `Opening ${hostLabel(input.url)}` : 'Opening browser page';
   if (name === 'browser_snapshot') return 'Reading browser page';
   if (name === 'browser_screenshot') return 'Taking browser screenshot';
-  if (name === 'browser_type') return input.text ? `Typing "${compactText(input.text, 60)}"` : 'Typing in browser';
+  if (name === 'browser_fill') return input.text ? `Typing "${compactText(input.text, 60)}"` : 'Typing in browser';
   if (name === 'browser_click') return 'Clicking in browser';
-  if (name === 'browser_wait_for_load_state') return 'Waiting for page load';
+  if (name === 'browser_wait') return 'Waiting for page';
+  if (name === 'browser_cli') return Array.isArray(input.args) ? `Browser: ${compactText(input.args.join(' '), 60)}` : 'Running browser command';
+  if (name === 'record_start') return 'Starting browser recording';
+  if (name === 'record_stop') return 'Saving browser recording';
   if (name === 'apps_register') return input.name ? `Registering app ${compactText(input.name, 60)}` : 'Registering app';
   if (name === 'apps_start') return 'Starting app';
   if (name === 'apps_stop') return 'Stopping app';

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

@@ -0,0 +1,51 @@
+'use strict';
+
+/**
+ * System-level instructions — the one machine-wide context doc.
+ *
+ * `<AMALGM_DIR>/context/instructions.md` is user-authored and applies to every
+ * session on this computer. Project memory (instructions, change log, project
+ * state) is handled separately by the project-context block. The legacy
+ * active/passive memory blocks are gone — this and project context are the
+ * definitive memory surfaces.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { AMALGM_DIR } = require('../../amalgm-mcp/config');
+const { cappedDocContent, isEmptyContextDoc } = require('../../amalgm-mcp/project-context/paths');
+
+function systemInstructionsPath() {
+  return path.join(path.resolve(AMALGM_DIR), 'context', 'instructions.md');
+}
+
+function escapeAttribute(value) {
+  return String(value || '')
+    .replace(/&/g, '&amp;')
+    .replace(/"/g, '&quot;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+function systemInstructionsBlock() {
+  const filePath = systemInstructionsPath();
+  let content = '';
+  try {
+    content = fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return '';
+  }
+  if (isEmptyContextDoc(content)) return '';
+  return [
+    `<system_instructions path="${escapeAttribute(filePath)}">`,
+    'These are user-authored instructions that apply to every session on this computer. Current user requests and higher-priority system/developer instructions win on conflict.',
+    '',
+    cappedDocContent(content),
+    '</system_instructions>',
+  ].join('\n');
+}
+
+module.exports = {
+  systemInstructionsBlock,
+  systemInstructionsPath,
+};