amalgm 0.1.35 → 0.1.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.35",
+  "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;
   }
@@ -52,20 +62,38 @@ function readResource(resource, cache) {
 
 function buildSnapshot(resourcesInput) {
   const resources = normalizeResources(resourcesInput);
-  const beforeSeq = currentSeq();
-  const cache = {};
-  const data = {};
+  let lastUnstable = null;
+
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const beforeSeq = currentSeq();
+    const cache = {};
+    const data = {};
+
+    for (const resource of resources) {
+      const value = readResource(resource, cache);
+      if (value !== undefined) data[resource] = value;
+    }
+
+    const afterSeq = currentSeq();
+    if (beforeSeq === afterSeq) {
+      return {
+        seq: afterSeq,
+        stable: true,
+        resources: data,
+      };
+    }
 
-  for (const resource of resources) {
-    const value = readResource(resource, cache);
-    if (value !== undefined) data[resource] = value;
+    lastUnstable = {
+      seq: beforeSeq,
+      stable: false,
+      resources: data,
+    };
   }
 
-  const afterSeq = currentSeq();
-  return {
-    seq: afterSeq,
-    stable: beforeSeq === afterSeq,
-    resources: data,
+  return lastUnstable || {
+    seq: currentSeq(),
+    stable: true,
+    resources: {},
   };
 }
 

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/scheduler.js

@@ -57,7 +57,9 @@ function isTaskDue(task, now) {
         currentDate: now,
         tz: schedule.tz || 'UTC',
       });
-      const prev = interval.prev().toDate();
+      const prev = interval.includesDate(now)
+        ? new Date(Math.floor(now.getTime() / 1000) * 1000)
+        : interval.prev().toDate();
       const createdAt = validDate(task.createdAt);
       const lastRunAt = validDate(task.lastRunAt);
 
@@ -68,8 +70,9 @@ function isTaskDue(task, now) {
     }
   }
   if (schedule.kind === 'interval') {
-    if (!task.lastRunAt) return true;
-    return now - new Date(task.lastRunAt) >= schedule.ms;
+    const baseline = validDate(task.lastRunAt) || validDate(task.createdAt);
+    if (!baseline) return true;
+    return now - baseline >= schedule.ms;
   }
   return false;
 }

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/events-matcher.test.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  computeSignature,
+  extractSignature,
+  matchBySignature,
+} = require('../events/matcher');
+
+function trigger(overrides = {}) {
+  return {
+    id: 'trigger-1',
+    enabled: true,
+    secret: 'super-secret',
+    ...overrides,
+  };
+}
+
+test('event matcher accepts generic HMAC webhook signatures', () => {
+  const rawBody = JSON.stringify({ ok: true });
+  const signature = extractSignature({
+    'x-webhook-signature': computeSignature('super-secret', rawBody),
+  });
+
+  assert.equal(matchBySignature([trigger()], signature, rawBody)?.id, 'trigger-1');
+});
+
+test('event matcher accepts bearer token webhook secrets', () => {
+  const signature = extractSignature({
+    authorization: 'Bearer super-secret',
+  });
+
+  assert.equal(matchBySignature([trigger()], signature, '{}')?.id, 'trigger-1');
+});
+
+test('event matcher rejects disabled triggers and wrong secrets', () => {
+  const rawBody = JSON.stringify({ ok: true });
+  const signature = extractSignature({
+    'x-webhook-signature': computeSignature('wrong-secret', rawBody),
+  });
+
+  assert.equal(matchBySignature([trigger(), trigger({ id: 'disabled', enabled: false })], signature, rawBody), null);
+});

package/runtime/scripts/amalgm-mcp/tests/local-live-snapshot.test.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+let seq = 0;
+const eventsPath = require.resolve('../state/events');
+require.cache[eventsPath] = {
+  id: eventsPath,
+  filename: eventsPath,
+  loaded: true,
+  exports: {
+    currentSeq: () => seq,
+  },
+};
+
+const taskStore = require('../tasks/store');
+const { buildSnapshot } = require('../state/snapshot');
+
+test.after(() => {
+  taskStore.loadTasks = originalLoadTasks;
+  delete require.cache[eventsPath];
+});
+
+const originalLoadTasks = taskStore.loadTasks;
+
+test('snapshot retries when a state event lands during resource reads', () => {
+  let calls = 0;
+  taskStore.loadTasks = () => {
+    calls += 1;
+    if (calls === 1) {
+      seq = 1;
+      return { version: 1, tasks: [{ id: 'stale-task', name: 'Stale task' }] };
+    }
+    return { version: 1, tasks: [{ id: 'new-task', name: 'New task' }] };
+  };
+
+  const snapshot = buildSnapshot('tasks');
+
+  assert.equal(calls, 2);
+  assert.equal(snapshot.stable, true);
+  assert.equal(snapshot.seq, 1);
+  assert.deepEqual(snapshot.resources.tasks, [{ id: 'new-task', name: 'New task' }]);
+});

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

@@ -0,0 +1,64 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { isTaskDue } = require('../tasks/scheduler');
+
+function baseTask(overrides = {}) {
+  return {
+    id: 'task-1',
+    enabled: true,
+    createdAt: '2026-05-18T10:00:00.000Z',
+    lastRunAt: null,
+    endsAt: null,
+    schedule: { kind: 'once', at: '2026-05-18T10:01:00.000Z' },
+    ...overrides,
+  };
+}
+
+test('interval task waits for the first interval after creation', () => {
+  const task = baseTask({
+    schedule: { kind: 'interval', ms: 60_000 },
+  });
+
+  assert.equal(isTaskDue(task, new Date('2026-05-18T10:00:30.000Z')), false);
+  assert.equal(isTaskDue(task, new Date('2026-05-18T10:01:00.000Z')), true);
+});
+
+test('interval task uses lastRunAt after the first run', () => {
+  const task = baseTask({
+    lastRunAt: '2026-05-18T10:03:00.000Z',
+    schedule: { kind: 'interval', ms: 60_000 },
+  });
+
+  assert.equal(isTaskDue(task, new Date('2026-05-18T10:03:59.000Z')), false);
+  assert.equal(isTaskDue(task, new Date('2026-05-18T10:04:00.000Z')), true);
+});
+
+test('cron task is due at the exact scheduled boundary in its timezone', () => {
+  const task = baseTask({
+    createdAt: '2026-05-18T15:55:00.000Z',
+    schedule: {
+      kind: 'cron',
+      expr: '0 9 * * *',
+      tz: 'America/Los_Angeles',
+    },
+  });
+
+  assert.equal(isTaskDue(task, new Date('2026-05-18T16:00:00.000Z')), true);
+});
+
+test('cron task does not rerun for the same scheduled instant', () => {
+  const task = baseTask({
+    createdAt: '2026-05-18T15:55:00.000Z',
+    lastRunAt: '2026-05-18T16:00:00.000Z',
+    schedule: {
+      kind: 'cron',
+      expr: '0 9 * * *',
+      tz: 'America/Los_Angeles',
+    },
+  });
+
+  assert.equal(isTaskDue(task, new Date('2026-05-18T16:00:30.000Z')), false);
+});

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);
+});