amalgm 0.1.86 → 0.1.87

package/package.json

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

package/runtime/lib/harnesses.js

@@ -105,7 +105,10 @@ var CLAUDE_LEGACY_ALIASES = {
   "opus[1m]": CLAUDE_OPUS_4_8_1M_MODEL_ID,
   sonnet: "anthropic/claude-sonnet-4.6",
   "sonnet[1m]": "anthropic/claude-sonnet-4.6",
-  haiku: "anthropic/claude-haiku-4.5"
+  haiku: "anthropic/claude-haiku-4.5",
+  fable: "anthropic/claude-fable-5",
+  "claude-code-fable": "anthropic/claude-fable-5",
+  "claude-code-fable-5": "anthropic/claude-fable-5"
 };
 var CLAUDE_HARNESS_MODELS = {
   "anthropic/claude-opus-4.8": "opus",
@@ -115,7 +118,8 @@ var CLAUDE_HARNESS_MODELS = {
   "anthropic/claude-opus-4.5": "opus",
   "anthropic/claude-sonnet-4.6": "sonnet",
   "anthropic/claude-sonnet-4.5": "sonnet",
-  "anthropic/claude-haiku-4.5": "haiku"
+  "anthropic/claude-haiku-4.5": "haiku",
+  "anthropic/claude-fable-5": "claude-fable-5"
 };
 var INTERNAL_TO_GATEWAY_MODEL_IDS = {
   [CLAUDE_OPUS_4_8_1M_MODEL_ID]: "anthropic/claude-opus-4.8"
@@ -430,6 +434,15 @@ var CLAUDE_MODELS = [
     cliModel: modelIdToHarnessModel("anthropic/claude-opus-4.8-1m", "claude_code"),
     provider: "claude",
     providerGroup: "anthropic"
+  },
+  {
+    id: "anthropic/claude-fable-5",
+    name: "Fable 5",
+    description: "Anthropic's most capable model",
+    gatewayModelId: "anthropic/claude-fable-5",
+    cliModel: modelIdToHarnessModel("anthropic/claude-fable-5", "claude_code"),
+    provider: "claude",
+    providerGroup: "anthropic"
   }
 ];
 var OPENCODE_MODELS = [

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

@@ -10,9 +10,11 @@ const {
   deleteAutomationByTriggerId,
   getAutomation,
   getAutomationByTriggerId,
+  getAutomationRun,
   listAutomationRuns,
   listAutomations,
   listTriggers,
+  listWorkflowCellRuns,
   listWorkflows,
   updateAutomation,
   updateAutomationByTriggerId,
@@ -43,10 +45,44 @@ async function handleGet(body, sendJson) {
   if (!automation) return sendJson(404, { error: 'Automation not found' });
   sendJson(200, {
     automation,
-    runs: listAutomationRuns({ automationId: automation.id, limit: 50 }),
+    runs: listAutomationRuns({
+      automationId: automation.id,
+      limit: Number(body?.limit) || 50,
+      offset: Number(body?.offset) || 0,
+    }),
   });
 }
 
+/**
+ * Paginated run history, plus run detail (per-cell results) when run_id is
+ * given. This is the endpoint the UI run views should use instead of the
+ * global 100-row state snapshot.
+ */
+async function handleRuns(body, sendJson) {
+  try {
+    const runId = body?.run_id || body?.runId;
+    if (runId) {
+      const run = getAutomationRun(runId);
+      if (!run) return sendJson(404, { error: 'Run not found' });
+      return sendJson(200, { ok: true, run, cellRuns: listWorkflowCellRuns({ runId: run.id }) });
+    }
+    const automationId = body?.automation_id || body?.automationId;
+    if (!automationId) return sendJson(400, { error: 'automation_id or run_id is required' });
+    const limit = Math.max(1, Math.min(Number(body?.limit) || 50, 500));
+    const offset = Math.max(0, Number(body?.offset) || 0);
+    const page = listAutomationRuns({ automationId, limit: limit + 1, offset });
+    sendJson(200, {
+      ok: true,
+      runs: page.slice(0, limit),
+      hasMore: page.length > limit,
+      limit,
+      offset,
+    });
+  } catch (error) {
+    sendError(sendJson, 400, error);
+  }
+}
+
 async function handleCreate(body, sendJson) {
   try {
     const automation = createAutomation(body || {}, { source: 'automations:rest:create' });
@@ -99,7 +135,7 @@ async function handleRunNow(body, sendJson) {
   try {
     const id = body?.automation_id || body?.automationId;
     if (!id) return sendJson(400, { error: 'automation_id is required' });
-    const run = await executeAutomationById(id, {
+    const runs = await executeAutomationById(id, {
       id: `manual:${Date.now()}`,
       source: 'amalgm.manual',
       event: 'run_now',
@@ -107,7 +143,8 @@ async function handleRunNow(body, sendJson) {
       headers: {},
       receivedAt: new Date().toISOString(),
     }, { triggerId: body?.trigger_id || body?.triggerId });
-    sendJson(200, { ok: true, run });
+    // One run per workflow; `run` keeps the legacy single-run shape.
+    sendJson(200, { ok: true, runs, run: runs[0] || null });
   } catch (error) {
     sendError(sendJson, 400, error);
   }
@@ -141,6 +178,7 @@ module.exports = {
   handleGet,
   handleList,
   handleRunNow,
+  handleRuns,
   handleTriggerDelete,
   handleTriggerUpdate,
   handleUpdate,

package/runtime/scripts/amalgm-mcp/automations/runner.js

@@ -9,16 +9,23 @@ const { DEFAULT_CWD } = require('../config');
 const { compileWorkflowText } = require('../workflows/compiler');
 const { callToolboxMcpTool, toolboxMcpToolName } = require('../toolbox/runner');
 const { buildWorkflowInput } = require('./context');
-const { resolveFirstPartyToolAction, resolveToolboxAction, suggestWorkflowToolActions } = require('./tool-actions');
+const {
+  resolveFirstPartyToolAction,
+  resolveToolboxAction,
+  suggestWorkflowToolActions,
+  workflowActionKeys,
+} = require('./tool-actions');
 const {
   getAutomation,
   getAutomationByTriggerId,
   recordAutomationRun,
   recordWorkflowCellRun,
+  touchAutomationRun,
 } = require('./store');
 
 const DEFAULT_CELL_TIMEOUT_MS = 120_000;
 const DEFAULT_CODE_TIMEOUT_MS = 15_000;
+const RUN_HEARTBEAT_MS = 60_000;
 const MAX_OUTPUT_BYTES = 512 * 1024;
 const runQueues = new Map();
 
@@ -242,15 +249,17 @@ async function runShellCommand(config, allowlist) {
   };
 }
 
-async function runHttpTool(args) {
+async function runHttpTool(args, options = {}) {
   const method = String(args.method || 'GET').toUpperCase();
   if (!args.url) throw new Error('http.fetch needs a url.');
+  const timeoutMs = Number(options.timeoutMs) || DEFAULT_CELL_TIMEOUT_MS;
   const response = await fetch(args.url, {
     method,
     headers: args.headers || {},
     body: ['GET', 'HEAD'].includes(method) ? undefined : (
       typeof args.body === 'string' ? args.body : JSON.stringify(args.body ?? {})
     ),
+    signal: AbortSignal.timeout(timeoutMs),
   });
   const text = await response.text();
   let body = text;
@@ -278,16 +287,20 @@ function mcpResultToOutput(result, actionKey) {
   };
 }
 
-async function runToolCell(cell, args, allowlist) {
+async function runToolCell(cell, args, allowlist, options = {}) {
   const actionKey = `${cell.toolId}.${cell.actionName}`;
   const allowedActions = Array.isArray(allowlist.actions) ? allowlist.actions : [];
-  if (allowedActions.length > 0 && !allowedActions.includes(actionKey)) {
+  // Match against every alias of the action (e.g. allowlist entries like
+  // "amalgm.talk_to_agent" must authorize "agents.talk_to_agent"), not just
+  // the raw key — otherwise alias-based allowlists silently block real calls.
+  const candidateKeys = workflowActionKeys(cell.toolId, cell.actionName);
+  if (allowedActions.length > 0 && !candidateKeys.some((key) => allowedActions.includes(key))) {
     throw new Error(`Workflow is not allowed to call ${actionKey}.`);
   }
 
   if (cell.toolId === 'http' && cell.actionName === 'fetch') {
     if (allowlist.network !== true) throw new Error('http.fetch requires allowlist.network=true.');
-    return runHttpTool(args);
+    return runHttpTool(args, options);
   }
 
   const firstPartyAction = resolveFirstPartyToolAction(cell.toolId, cell.actionName);
@@ -316,14 +329,27 @@ async function runToolCell(cell, args, allowlist) {
   return mcpResultToOutput(result, actionKey);
 }
 
-function workflowIrForAutomation(automation) {
-  const workflow = automation.workflow || automation.workflows?.[0];
+function irForWorkflow(workflow) {
   if (!workflow) throw new Error('Automation has no workflow.');
   if (workflow.workflowIr && workflow.workflowIr.version === 1) return workflow.workflowIr;
   if (workflow.workflowText || workflow.workflow) return compileWorkflowText(workflow.workflowText || workflow.workflow);
   throw new Error('Automation workflow has no script.');
 }
 
+function workflowIrForAutomation(automation) {
+  return irForWorkflow(automation.workflow || automation.workflows?.[0]);
+}
+
+function automationWorkflows(automation) {
+  const workflows = (Array.isArray(automation.workflows) && automation.workflows.length > 0
+    ? automation.workflows
+    : [automation.workflow]).filter(Boolean);
+  return {
+    workflows,
+    enabled: workflows.filter((workflow) => workflow.enabled !== false),
+  };
+}
+
 async function executeWorkflowCell(cell, ctx, allowlist, limits) {
   const timeoutMs = Number(cell.timeoutMs || limits.cellTimeoutMs) || DEFAULT_CELL_TIMEOUT_MS;
   const stop = () => {
@@ -350,21 +376,77 @@ async function executeWorkflowCell(cell, ctx, allowlist, limits) {
   }
 
   if (cell.kind === 'tool') {
+    // cellTimeoutMs is the wall-clock budget for the WHOLE cell: argument
+    // resolution and the tool call spend from the same budget, and the call
+    // itself is hard-bounded — one hung MCP tool, agent call, or fetch
+    // otherwise wedges the run (and its concurrency queue) in "running".
+    const cellStartedMs = Date.now();
     const args = await resolveDynamic(cell.args || {}, input, { timeoutMs });
-    const output = await runToolCell(cell, args, allowlist);
+    const remainingMs = Math.max(1000, timeoutMs - (Date.now() - cellStartedMs));
+    const output = await withTimeout(
+      runToolCell(cell, args, allowlist, { timeoutMs: remainingMs }),
+      remainingMs,
+      `Tool ${cell.toolId}.${cell.actionName}`,
+    );
     return { output };
   }
 
   throw new Error(`Unsupported workflow cell kind "${cell.kind}".`);
 }
 
+/**
+ * Run every enabled workflow of the automation, in listed order, recording
+ * one run row per workflow. Workflows are independent: one failing must not
+ * skip the rest. Returns the array of run records (failed runs included).
+ * Throws only when no workflow produced a successful run, so single-workflow
+ * callers keep their old failure semantics.
+ */
 async function runAutomationNow(automation, trigger, eventObj = {}) {
   if (!automation) throw new Error('Automation is required.');
   if (automation.enabled === false) throw new Error(`Automation "${automation.name}" is disabled.`);
-  const workflow = automation.workflow || automation.workflows?.[0];
-  if (!workflow) throw new Error(`Automation "${automation.name}" has no workflow.`);
-  if (workflow.enabled === false) throw new Error(`Workflow "${workflow.name}" is disabled.`);
+  const { workflows, enabled } = automationWorkflows(automation);
+  if (workflows.length === 0) throw new Error(`Automation "${automation.name}" has no workflow.`);
+  if (enabled.length === 0) throw new Error(`Automation "${automation.name}" has no enabled workflow.`);
+
+  const runs = [];
+  let firstError = null;
+  for (const workflow of enabled) {
+    try {
+      runs.push(await runWorkflowNow(automation, workflow, trigger, eventObj));
+    } catch (error) {
+      if (!firstError) firstError = error;
+      if (error?.run) {
+        runs.push(error.run);
+      } else {
+        // The workflow failed before its start row was recorded (IR drift,
+        // store error) — leave a failed run row so the loss is visible.
+        try {
+          const timestamp = new Date().toISOString();
+          const failedRun = recordAutomationRun(automation.id, {
+            runId: crypto.randomUUID(),
+            automationId: automation.id,
+            automationName: automation.name,
+            triggerId: trigger?.id || null,
+            triggerName: trigger?.name || null,
+            workflowId: workflow.id || null,
+            workflowName: workflow.name || null,
+            startedAt: timestamp,
+            finishedAt: timestamp,
+            status: 'failed',
+            error: error.message || String(error),
+          }, { source: 'automation_runs:workflow:start-failed' });
+          if (failedRun) runs.push(failedRun);
+        } catch {
+          // Recording must never mask the original failure.
+        }
+      }
+    }
+  }
+  if (firstError && !runs.some((run) => run && run.status !== 'failed')) throw firstError;
+  return runs;
+}
 
+async function runWorkflowNow(automation, workflow, trigger, eventObj = {}) {
   const runId = crypto.randomUUID();
   const startedAt = new Date().toISOString();
   const resolvedTrigger = trigger || automation.triggers?.[0] || {
@@ -373,7 +455,7 @@ async function runAutomationNow(automation, trigger, eventObj = {}) {
     kind: 'manual',
     automationId: automation.id,
   };
-  const ir = workflowIrForAutomation(automation);
+  const ir = irForWorkflow(workflow);
   const allowlist = {
     ...(ir.allowlist || {}),
     ...(workflow.allowlist || {}),
@@ -412,6 +494,13 @@ async function runAutomationNow(automation, trigger, eventObj = {}) {
     },
   }, { source: 'automation_runs:workflow:start' });
 
+  // Liveness heartbeat: run rows are otherwise only written at cell
+  // boundaries, so a single cell longer than the reaper's stale threshold
+  // would be falsely marked interrupted. unref'd so it never holds the
+  // process open.
+  const heartbeat = setInterval(() => touchAutomationRun(runId), RUN_HEARTBEAT_MS);
+  heartbeat.unref?.();
+
   let status = 'completed';
   try {
     for (const cell of ir.cells) {
@@ -500,7 +589,7 @@ async function runAutomationNow(automation, trigger, eventObj = {}) {
     }, { source: `automation_runs:workflow:${status}` });
     return run;
   } catch (error) {
-    recordAutomationRun(automation.id, {
+    const failedRun = recordAutomationRun(automation.id, {
       runId,
       automationId: automation.id,
       automationName: automation.name,
@@ -513,7 +602,10 @@ async function runAutomationNow(automation, trigger, eventObj = {}) {
       error: error.message || String(error),
       durationMs: durationSince(startedAt),
     }, { source: 'automation_runs:workflow:failed' });
+    if (failedRun) error.run = failedRun;
     throw error;
+  } finally {
+    clearInterval(heartbeat);
   }
 }
 
@@ -533,8 +625,12 @@ function runQueuedAutomation(key, state, item) {
 }
 
 function executeAutomation(automation, trigger, eventObj = {}) {
-  const ir = workflowIrForAutomation(automation);
-  const workflow = automation.workflow || automation.workflows?.[0];
+  // Concurrency gating reads limits from the first ENABLED workflow — a
+  // disabled primary is skipped by the runner, so its limits must not govern
+  // the firing.
+  const { enabled } = automationWorkflows(automation);
+  const workflow = enabled[0] || automation.workflow || automation.workflows?.[0];
+  const ir = irForWorkflow(workflow);
   const limits = {
     ...(ir.limits || {}),
     ...(workflow?.limits || {}),

package/runtime/scripts/amalgm-mcp/automations/scheduler.js

@@ -7,57 +7,142 @@
  * scheduled triggers from the unified automation store and runs their
  * workflows; it does not wake an agent unless the workflow explicitly calls
  * an agent/tool cell.
+ *
+ * Reliability invariants:
+ * - next_run_at is persisted, so triggers due while the process was down are
+ *   claimed by the first poll after boot/wake (single-shot catch-up).
+ * - Boot runs a repair pass that re-arms enabled triggers whose next_run_at
+ *   was lost (the claim query skips NULL rows, so without repair those
+ *   triggers are permanently dormant).
+ * - One automation failing to start must never abort the rest of a claim
+ *   batch: claims have already advanced next_run_at, so a lost claim is a
+ *   silently missed run.
+ * - Each tick expires stale "running" run rows so crashes and hung cells do
+ *   not leave phantom in-progress runs in history.
  */
 
+const crypto = require('crypto');
+
 const { SCHEDULER_INTERVAL_MS } = require('../config');
-const { claimDueScheduledTriggers } = require('./store');
+const {
+  claimDueScheduledTriggers,
+  expireStaleAutomationRuns,
+  getSchedulerHeartbeat,
+  pruneAutomationRuns,
+  recordAutomationRun,
+  recordSchedulerHeartbeat,
+  repairScheduledTriggers,
+} = require('./store');
 const { executeAutomation } = require('./runner');
 
+// Runs claimed more than this far past their slot are stamped as catch-up
+// runs so workflows and the UI can distinguish "on time" from "made up".
+const CATCH_UP_GRACE_MS = 5 * 60_000;
+const MAINTENANCE_INTERVAL_MS = 60 * 60_000;
+
 let schedulerTimer = null;
 let isPolling = false;
+let lastMaintenanceAt = 0;
 
 const schedulerStatus = {
   startedAt: null,
   lastTickAt: null,
   lastError: null,
   lastClaimed: 0,
+  lastRepairedTriggers: 0,
+  lastExpiredRuns: 0,
 };
 
 function startAutomationScheduler() {
   console.log(`[AmalgmMCP:Automations] Starting scheduler (interval: ${SCHEDULER_INTERVAL_MS}ms)`);
   if (schedulerTimer) clearInterval(schedulerTimer);
   schedulerStatus.startedAt = new Date().toISOString();
+
+  const previousHeartbeat = getSchedulerHeartbeat();
+  if (previousHeartbeat) {
+    const gapMs = Date.now() - new Date(previousHeartbeat).getTime();
+    if (Number.isFinite(gapMs) && gapMs > SCHEDULER_INTERVAL_MS * 4) {
+      console.warn(`[AmalgmMCP:Automations] Scheduler was down for ~${Math.round(gapMs / 60_000)}m (last heartbeat ${previousHeartbeat}); overdue triggers will catch up this tick.`);
+    }
+  }
+
+  try {
+    const repaired = repairScheduledTriggers({ source: 'automation-scheduler:boot' });
+    schedulerStatus.lastRepairedTriggers = repaired.length;
+    if (repaired.length > 0) {
+      console.log(`[AmalgmMCP:Automations] Re-armed ${repaired.length} dormant scheduled trigger(s) with missing next_run_at`);
+    }
+  } catch (error) {
+    console.error('[AmalgmMCP:Automations] Trigger repair pass failed:', error.message || error);
+  }
+
   pollAutomationScheduler();
   schedulerTimer = setInterval(pollAutomationScheduler, SCHEDULER_INTERVAL_MS);
 }
 
+function recordLostClaim(claim, error) {
+  try {
+    const timestamp = new Date().toISOString();
+    recordAutomationRun(claim.automation.id, {
+      runId: crypto.randomUUID(),
+      automationId: claim.automation.id,
+      automationName: claim.automation.name,
+      triggerId: claim.trigger?.id || null,
+      triggerName: claim.trigger?.name || null,
+      workflowId: claim.automation.workflowId || null,
+      startedAt: timestamp,
+      finishedAt: timestamp,
+      status: 'failed',
+      error: `Scheduled run could not start: ${error.message || error}`,
+    }, { source: 'automation_runs:workflow:start-failed' });
+  } catch (recordError) {
+    console.error('[AmalgmMCP:Automations] Failed to record lost claim:', recordError.message || recordError);
+  }
+}
+
 function pollAutomationScheduler() {
   if (isPolling) return;
   isPolling = true;
   try {
     const now = new Date();
     schedulerStatus.lastTickAt = now.toISOString();
+    recordSchedulerHeartbeat(schedulerStatus.lastTickAt);
     const claims = claimDueScheduledTriggers(now, { source: 'automation-scheduler' });
     schedulerStatus.lastClaimed = claims.length;
     schedulerStatus.lastError = null;
 
     for (const claim of claims) {
       if (!claim?.automation || !claim?.trigger) continue;
-      executeAutomation(claim.automation, claim.trigger, {
-        id: claim.scheduledFor || now.toISOString(),
+      const scheduledFor = claim.scheduledFor || now.toISOString();
+      const lateMs = Math.max(0, now.getTime() - new Date(scheduledFor).getTime());
+      const eventObj = {
+        id: scheduledFor,
         source: 'amalgm.scheduler',
         event: 'scheduled',
         payload: {
-          scheduledFor: claim.scheduledFor,
+          scheduledFor,
+          catchUp: lateMs > CATCH_UP_GRACE_MS,
+          lateMs,
           triggerId: claim.trigger.id,
           automationId: claim.automation.id,
         },
         headers: {},
         receivedAt: now.toISOString(),
-      }).catch((error) => {
-        console.error(`[AmalgmMCP:Automations] Automation ${claim.automation.id} failed:`, error.message);
-      });
+      };
+      // The claim already advanced next_run_at, so this run will not be
+      // retried — isolate every failure (sync throws included) per claim and
+      // leave a failed run row instead of losing the run invisibly.
+      try {
+        executeAutomation(claim.automation, claim.trigger, eventObj).catch((error) => {
+          console.error(`[AmalgmMCP:Automations] Automation ${claim.automation.id} failed:`, error.message);
+        });
+      } catch (error) {
+        console.error(`[AmalgmMCP:Automations] Automation ${claim.automation.id} could not start:`, error.message || error);
+        recordLostClaim(claim, error);
+      }
     }
+
+    runSchedulerMaintenance(now);
   } catch (error) {
     schedulerStatus.lastError = error.message || String(error);
     console.error('[AmalgmMCP:Automations] Scheduler poll error:', schedulerStatus.lastError);
@@ -66,11 +151,35 @@ function pollAutomationScheduler() {
   }
 }
 
+function runSchedulerMaintenance(now = new Date()) {
+  try {
+    const expired = expireStaleAutomationRuns();
+    schedulerStatus.lastExpiredRuns = expired.length;
+    if (expired.length > 0) {
+      console.warn(`[AmalgmMCP:Automations] Marked ${expired.length} stale running run(s) as interrupted`);
+    }
+  } catch (error) {
+    console.error('[AmalgmMCP:Automations] Stale-run sweep failed:', error.message || error);
+  }
+
+  if (now.getTime() - lastMaintenanceAt < MAINTENANCE_INTERVAL_MS) return;
+  lastMaintenanceAt = now.getTime();
+  try {
+    const pruned = pruneAutomationRuns();
+    if (pruned > 0) {
+      console.log(`[AmalgmMCP:Automations] Pruned ${pruned} old automation run(s)`);
+    }
+  } catch (error) {
+    console.error('[AmalgmMCP:Automations] Run pruning failed:', error.message || error);
+  }
+}
+
 function getAutomationSchedulerStatus() {
   return {
     intervalMs: SCHEDULER_INTERVAL_MS,
     running: Boolean(schedulerTimer),
     polling: isPolling,
+    heartbeatAt: getSchedulerHeartbeat(),
     ...schedulerStatus,
   };
 }