amalgm 0.1.49 → 0.1.50

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

@@ -7,6 +7,8 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const activeMemory = require('../../chat-core/tooling/active-memory');
+const { AMALGM_DIR } = require('../config');
+const { appendStateEvent } = require('../state/events');
 
 const TEXT_EXTENSIONS = new Set([
   'txt', 'md', 'json', 'js', 'ts', 'tsx', 'jsx', 'py', 'html', 'css',
@@ -18,6 +20,14 @@ const TEXT_EXTENSIONS = new Set([
 const IS_LOCAL_MACHINE = process.env.AMALGM_LOCAL_MODE === 'true';
 const CONTAINER_ROOT = process.env.AMALGM_WORKSPACE_ROOT || '/workspace';
 const MAX_READ_BYTES = Number.parseInt(process.env.AMALGM_FS_MAX_READ_BYTES || '', 10) || 25 * 1024 * 1024;
+const FILE_RESOURCE_PREFIX = 'files:';
+const UPLOADS_RESOURCE = 'uploads';
+const UPLOADS_ROOT = path.join(AMALGM_DIR, 'uploads');
+const FS_WATCH_DEBOUNCE_MS = 150;
+
+const fileWatchers = new Map();
+const uploadWatchers = new Map();
+let uploadsPublishTimer = null;
 
 function expandHome(targetPath) {
   if (targetPath === '~') return os.homedir();
@@ -63,11 +73,65 @@ async function existingAllowedRoots() {
   return Array.from(new Set(roots));
 }
 
+function existingAllowedRootsSync() {
+  const roots = [];
+  for (const root of configuredRootPaths()) {
+    try {
+      roots.push(fs.realpathSync(root));
+    } catch {
+      // Ignore configured roots that are not mounted on this computer.
+    }
+  }
+  return Array.from(new Set(roots));
+}
+
 function isWithin(root, target) {
   const relative = path.relative(root, target);
   return relative === '' || (!!relative && !relative.startsWith('..') && !path.isAbsolute(relative));
 }
 
+function comparableRealPathSync(targetPath) {
+  const resolved = path.resolve(targetPath);
+  try {
+    return fs.realpathSync(resolved);
+  } catch {
+    try {
+      const parent = nearestExistingParentSync(path.dirname(resolved));
+      const realParent = fs.realpathSync(parent);
+      return path.join(realParent, path.relative(parent, resolved));
+    } catch {
+      return resolved;
+    }
+  }
+}
+
+function base64UrlEncode(value) {
+  return Buffer.from(String(value), 'utf8')
+    .toString('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/g, '');
+}
+
+function base64UrlDecode(value) {
+  const normalized = String(value || '').replace(/-/g, '+').replace(/_/g, '/');
+  const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, '=');
+  return Buffer.from(padded, 'base64').toString('utf8');
+}
+
+function filesResourceName(dirPath) {
+  return `${FILE_RESOURCE_PREFIX}${base64UrlEncode(path.resolve(expandHome(dirPath)))}`;
+}
+
+function pathFromFilesResource(resource) {
+  if (typeof resource !== 'string' || !resource.startsWith(FILE_RESOURCE_PREFIX)) return null;
+  try {
+    return base64UrlDecode(resource.slice(FILE_RESOURCE_PREFIX.length));
+  } catch {
+    return null;
+  }
+}
+
 function requestPathOrDefault(targetPath) {
   if (typeof targetPath === 'string' && targetPath.trim()) return targetPath;
   return IS_LOCAL_MACHINE ? os.homedir() : CONTAINER_ROOT;
@@ -86,6 +150,19 @@ async function nearestExistingParent(targetPath) {
   return current || path.parse(targetPath).root;
 }
 
+function nearestExistingParentSync(targetPath) {
+  let current = targetPath;
+  while (current && current !== path.dirname(current)) {
+    try {
+      const stats = fs.lstatSync(current);
+      return stats.isDirectory() || stats.isSymbolicLink() ? current : path.dirname(current);
+    } catch {
+      current = path.dirname(current);
+    }
+  }
+  return current || path.parse(targetPath).root;
+}
+
 async function assertContained(realPath) {
   const roots = await existingAllowedRoots();
   if (roots.length === 0) {
@@ -102,6 +179,23 @@ async function assertContained(realPath) {
   }
 }
 
+function assertContainedSync(realPath) {
+  const roots = existingAllowedRootsSync();
+  const comparablePath = comparableRealPathSync(realPath);
+  if (roots.length === 0) {
+    const rootHint = IS_LOCAL_MACHINE ? os.homedir() : CONTAINER_ROOT;
+    throw Object.assign(new Error(`No accessible filesystem roots configured; expected ${rootHint}`), {
+      statusCode: 500,
+    });
+  }
+
+  if (!roots.some((root) => isWithin(root, comparablePath))) {
+    throw Object.assign(new Error('Filesystem path is outside the approved Amalgm computer roots'), {
+      statusCode: 403,
+    });
+  }
+}
+
 async function resolveSafePath(targetPath, options = {}) {
   const { forCreate = false } = options;
   const requested = requestPathOrDefault(targetPath);
@@ -144,6 +238,31 @@ async function resolveSafePath(targetPath, options = {}) {
   return normalized;
 }
 
+function resolveSafePathSync(targetPath) {
+  const requested = requestPathOrDefault(targetPath);
+
+  if (typeof requested !== 'string' || requested.length === 0) {
+    throw Object.assign(new Error('path is required'), { statusCode: 400 });
+  }
+
+  const expanded = expandHome(requested);
+  if (!path.isAbsolute(expanded)) {
+    throw Object.assign(new Error('Path must be absolute or use ~'), { statusCode: 400 });
+  }
+
+  const normalized = path.resolve(expanded);
+  try {
+    const real = fs.realpathSync(normalized);
+    assertContainedSync(real);
+    return normalized;
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      throw Object.assign(new Error('Filesystem path not found'), { statusCode: 404 });
+    }
+    throw error;
+  }
+}
+
 function statusForError(error, fallbackStatus = 500) {
   if (typeof error?.statusCode === 'number') return error.statusCode;
   if (error?.code === 'ENOENT') return 404;
@@ -159,29 +278,211 @@ function classifyFile(targetPath) {
   };
 }
 
-async function handleList(query, sendJson) {
+function directorySnapshot(targetPath) {
+  const entries = fs.readdirSync(targetPath, { withFileTypes: true });
+  const files = entries.map((entry) => {
+    const fullPath = path.join(targetPath, entry.name);
+    const stats = fs.lstatSync(fullPath);
+    return {
+      name: entry.name,
+      isDir: stats.isDirectory(),
+      size: stats.size,
+      modTime: stats.mtime.toISOString(),
+    };
+  });
+
+  files.sort((a, b) => {
+    if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+
+  return { path: targetPath, files };
+}
+
+function closeFileWatcher(dirPath) {
+  const existing = fileWatchers.get(dirPath);
+  if (!existing) return;
+  if (existing.timer) clearTimeout(existing.timer);
   try {
-    const targetPath = await resolveSafePath(query.path);
-    const entries = await fs.promises.readdir(targetPath, { withFileTypes: true });
-    const files = await Promise.all(
-      entries.map(async (entry) => {
-        const fullPath = path.join(targetPath, entry.name);
-        const stats = await fs.promises.lstat(fullPath);
-        return {
+    existing.watcher.close();
+  } catch {}
+  fileWatchers.delete(dirPath);
+}
+
+function scheduleFilesResourcePublish(dirPath, source = 'fs:watch') {
+  const resolved = path.resolve(dirPath);
+  const existing = fileWatchers.get(resolved);
+  if (existing?.timer) clearTimeout(existing.timer);
+
+  const timer = setTimeout(() => {
+    if (existing) existing.timer = null;
+    void publishFilesResourceForPath(resolved, source);
+  }, FS_WATCH_DEBOUNCE_MS);
+  if (typeof timer.unref === 'function') timer.unref();
+  if (existing) existing.timer = timer;
+}
+
+function watchFilesDirectory(dirPath) {
+  const resolved = path.resolve(dirPath);
+  if (fileWatchers.has(resolved)) return;
+
+  try {
+    const watcher = fs.watch(resolved, { persistent: false }, () => {
+      scheduleFilesResourcePublish(resolved, 'fs:watch');
+    });
+    watcher.on('error', () => closeFileWatcher(resolved));
+    if (typeof watcher.unref === 'function') watcher.unref();
+    fileWatchers.set(resolved, { watcher, timer: null });
+  } catch {
+    // Watching is best-effort. Mutations through this API still publish events.
+  }
+}
+
+function buildFilesResource(resourceOrPath, options = {}) {
+  const rawPath = pathFromFilesResource(resourceOrPath) || resourceOrPath;
+  if (!rawPath) return undefined;
+  const targetPath = resolveSafePathSync(rawPath);
+  const snapshot = directorySnapshot(targetPath);
+  if (options.watch !== false) watchFilesDirectory(targetPath);
+  return snapshot;
+}
+
+async function publishFilesResourceForPath(dirPath, source = 'fs') {
+  const resolved = path.resolve(expandHome(dirPath));
+  try {
+    const value = await buildFilesResource(resolved, { watch: true });
+    appendStateEvent({
+      resource: filesResourceName(resolved),
+      op: 'replace',
+      id: resolved,
+      value,
+      source,
+    });
+  } catch {
+    appendStateEvent({
+      resource: filesResourceName(resolved),
+      op: 'replace',
+      id: resolved,
+      value: { path: resolved, files: [], missing: true },
+      source,
+    });
+  }
+}
+
+function isUploadsPath(targetPath) {
+  const resolved = path.resolve(expandHome(targetPath));
+  return isWithin(UPLOADS_ROOT, resolved);
+}
+
+function closeUploadWatcher(dirPath) {
+  const existing = uploadWatchers.get(dirPath);
+  if (!existing) return;
+  try {
+    existing.close();
+  } catch {}
+  uploadWatchers.delete(dirPath);
+}
+
+function scheduleUploadsPublish(source = 'uploads:watch') {
+  if (uploadsPublishTimer) clearTimeout(uploadsPublishTimer);
+  uploadsPublishTimer = setTimeout(() => {
+    uploadsPublishTimer = null;
+    void publishUploadsResource(source);
+  }, FS_WATCH_DEBOUNCE_MS);
+  if (typeof uploadsPublishTimer.unref === 'function') uploadsPublishTimer.unref();
+}
+
+function watchUploadDirectory(dirPath) {
+  const resolved = path.resolve(dirPath);
+  if (uploadWatchers.has(resolved)) return;
+  try {
+    const watcher = fs.watch(resolved, { persistent: false }, () => {
+      scheduleUploadsPublish('uploads:watch');
+    });
+    watcher.on('error', () => closeUploadWatcher(resolved));
+    if (typeof watcher.unref === 'function') watcher.unref();
+    uploadWatchers.set(resolved, watcher);
+  } catch {
+    // Best-effort watcher; API writes still publish synchronously.
+  }
+}
+
+function buildUploadsResource(options = {}) {
+  const files = [];
+
+  try {
+    assertContainedSync(UPLOADS_ROOT);
+  } catch {
+    return { root: UPLOADS_ROOT, files };
+  }
+
+  if (options.watch !== false) watchUploadDirectory(UPLOADS_ROOT);
+
+  let sessionDirs = [];
+  try {
+    sessionDirs = fs.readdirSync(UPLOADS_ROOT, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === 'ENOENT') return { root: UPLOADS_ROOT, files };
+    throw error;
+  }
+
+  for (const dir of sessionDirs.filter((entry) => entry.isDirectory())) {
+    const sessionPath = path.join(UPLOADS_ROOT, dir.name);
+    if (options.watch !== false) watchUploadDirectory(sessionPath);
+    try {
+      const entries = fs.readdirSync(sessionPath, { withFileTypes: true });
+      for (const entry of entries.filter((item) => item.isFile())) {
+        const fullPath = path.join(sessionPath, entry.name);
+        const stats = fs.lstatSync(fullPath);
+        files.push({
           name: entry.name,
-          isDir: stats.isDirectory(),
+          isDir: false,
           size: stats.size,
           modTime: stats.mtime.toISOString(),
-        };
-      }),
-    );
+          fullPath,
+          sessionId: dir.name,
+        });
+      }
+    } catch {
+      // Upload session directories can disappear while listing.
+    }
+  }
 
-    files.sort((a, b) => {
-      if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
-      return a.name.localeCompare(b.name);
+  files.sort((a, b) => a.name.localeCompare(b.name));
+  return { root: UPLOADS_ROOT, files };
+}
+
+async function publishUploadsResource(source = 'uploads') {
+  try {
+    appendStateEvent({
+      resource: UPLOADS_RESOURCE,
+      op: 'replace',
+      id: UPLOADS_ROOT,
+      value: buildUploadsResource({ watch: true }),
+      source,
     });
+  } catch (error) {
+    console.warn('[fs] Failed to publish uploads resource:', error instanceof Error ? error.message : String(error));
+  }
+}
+
+async function publishFilesystemChange(paths, source = 'fs') {
+  const directories = new Set();
+  let touchesUploads = false;
+
+  for (const item of paths.filter(Boolean)) {
+    const resolved = path.resolve(expandHome(item));
+    directories.add(path.dirname(resolved));
+    if (isUploadsPath(resolved)) touchesUploads = true;
+  }
 
-    sendJson(200, { files, path: targetPath });
+  await Promise.all(Array.from(directories).map((dir) => publishFilesResourceForPath(dir, source)));
+  if (touchesUploads) await publishUploadsResource(source);
+}
+
+async function handleList(query, sendJson) {
+  try {
+    sendJson(200, await buildFilesResource(query.path, { watch: true }));
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Failed to list files';
     sendJson(statusForError(error), { error: message });
@@ -238,6 +539,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');
+    await publishFilesystemChange([targetPath], 'fs:write');
 
     sendJson(200, { success: true, path: targetPath });
   } catch (error) {
@@ -249,8 +551,19 @@ async function handleWrite(body, sendJson) {
 async function handleDelete(body, sendJson) {
   try {
     const targetPath = await resolveSafePath(body.path);
+    const stats = await fs.promises.lstat(targetPath).catch(() => null);
     await fs.promises.rm(targetPath, { recursive: true, force: true });
     activeMemory.notifyMemoryPathChanged(targetPath, 'fs:delete');
+    await publishFilesystemChange([targetPath], 'fs:delete');
+    if (stats?.isDirectory()) {
+      appendStateEvent({
+        resource: filesResourceName(targetPath),
+        op: 'replace',
+        id: targetPath,
+        value: { path: targetPath, files: [], missing: true },
+        source: 'fs:delete',
+      });
+    }
     sendJson(200, { success: true, path: targetPath });
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Failed to delete';
@@ -263,6 +576,8 @@ async function handleMkdir(body, sendJson) {
     const targetPath = await resolveSafePath(body.path, { forCreate: true });
     await fs.promises.mkdir(targetPath, { recursive: true, mode: 0o755 });
     activeMemory.notifyMemoryPathChanged(targetPath, 'fs:mkdir');
+    await publishFilesystemChange([targetPath], 'fs:mkdir');
+    await publishFilesResourceForPath(targetPath, 'fs:mkdir');
     sendJson(200, { success: true, path: targetPath });
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Failed to create folder';
@@ -274,10 +589,22 @@ async function handleRename(body, sendJson) {
   try {
     const oldPath = await resolveSafePath(body.oldPath);
     const newPath = await resolveSafePath(body.newPath, { forCreate: true });
+    const stats = await fs.promises.lstat(oldPath).catch(() => null);
     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');
+    await publishFilesystemChange([oldPath, newPath], 'fs:rename');
+    if (stats?.isDirectory()) {
+      appendStateEvent({
+        resource: filesResourceName(oldPath),
+        op: 'replace',
+        id: oldPath,
+        value: { path: oldPath, files: [], missing: true },
+        source: 'fs:rename',
+      });
+      await publishFilesResourceForPath(newPath, 'fs:rename');
+    }
     sendJson(200, { success: true, oldPath, newPath });
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Failed to rename';
@@ -293,7 +620,12 @@ module.exports = {
   handleRename,
   handleWrite,
   _private: {
+    buildFilesResource,
+    buildUploadsResource,
     configuredRootPaths,
+    filesResourceName,
+    pathFromFilesResource,
+    publishFilesystemChange,
     resolveSafePath,
   },
 };

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

@@ -7,6 +7,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { AMALGM_DIR } = require('../config');
+const { appendStateEvent } = require('../state/events');
 const { deleteTool, upsertTool } = require('../toolbox/store');
 
 const CONNECTIONS_FILE = path.join(AMALGM_DIR, 'mcp-connections.json');
@@ -103,6 +104,27 @@ function readNativeMcps() {
   }
 }
 
+function buildConnectionsSnapshot() {
+  const file = readConnectionsFile();
+  return {
+    connections: sanitizeConnections(file.connections),
+    nativeMcps: readNativeMcps(),
+  };
+}
+
+function publishMcpConnectionsChange(source = 'mcp-connections') {
+  try {
+    appendStateEvent({
+      resource: 'mcp_connections',
+      op: 'replace',
+      value: buildConnectionsSnapshot(),
+      source,
+    });
+  } catch (error) {
+    console.warn('[mcp-connections] Local Live Store publish failed:', error.message);
+  }
+}
+
 function mirrorConnectionToToolbox(appId, conn) {
   const registry = getMcpRegistry();
   const app = registry?.getMcpApp?.(appId);
@@ -151,11 +173,7 @@ function removeConnectionFromToolbox(appId) {
 }
 
 async function handleList(sendJson) {
-  const file = readConnectionsFile();
-  sendJson(200, {
-    connections: sanitizeConnections(file.connections),
-    nativeMcps: readNativeMcps(),
-  });
+  sendJson(200, buildConnectionsSnapshot());
 }
 
 async function handleUpsert(body, sendJson) {
@@ -203,6 +221,7 @@ async function handleUpsert(body, sendJson) {
 
   writeConnectionsFile(file);
   mirrorConnectionToToolbox(appId, file.connections[appId]);
+  publishMcpConnectionsChange('mcp-connections:upsert');
 
   sendJson(200, {
     ok: true,
@@ -223,11 +242,13 @@ async function handleDelete(body, sendJson) {
     writeConnectionsFile(file);
   }
   removeConnectionFromToolbox(appId);
+  publishMcpConnectionsChange('mcp-connections:delete');
 
   sendJson(200, { ok: true });
 }
 
 module.exports = {
+  buildConnectionsSnapshot,
   handleDelete,
   handleList,
   handleUpsert,

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

@@ -62,7 +62,7 @@ const { loadTasks } = require('../tasks/store');
 const { loadAgents } = require('../agents/store');
 const { loadArtifacts } = require('../artifacts/store');
 const { activeAgentConversations } = require('../agents/talk');
-const { startScheduler, stopScheduler } = require('../tasks/scheduler');
+const { getSchedulerStatus, startScheduler, stopScheduler } = require('../tasks/scheduler');
 const { createTransport } = require('./mcp');
 const { handleEventsPost } = require('../events/ingress');
 const eventsRing = require('../events/ring-buffer');
@@ -118,6 +118,7 @@ function createServer() {
           status: 'ok',
           tasks: tasks.tasks.length,
           enabledTasks: tasks.tasks.filter((t) => t.enabled).length,
+          scheduler: getSchedulerStatus(),
           artifacts: loadArtifacts().artifacts.length,
           customAgents: agents.agents.length,
           activeAgentConversations: activeAgentConversations.size,

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

@@ -55,6 +55,78 @@ function migrate(database = openLocalDb()) {
     CREATE INDEX IF NOT EXISTS event_log_resource_seq_idx
       ON event_log(resource, seq);
 
+    CREATE TABLE IF NOT EXISTS local_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT,
+      updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS scheduled_tasks (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      schedule_kind TEXT NOT NULL,
+      schedule_json TEXT NOT NULL,
+      next_run_at TEXT,
+      last_run_at TEXT,
+      last_status TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      task_json TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS scheduled_tasks_due_idx
+      ON scheduled_tasks(enabled, next_run_at);
+
+    CREATE INDEX IF NOT EXISTS scheduled_tasks_kind_idx
+      ON scheduled_tasks(schedule_kind);
+
+    CREATE TABLE IF NOT EXISTS task_runs (
+      id TEXT PRIMARY KEY,
+      task_id TEXT NOT NULL,
+      scheduled_for TEXT NOT NULL,
+      status TEXT NOT NULL,
+      started_at TEXT,
+      finished_at TEXT,
+      claimed_at TEXT,
+      claim_expires_at TEXT,
+      runner_id TEXT,
+      session_id TEXT,
+      error TEXT,
+      run_json TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      UNIQUE(task_id, scheduled_for),
+      FOREIGN KEY(task_id) REFERENCES scheduled_tasks(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS task_runs_task_updated_idx
+      ON task_runs(task_id, updated_at DESC);
+
+    CREATE INDEX IF NOT EXISTS task_runs_status_idx
+      ON task_runs(status);
+
+    CREATE TABLE IF NOT EXISTS event_runs (
+      id TEXT PRIMARY KEY,
+      trigger_id TEXT NOT NULL,
+      status TEXT NOT NULL,
+      started_at TEXT,
+      finished_at TEXT,
+      session_id TEXT,
+      harness TEXT,
+      project_path TEXT,
+      error TEXT,
+      run_json TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS event_runs_trigger_updated_idx
+      ON event_runs(trigger_id, updated_at DESC);
+
+    CREATE INDEX IF NOT EXISTS event_runs_status_idx
+      ON event_runs(status);
+
     CREATE TABLE IF NOT EXISTS tools (
       id TEXT PRIMARY KEY,
       name TEXT NOT NULL,

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

@@ -2,7 +2,7 @@
 
 const { currentSeq } = require('./events');
 
-const DEFAULT_RESOURCES = ['tasks', 'event_triggers', 'agents', 'artifacts', 'toolbox', 'tools', 'tool_actions', 'hooks', 'projects', 'workspaces', 'memories'];
+const DEFAULT_RESOURCES = ['tasks', 'task_runs', 'event_runs', 'event_triggers', 'agents', 'artifacts', 'toolbox', 'tools', 'tool_actions', 'hooks', 'projects', 'workspaces', 'memories', 'mcp_connections'];
 
 function normalizeResources(resources) {
   const values = resources ? String(resources).split(',') : DEFAULT_RESOURCES;
@@ -14,6 +14,10 @@ function readResource(resource, cache) {
   switch (resource) {
     case 'tasks':
       return require('../tasks/store').loadTasks().tasks;
+    case 'task_runs':
+      return require('../tasks/store').listTaskRuns({ limit: 100 });
+    case 'event_runs':
+      return require('../events/store').listEventRuns({ limit: 100 });
     case 'event_triggers':
       return require('../events/store').loadEventTriggers().triggers;
     case 'agents':
@@ -38,7 +42,14 @@ function readResource(resource, cache) {
     }
     case 'memories':
       return require('../../chat-core/tooling/active-memory').collectActiveMemoryFiles();
+    case 'uploads':
+      return require('../fs/rest')._private.buildUploadsResource();
+    case 'mcp_connections':
+      return require('../mcp-connections/rest').buildConnectionsSnapshot();
     default:
+      if (String(resource).startsWith('files:')) {
+        return require('../fs/rest')._private.buildFilesResource(resource);
+      }
       return undefined;
   }
 }

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

@@ -143,16 +143,25 @@ function resolveTaskRequest(task) {
   };
 }
 
-async function executeTask(task) {
-  const runId = crypto.randomUUID();
-  const startedAt = new Date().toISOString();
+async function executeTask(task, claimedRun = null) {
+  const runId = claimedRun?.id || claimedRun?.runId || crypto.randomUUID();
+  const startedAt = claimedRun?.startedAt || new Date().toISOString();
   const { harness, chatInput, legacy, modelSelection, modelSettings } = resolveTaskRequest(task);
   const projectPath = legacy.cwd || task.projectPath || null;
   const mcpServers = await buildLocalMcpServerConfigs(legacy.mcpAppIds || []);
   const reasoningEffort = modelSettings.effort || modelSelection.reasoningEffort;
 
   console.log(`[AmalgmMCP:Exec] Starting task ${task.id} (${task.name}), run ${runId}`);
-  appendRunLog(task.id, { runId, startedAt, status: 'running', prompt: task.prompt });
+  appendRunLog(task.id, {
+    runId,
+    startedAt,
+    scheduledFor: claimedRun?.scheduledFor || startedAt,
+    claimedAt: claimedRun?.claimedAt || startedAt,
+    claimExpiresAt: claimedRun?.claimExpiresAt || null,
+    runnerId: claimedRun?.runnerId || null,
+    status: 'running',
+    prompt: task.prompt,
+  });
   updateTaskMeta(task.id, { lastRunAt: startedAt, lastStatus: 'running' });
 
   const codeSessionId = crypto.randomUUID();