amalgm 0.1.36 → 0.1.37

package/package.json

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

package/runtime/scripts/amalgm-mcp/artifacts/supervisor.js

@@ -9,6 +9,7 @@ const fs = require('fs');
 const path = require('path');
 const { spawn } = require('child_process');
 const { DEFAULT_CWD } = require('../config');
+const activeMemory = require('../../chat-core/tooling/active-memory');
 const { syncArtifactRoutesToGateway } = require('./advertise');
 const {
   allocatePort,
@@ -319,10 +320,23 @@ async function registerArtifact(input) {
   const data = loadArtifacts();
   data.artifacts.push(artifact);
   saveArtifacts(data);
+  activeMemory.ensureConstructMemory({
+    type: 'artifact',
+    id: artifact.id,
+    name: artifact.name,
+    projectPath: artifact.cwd,
+  }, { source: 'artifact:register' });
 
   if (artifact.buildCommand) await runBuild(artifact);
   await startArtifact(artifact.id);
-  return updateArtifactMeta(artifact.id, { lastDeployedAt: new Date().toISOString() });
+  const deployed = updateArtifactMeta(artifact.id, { lastDeployedAt: new Date().toISOString() });
+  activeMemory.ensureConstructMemory({
+    type: 'artifact',
+    id: deployed.id,
+    name: deployed.name,
+    projectPath: deployed.cwd,
+  }, { source: 'artifact:deploy' });
+  return deployed;
 }
 
 async function redeployArtifact(artifactId, updates = {}) {
@@ -343,6 +357,12 @@ async function redeployArtifact(artifactId, updates = {}) {
   if (updates.keep_alive !== undefined) patch.keepAlive = updates.keep_alive !== false;
   if (updates.autostart !== undefined) patch.autostart = updates.autostart !== false;
   if (Object.keys(patch).length > 0) artifact = updateArtifactMeta(artifactId, patch);
+  activeMemory.ensureConstructMemory({
+    type: 'artifact',
+    id: artifact.id,
+    name: artifact.name,
+    projectPath: artifact.cwd,
+  }, { source: 'artifact:update' });
 
   if (!artifact.startCommand) throw new Error('startCommand is required');
   if (!fs.existsSync(artifact.cwd)) throw new Error(`cwd does not exist: ${artifact.cwd}`);
@@ -350,7 +370,14 @@ async function redeployArtifact(artifactId, updates = {}) {
   if (artifact.buildCommand) await runBuild(artifact);
   await stopArtifact(artifactId, { desiredState: 'running' });
   await startArtifact(artifactId);
-  return updateArtifactMeta(artifactId, { lastDeployedAt: new Date().toISOString() });
+  const deployed = updateArtifactMeta(artifactId, { lastDeployedAt: new Date().toISOString() });
+  activeMemory.ensureConstructMemory({
+    type: 'artifact',
+    id: deployed.id,
+    name: deployed.name,
+    projectPath: deployed.cwd,
+  }, { source: 'artifact:deploy' });
+  return deployed;
 }
 
 function cryptoRandomId() {

package/runtime/scripts/amalgm-mcp/events/executor.js

@@ -139,6 +139,12 @@ async function executeArtifactEvent(artifactOrTrigger, eventDef, payload, opts =
       cwd,
       authMethod: legacy.authMethod || authMethod,
       mcpServers,
+      origin: {
+        type: 'event',
+        id: triggerId || artifactOrTrigger.id,
+        name: eventDef.name,
+        projectPath: projectPath || null,
+      },
       automated: true,
     });
 

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

@@ -17,6 +17,7 @@ const {
   hydrateModelPreferences,
 } = require('../lib/prefs');
 const credentialAdapter = require('../../credential-adapter');
+const activeMemory = require('../../chat-core/tooling/active-memory');
 
 function resolveEventHarness(harness, chatInput) {
   return (
@@ -134,6 +135,12 @@ async function handleCreate(body, sendJson) {
   });
   data.triggers.push(trigger);
   saveEventTriggers(data);
+  activeMemory.ensureConstructMemory({
+    type: 'event',
+    id: trigger.id,
+    name: trigger.name,
+    projectPath: trigger.projectPath,
+  }, { source: 'event:create' });
   console.log(`[AmalgmMCP:Events] Created event trigger: ${name} (${source}:${event})`);
   sendJson(200, { ok: true, trigger });
 }
@@ -182,6 +189,12 @@ async function handleUpdate(body, sendJson) {
   }
   Object.assign(trigger, normalizeEventTriggerRecord(trigger, trigger));
   saveEventTriggers(data);
+  activeMemory.ensureConstructMemory({
+    type: 'event',
+    id: trigger.id,
+    name: trigger.name,
+    projectPath: trigger.projectPath,
+  }, { source: 'event:update' });
   console.log(`[AmalgmMCP:Events] Updated trigger: ${trigger_id}`);
   sendJson(200, { ok: true, trigger });
 }

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

@@ -20,6 +20,7 @@ const {
   hydrateModelPreferences,
 } = require('../lib/prefs');
 const credentialAdapter = require('../../credential-adapter');
+const activeMemory = require('../../chat-core/tooling/active-memory');
 
 function resolveEventHarness(harness, chatInput) {
   return (
@@ -159,6 +160,12 @@ module.exports = [
       });
       data.triggers.push(trigger);
       saveEventTriggers(data);
+      activeMemory.ensureConstructMemory({
+        type: 'event',
+        id: trigger.id,
+        name: trigger.name,
+        projectPath: trigger.projectPath,
+      }, { source: 'event:create' });
       console.log(`[AmalgmMCP:Events] Created trigger via MCP: ${name} (${source}:${event})`);
       return textResult(
         `Event trigger created.\n\nWebhook URL: ${trigger.webhookUrl}\nSecret: ${trigger.secret}\n\nConfigure the sender to either sign each request with this secret or send it directly in a secret header, then POST JSON to the webhook URL.\n\n${JSON.stringify(trigger, null, 2)}`,
@@ -281,6 +288,12 @@ module.exports = [
       Object.assign(trigger, normalizeEventTriggerRecord(trigger, trigger));
 
       saveEventTriggers(data);
+      activeMemory.ensureConstructMemory({
+        type: 'event',
+        id: trigger.id,
+        name: trigger.name,
+        projectPath: trigger.projectPath,
+      }, { source: 'event:update' });
       console.log(`[AmalgmMCP:Events] Updated trigger via MCP: ${trigger_id}`);
       return textResult(`Trigger updated.\n\n${JSON.stringify(trigger, null, 2)}`);
     },

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

@@ -6,6 +6,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const activeMemory = require('../../chat-core/tooling/active-memory');
 
 const TEXT_EXTENSIONS = new Set([
   'txt', 'md', 'json', 'js', 'ts', 'tsx', 'jsx', 'py', 'html', 'css',
@@ -236,6 +237,7 @@ async function handleWrite(body, sendJson) {
 
     await fs.promises.mkdir(path.dirname(targetPath), { recursive: true });
     await fs.promises.writeFile(targetPath, data);
+    activeMemory.notifyMemoryPathChanged(targetPath, 'fs:write');
 
     sendJson(200, { success: true, path: targetPath });
   } catch (error) {
@@ -248,6 +250,7 @@ async function handleDelete(body, sendJson) {
   try {
     const targetPath = await resolveSafePath(body.path);
     await fs.promises.rm(targetPath, { recursive: true, force: true });
+    activeMemory.notifyMemoryPathChanged(targetPath, 'fs:delete');
     sendJson(200, { success: true, path: targetPath });
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Failed to delete';
@@ -259,6 +262,7 @@ async function handleMkdir(body, sendJson) {
   try {
     const targetPath = await resolveSafePath(body.path, { forCreate: true });
     await fs.promises.mkdir(targetPath, { recursive: true, mode: 0o755 });
+    activeMemory.notifyMemoryPathChanged(targetPath, 'fs:mkdir');
     sendJson(200, { success: true, path: targetPath });
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Failed to create folder';
@@ -272,6 +276,8 @@ async function handleRename(body, sendJson) {
     const newPath = await resolveSafePath(body.newPath, { forCreate: true });
     await fs.promises.mkdir(path.dirname(newPath), { recursive: true });
     await fs.promises.rename(oldPath, newPath);
+    activeMemory.notifyMemoryPathChanged(oldPath, 'fs:rename');
+    activeMemory.notifyMemoryPathChanged(newPath, 'fs:rename');
     sendJson(200, { success: true, oldPath, newPath });
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Failed to rename';

package/runtime/scripts/amalgm-mcp/server/http.js

@@ -195,6 +195,15 @@ function createServer() {
       if (req.url === '/workspace/projects' && req.method === 'GET') {
         return workspaceRest.handleProjects(sendJson);
       }
+      if (req.url === '/workspace/projects' && req.method === 'POST') {
+        return workspaceRest.handleProjectRegister(await readJsonBody(), sendJson);
+      }
+      if (req.url === '/workspace/projects' && req.method === 'PATCH') {
+        return workspaceRest.handleProjectUpdate(await readJsonBody(), sendJson);
+      }
+      if (req.url === '/workspace/projects' && req.method === 'DELETE') {
+        return workspaceRest.handleProjectDelete(await readJsonBody(), sendJson);
+      }
       if (req.url === '/workspace/import' && req.method === 'POST') {
         return workspaceRest.handleImport(await readJsonBody(), sendJson);
       }

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

@@ -104,6 +104,31 @@ function migrate(database = openLocalDb()) {
 
     CREATE INDEX IF NOT EXISTS agents_builtin_idx
       ON agents(builtin);
+
+    CREATE TABLE IF NOT EXISTS workspaces (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      uri TEXT NOT NULL UNIQUE,
+      path TEXT,
+      location_type TEXT NOT NULL,
+      computer_id TEXT,
+      source TEXT NOT NULL,
+      managed INTEGER NOT NULL DEFAULT 0,
+      status TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      workspace_json TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS workspaces_path_idx
+      ON workspaces(path);
+
+    CREATE INDEX IF NOT EXISTS workspaces_computer_id_idx
+      ON workspaces(computer_id);
+
+    CREATE INDEX IF NOT EXISTS workspaces_location_type_idx
+      ON workspaces(location_type);
+
   `);
   migrateLegacyToolboxTables(database);
   removeInheritedHarnessTools(database);

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

@@ -10,6 +10,9 @@ const DEFAULT_RESOURCES = [
   'toolbox',
   'tools',
   'tool_actions',
+  'projects',
+  'workspaces',
+  'memories',
 ];
 
 function normalizeResources(resources) {
@@ -45,6 +48,13 @@ function readResource(resource, cache) {
       cache.toolbox ||= require('../toolbox/store').readToolbox();
       return cache.toolbox.toolActions;
     }
+    case 'projects':
+    case 'workspaces': {
+      const workspaceStore = require('../workspace/store');
+      return workspaceStore.listWorkspaces();
+    }
+    case 'memories':
+      return require('../../chat-core/tooling/active-memory').collectActiveMemoryFiles();
     default:
       return undefined;
   }

package/runtime/scripts/amalgm-mcp/tasks/executor.js

@@ -106,6 +106,7 @@ async function executeTask(task) {
   const runId = crypto.randomUUID();
   const startedAt = new Date().toISOString();
   const { harness, chatInput, legacy, modelSelection } = resolveTaskRequest(task);
+  const projectPath = legacy.cwd || task.projectPath || null;
   const mcpServers = await buildLocalMcpServerConfigs(legacy.mcpAppIds || []);
 
   console.log(`[AmalgmMCP:Exec] Starting task ${task.id} (${task.name}), run ${runId}`);
@@ -127,7 +128,7 @@ async function executeTask(task) {
         title: 'New Chat',
         origin: 'task',
         origin_id: task.id,
-        project_path: legacy.cwd || task.projectPath || null,
+        project_path: projectPath,
         status: 'in-progress',
         metadata: { taskRunId: runId, automated: true, originName: task.name },
       });
@@ -156,10 +157,15 @@ async function executeTask(task) {
         modelId: modelSelection.modelId || legacy.modelId || null,
         cliModel: modelSelection.cliModel || null,
         ...(modelSelection.reasoningEffort ? { reasoningEffort: modelSelection.reasoningEffort } : {}),
-        cwd: legacy.cwd || DEFAULT_CWD,
+        cwd: projectPath || DEFAULT_CWD,
         authMethod: legacy.authMethod || null,
         mcpServers,
-        taskId: task.id,
+        origin: {
+          type: 'task',
+          id: task.id,
+          name: task.name,
+          projectPath,
+        },
         automated: true,
       },
       abortController.signal,

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

@@ -23,6 +23,7 @@ const {
   hydrateModelPreferences,
 } = require('../lib/prefs');
 const credentialAdapter = require('../../credential-adapter');
+const activeMemory = require('../../chat-core/tooling/active-memory');
 
 function resolveTaskHarness(harness, chatInput) {
   const candidate =
@@ -153,6 +154,12 @@ module.exports = [
       const data = loadTasks();
       data.tasks.push(task);
       saveTasks(data);
+      activeMemory.ensureConstructMemory({
+        type: 'task',
+        id: task.id,
+        name: task.name,
+        projectPath: task.projectPath,
+      }, { source: 'task:create' });
       console.log(`[AmalgmMCP] Created task: ${task.id} (${task.name})`);
       return textResult(`Task created successfully.\n\n${JSON.stringify(task, null, 2)}`);
     },
@@ -309,6 +316,12 @@ module.exports = [
       Object.assign(task, normalizedTask);
 
       saveTasks(data);
+      activeMemory.ensureConstructMemory({
+        type: 'task',
+        id: task.id,
+        name: task.name,
+        projectPath: task.projectPath,
+      }, { source: 'task:update' });
       console.log(`[AmalgmMCP] Updated task: ${task.id} (${task.name})`);
       return textResult(`Task updated.\n\n${JSON.stringify(task, null, 2)}`);
     },

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

@@ -0,0 +1,84 @@
+'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-workspaces-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 {
+  listWorkspaces,
+  removeWorkspace,
+  renameWorkspace,
+  upsertWorkspace,
+  workspaceUriForPath,
+} = require('../workspace/store');
+
+test.after(() => {
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+test('workspace rows store a stable computer URI and local path', () => {
+  const projectPath = path.join(tempRoot, 'existing-project');
+  fs.mkdirSync(projectPath, { recursive: true });
+
+  const workspace = upsertWorkspace({
+    path: projectPath,
+    name: 'Existing project',
+    source: 'computer',
+  });
+
+  assert.equal(workspace.path, projectPath);
+  assert.equal(workspace.computerId, 'computer-test');
+  assert.equal(workspace.managed, false);
+  assert.equal(workspace.uri, workspaceUriForPath(projectPath, 'computer-test'));
+  assert.equal(listWorkspaces().length, 1);
+});
+
+test('workspace rename and remove publish durable row changes', () => {
+  const projectPath = path.join(tempRoot, 'managed-project');
+  fs.mkdirSync(projectPath, { recursive: true });
+
+  const workspace = upsertWorkspace({
+    path: projectPath,
+    name: 'Managed project',
+    source: 'managed',
+    managed: true,
+  });
+
+  const renamed = renameWorkspace(workspace.id, 'Renamed project');
+  assert.equal(renamed.name, 'Renamed project');
+  assert.equal(listWorkspaces().some((item) => item.name === 'Renamed project'), true);
+
+  const removed = removeWorkspace(workspace.id);
+  assert.equal(removed.id, workspace.id);
+  assert.equal(listWorkspaces().some((item) => item.id === workspace.id), false);
+});
+
+test('workspace registry does not auto-discover managed folders', () => {
+  const workspaceRoot = path.join(tempRoot, 'workspace-root');
+  const projectPath = path.join(workspaceRoot, 'folder-on-disk');
+  fs.mkdirSync(projectPath, { recursive: true });
+
+  assert.equal(listWorkspaces().some((item) => item.path === projectPath), false);
+
+  const workspace = upsertWorkspace({
+    path: projectPath,
+    name: 'Folder on disk',
+    source: 'managed',
+    managed: true,
+  }, { workspaceRoot });
+
+  assert.equal(listWorkspaces().some((item) => item.id === workspace.id), true);
+  removeWorkspace(workspace.id);
+
+  assert.equal(fs.existsSync(projectPath), true);
+  assert.equal(listWorkspaces().some((item) => item.path === projectPath), false);
+});

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

@@ -16,6 +16,7 @@ const { AMALGM_DIR, PORT } = 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');
@@ -726,6 +727,13 @@ 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 };
 }
 
@@ -802,6 +810,13 @@ 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) };
 }