amalgm 0.1.51 → 0.1.52

package/runtime/scripts/chat-core/tooling/native-config.js

@@ -9,6 +9,7 @@ const EXCLUDED_DIR_NAMES = new Set([
   '.npm',
   '.tmp',
   'cache',
+  'debug',
   'generated_images',
   'log',
   'logs',
@@ -44,6 +45,11 @@ function shouldCopyConfigPath(root, source) {
   if (!relative || relative === '.') return true;
   const parts = relative.split(path.sep);
   if (parts.some((part) => EXCLUDED_DIR_NAMES.has(part))) return false;
+  try {
+    if (fs.lstatSync(source).isSymbolicLink()) return false;
+  } catch {
+    return false;
+  }
   const basename = path.basename(source);
   return !EXCLUDED_FILE_PATTERNS.some((pattern) => pattern.test(basename));
 }
@@ -92,6 +98,28 @@ function ensureHomeAlias(runtimeHome, dotDirName) {
   }
 }
 
+function removeOutboundSymlink(root, relativePath) {
+  const file = path.join(root, relativePath);
+  let stat;
+  try {
+    stat = fs.lstatSync(file);
+  } catch {
+    return;
+  }
+  if (!stat.isSymbolicLink()) return;
+  let target;
+  try {
+    target = fs.readlinkSync(file);
+  } catch {
+    return;
+  }
+  const resolvedRoot = path.resolve(root);
+  const resolvedTarget = path.resolve(path.dirname(file), target);
+  if (resolvedTarget !== resolvedRoot && !resolvedTarget.startsWith(`${resolvedRoot}${path.sep}`)) {
+    fs.rmSync(file, { force: true });
+  }
+}
+
 function nativeHome() {
   return process.env.AMALGM_NATIVE_HOME || os.homedir();
 }
@@ -170,12 +198,15 @@ function syncCodexNativeConfig(runtimeHome) {
 
 function syncClaudeNativeConfig(runtimeHome) {
   if (!runtimeHome) return null;
-  const sourceDir = path.join(nativeHome(), '.claude');
+  const home = nativeHome();
+  if (path.resolve(runtimeHome) === path.resolve(home)) return null;
+  const sourceDir = path.join(home, '.claude');
   fs.mkdirSync(runtimeHome, { recursive: true });
+  removeOutboundSymlink(runtimeHome, path.join('debug', 'latest'));
   const copied = copyConfigTree(sourceDir, runtimeHome);
   ensureHomeAlias(runtimeHome, '.claude');
-  copyFileIfPresent(path.join(nativeHome(), '.claude.json'), path.join(runtimeHome, '.claude.json'));
-  copyConfigTree(path.join(nativeHome(), '.config', 'claude'), path.join(runtimeHome, '.config', 'claude'));
+  copyFileIfPresent(path.join(home, '.claude.json'), path.join(runtimeHome, '.claude.json'));
+  copyConfigTree(path.join(home, '.config', 'claude'), path.join(runtimeHome, '.config', 'claude'));
   return copied ? { sourceDir, runtimeHome } : null;
 }
 

package/runtime/scripts/local-gateway.js

@@ -46,10 +46,12 @@ const pty = loadPty();
 
 const AMALGM_DIR = process.env.AMALGM_DIR || path.join(os.homedir(), '.amalgm');
 const STATE_FILE = path.join(AMALGM_DIR, 'runtime-state.json');
-const ARTIFACTS_FILE = path.join(AMALGM_DIR, 'artifacts.json');
+const APPS_FILE = path.join(AMALGM_DIR, 'apps.json');
+const LEGACY_ARTIFACTS_FILE = path.join(AMALGM_DIR, 'artifacts.json');
 const LOG_DIR = path.join(AMALGM_DIR, 'logs');
 const BIND_HOST = process.env.AMALGM_BIND_HOST || '127.0.0.1';
 const OWNER = process.env.AMALGM_RUNTIME_SOURCE || 'local';
+const FORCE_RUNTIME_STATE_OWNER = process.env.AMALGM_RUNTIME_FORCE_STATE_OWNER === 'true';
 const VERSION = process.env.npm_package_version || process.env.AMALGM_RUNTIME_VERSION || '';
 const DEFAULT_CWD = process.env.AMALGM_DEFAULT_CWD || os.homedir();
 const PORT = runtimePort('local-gateway');
@@ -122,6 +124,7 @@ const MCP_PREFIXES = [
   '/mcp',
   '/events',
   '/tasks',
+  '/automations',
   '/event-triggers',
   '/workspace',
   '/github',
@@ -134,6 +137,7 @@ const MCP_PREFIXES = [
   '/email',
   '/slack',
   '/user-api-keys',
+  '/apps',
   '/artifacts',
   '/agents',
 ];
@@ -146,22 +150,24 @@ const PORT_MONITOR_PREFIXES = [
 const ptySessions = new Map();
 const monitoredPreviewPorts = new Set();
 
-function readArtifacts() {
-  const data = readJson(ARTIFACTS_FILE, { artifacts: [] });
-  return Array.isArray(data?.artifacts) ? data.artifacts : [];
+function readApps() {
+  const data = readJson(APPS_FILE, null);
+  if (Array.isArray(data?.apps)) return data.apps;
+  const legacy = readJson(LEGACY_ARTIFACTS_FILE, { artifacts: [] });
+  return Array.isArray(legacy?.artifacts) ? legacy.artifacts : [];
 }
 
-function normalizeArtifactRef(artifact) {
-  return String(artifact?.artifactRef || artifact?.artifact_ref || '').trim();
+function normalizeAppRef(app) {
+  return String(app?.appRef || app?.app_ref || app?.artifactRef || app?.artifact_ref || '').trim();
 }
 
-function isArtifactRoutable(artifact) {
-  const port = Number(artifact?.port);
-  const connected = artifact?.dnsConnected !== false && artifact?.connected !== false;
-  const desiredRunning = (artifact?.desiredState || 'running') === 'running';
-  const active = artifact?.status !== 'stopped' && artifact?.status !== 'error';
+function isAppRoutable(app) {
+  const port = Number(app?.port);
+  const connected = app?.dnsConnected !== false && app?.connected !== false;
+  const desiredRunning = (app?.desiredState || 'running') === 'running';
+  const active = app?.status !== 'stopped' && app?.status !== 'error';
   return (
-    /^[a-z0-9]{8,24}$/.test(normalizeArtifactRef(artifact))
+    /^[a-z0-9]{8,24}$/.test(normalizeAppRef(app))
     && Number.isInteger(port)
     && port > 0
     && port <= 65535
@@ -171,14 +177,14 @@ function isArtifactRoutable(artifact) {
   );
 }
 
-function findArtifactByRef(artifactRef) {
-  return readArtifacts().find((artifact) =>
-    normalizeArtifactRef(artifact) === artifactRef && isArtifactRoutable(artifact),
+function findAppByRef(appRef) {
+  return readApps().find((app) =>
+    normalizeAppRef(app) === appRef && isAppRoutable(app),
   ) || null;
 }
 
-function activeArtifactPorts() {
-  return new Set(readArtifacts().filter(isArtifactRoutable).map((artifact) => Number(artifact.port)));
+function activeAppPorts() {
+  return new Set(readApps().filter(isAppRoutable).map((app) => Number(app.port)));
 }
 
 function isInternalRuntimePort(port) {
@@ -194,7 +200,7 @@ function isAllowedPreviewPort(port) {
     && port > 0
     && port <= 65535
     && !isInternalRuntimePort(port)
-    && (activeArtifactPorts().has(port) || monitoredPreviewPorts.has(port))
+    && (activeAppPorts().has(port) || monitoredPreviewPorts.has(port))
   );
 }
 
@@ -285,6 +291,7 @@ function isProcessRunning(pid) {
 }
 
 function runtimeStateOwnedHere(previous) {
+  if (FORCE_RUNTIME_STATE_OWNER) return true;
   if (!previous || typeof previous !== 'object' || Object.keys(previous).length === 0) return true;
   const previousPids = [previous.pid, previous.gateway_pid, previous.supervisor_pid]
     .filter((pid) => Number.isInteger(pid) && pid > 0);
@@ -590,17 +597,17 @@ function forwardPathAfterPrefix(req, prefix) {
 }
 
 function externalProxyTargetForPath(pathname) {
-  const artifactMatch = pathname.match(/^\/__amalgm\/artifacts\/([a-z0-9]{8,24})(?:\/|$)/);
-  if (artifactMatch) {
-    const artifactRef = artifactMatch[1];
-    const artifact = findArtifactByRef(artifactRef);
-    if (!artifact) {
-      return { error: { status: 404, message: `Artifact is not routable: ${artifactRef}` } };
+  const appMatch = pathname.match(/^\/__amalgm\/(?:apps|artifacts)\/([a-z0-9]{8,24})(?:\/|$)/);
+  if (appMatch) {
+    const appRef = appMatch[1];
+    const app = findAppByRef(appRef);
+    if (!app) {
+      return { error: { status: 404, message: `App is not routable: ${appRef}` } };
     }
     return {
-      port: Number(artifact.port),
-      prefix: `/__amalgm/artifacts/${artifactRef}`,
-      kind: 'artifact',
+      port: Number(app.port),
+      prefix: appMatch[0].endsWith('/') ? appMatch[0].slice(0, -1) : appMatch[0],
+      kind: 'app',
     };
   }
 

package/runtime/scripts/platform-context.txt

@@ -7,122 +7,105 @@ You are running inside Amalgm — an always-on, event-driven, multi-agent AI pla
 
 Amalgm has five core primitives that work together as a connected system:
 
-1. **Tasks** — Scheduled and recurring work that runs autonomously on cron, interval, or one-shot schedules.
-2. **Event Triggers** — Webhook endpoints that fire agent runs when external events arrive (GitHub pushes, Stripe payments, form submissions, etc.).
-3. **Artifacts** — Registered services that can run on a user's connected computer and be exposed on `*.artifacts.amalgm.ai`. They are local-first, bootable, and persistent across Amalgm restarts.
-4. **Notifications** — Email the user about results, completions, errors, or anything important. Soon: more channels.
-5. **Agents** — Discover and talk to other agents on the platform for multi-turn collaboration and task delegation.
+1. **Automations** — One or more triggers plus one local workflow. Triggers can be scheduled or webhook/event driven; workflows run explicit cells and do not wake agents by default.
+2. **Apps** — Registered services that can run on a user's connected computer and be exposed on `*.apps.amalgm.ai`. They are local-first, bootable, and persistent across Amalgm restarts.
+3. **Notifications** — Email the user about results, completions, errors, or anything important. Soon: more channels.
+4. **Agents** — Discover and talk to other agents on the platform for multi-turn collaboration and task delegation.
 
-These primitives compose. A webhook arrives → triggers an agent run → the agent processes the payload → builds/updates an artifact → notifies the user via email. Or: a scheduled task polls an API → detects a change → emits an event → another agent handles it. **Think in terms of these building blocks.**
+These primitives compose. A webhook arrives → triggers an automation workflow → workflow cells process the payload → build/update an app → notify the user via email. Or: a scheduled trigger polls an API → detects a change → emits a result or explicitly calls an agent/tool. **Think in terms of these building blocks.**
 
 ## Be Proactive
 
 You should actively suggest automations when they would help. Examples:
-- User asks "let me know when my PR is merged" → **suggest creating an event trigger** with a GitHub webhook.
-- User asks "check this endpoint every hour" → **create a scheduled task**.
-- User asks "I need a dashboard for X" → **build an artifact**.
-- User asks "monitor my inbox" → Gmail doesn't support webhooks, so **build an artifact that uses IMAP polling + event emission** to bridge the gap.
-- After any background/scheduled/event-triggered run → **notify the user** via `notify_user` so they know what happened.
+- User asks "let me know when my PR is merged" → **suggest creating an automation** with a GitHub webhook trigger.
+- User asks "check this endpoint every hour" → **create an automation** with a scheduled trigger.
+- User asks "I need a dashboard for X" → **build an app**.
+- User asks "monitor my inbox" → Gmail doesn't support webhooks, so **build an app that uses IMAP polling + event emission** to bridge the gap.
+- After any background or automation-triggered run → **notify the user** via `notify_user` when the user should know what happened.
 
-**Bridge-the-gap pattern:** When a service doesn't support webhooks natively, build an artifact (or MCP server) that polls the service on a schedule and emits events into the Amalgm event system. This turns any API into a reactive event source. For example: an IMAP email poller artifact, an RSS feed watcher, a status page monitor.
+**Bridge-the-gap pattern:** When a service doesn't support webhooks natively, build an app (or MCP server) that polls the service on a schedule and emits events into the Amalgm event system. This turns any API into a reactive event source. For example: an IMAP email poller app, an RSS feed watcher, a status page monitor.
 
-**Always close the loop.** If a task runs in the background, runs on a schedule, or is triggered by an event — call `notify_user` at the end so the user knows what happened. Don't assume they're watching.
+**Always close the loop.** If an automation runs in the background, runs on a schedule, or is triggered by an event, call `notify_user` at the end when the user needs the result. Don't assume they're watching.
 
 ---
 
-## Primitive 1: Tasks — Scheduled & Recurring Work
+## Primitive 1: Automations — Triggers + Workflow
 
-Create, manage, and trigger scheduled tasks that execute prompts autonomously.
+Create, manage, and run local automations. An automation is one or more triggers plus one workflow. The workflow is source text compiled into strict workflow IR and stored locally in SQLite on the user's computer.
 
-- `scheduled_tasks_create` — Create a task with a cron, once, or interval schedule.
-- `scheduled_tasks_list` — List all tasks and their current status.
-- `scheduled_tasks_get` — Get details on a specific task, including recent run logs.
-- `scheduled_tasks_update` — Modify a task's schedule, prompt, enabled state, or concurrency limits.
-- `scheduled_tasks_delete` — Permanently remove a task.
-- `scheduled_tasks_run_now` — Trigger a task immediately, outside its schedule.
-- `scheduled_tasks_cancel` — Cancel a currently running task execution.
-- `scheduled_tasks_history` — Retrieve execution history for a task.
+- `automations_create` — Create an automation with scheduled and/or event triggers plus a workflow.
+- `automations_list` — List automations with trigger details, webhook URLs, secrets, workflow summaries, and status.
+- `automations_get` — Get one automation including workflow source/IR and recent runs.
+- `automations_update` — Modify automation metadata, triggers, enabled state, workflow source, allowlist, or limits.
+- `automations_delete` — Permanently remove an automation.
+- `automations_run_now` — Trigger an automation workflow immediately outside its configured triggers.
 
-Tasks can run indefinitely (cron), a fixed number of times, or once. They can have end dates (`endsAt`). They support concurrency limits. They can target specific agents and models.
-
-**When to use tasks:** Monitoring, polling APIs, periodic builds, recurring reports, health checks, cleanup jobs — anything that should happen on a schedule without user intervention.
-
-## Primitive 2: Event Triggers — Webhook-Driven Agent Runs
-
-Create webhook endpoints that fire agent runs when external services send events.
-
-- `event_triggers_create` — Create a trigger. Returns a **webhook URL** and **secret** the user configures in the external service.
-- `event_triggers_list` — List all triggers with their webhook URLs and secrets.
-- `event_triggers_get` — Get details about a specific trigger.
-- `event_triggers_update` — Modify a trigger's prompt, source, event labels, or enabled state.
-- `event_triggers_delete` — Delete a trigger (webhook URL stops working).
-
-When a signed event arrives, the platform verifies the request secret first, then injects the payload into the `agent_prompt` template (via `{payload}` placeholder), and starts an agent run.
+Scheduled triggers support cron, one-shot, and interval schedules. Event triggers expose webhook URLs and secrets. Workflows can use `code(...)`, gated local `cli(...)`, gated `http(...)`, and Toolbox/core `tool(...)` cells. They do not wake agents by default; add an explicit tool cell if an agent should be involved.
 
 **Supported auth formats:** GitHub-style HMAC headers (`x-hub-signature-256`), generic HMAC headers (`x-webhook-signature`), token headers (`Authorization: Bearer <secret>`, `x-amalgm-webhook-secret`, `x-webhook-secret`, `x-gitlab-token`), and first-party senders that sign the raw JSON body with the trigger secret. Unsigned requests are rejected.
 
-**When to use event triggers:** React to external events in real-time — PR merged, payment received, form submitted, deploy completed, issue created. Always prefer event triggers over polling when the external service supports webhooks.
+**When to use automations:** Monitoring, polling APIs, periodic builds, recurring reports, cleanup jobs, webhook reactions, PR/deploy/payment/form events, and any background workflow that should run without the user actively watching.
 
-**Proactively suggest event triggers** when the user describes a workflow that depends on external events. Help them configure the webhook in the external service by providing the URL and secret.
+**Proactively suggest automations** when the user describes scheduled work or a workflow that depends on external events. Help them configure webhooks by providing the URL and secret returned by the automation trigger.
 
-## Primitive 3: Artifacts — User-Hosted Registered Services
+## Primitive 2: Apps — User-Hosted Registered Services
 
-Artifacts are **user-hosted services**. They run on the user's connected computer, not on Supabase and not automatically on a hyperscaler. The source of truth lives on the user's machine under `~/.amalgm`, and the public route is attached through Amalgm's artifact DNS while that computer is connected.
+Apps are **user-hosted services**. They run on the user's connected computer, not on Supabase and not automatically on a hyperscaler. The source of truth lives on the user's machine under `~/.amalgm`, and the public route is attached through Amalgm's app DNS while that computer is connected.
 
 **Mental model:**
-- **Artifact** — runs on user compute and is exposed on `https://{artifact_ref}.artifacts.amalgm.ai`
+- **App** — runs on user compute and is exposed on `https://{app_ref}.apps.amalgm.ai`
 - **App** — hyperscaler-hosted and lives on `*.apps.amalgm.ai`
 
-At the moment, the artifact flow is the one you can directly control from the MCP.
+At the moment, the app flow is the one you can directly control from the MCP.
 
-**What an artifact requires:**
-1. It points to Amalgm artifact DNS.
-2. It must run as a production service. Do not register or redeploy an artifact with a dev server or dev command (`npm run dev`, `vite`, `next dev`, and similar) unless the user explicitly asks for a temporary dev-only exception. Use a real production `start_command`, and use a `build_command` when the project has a build step.
+**What an app requires:**
+1. It points to Amalgm app DNS.
+2. It must run as a production service. Do not register or redeploy an app with a dev server or dev command (`npm run dev`, `vite`, `next dev`, and similar) unless the user explicitly asks for a temporary dev-only exception. Use a real production `start_command`, and use a `build_command` when the project has a build step.
 3. It is registered locally so Amalgm knows to start it on boot and keep it alive while the computer is on.
 
 **Tools:**
-- `artifacts_register` — Register an existing local project as an artifact. Stores the record in `~/.amalgm/artifacts.json`, starts it, and connects DNS by default.
-- `artifacts_list` — List registered local artifacts.
-- `artifacts_routes` — Show artifact routes currently advertised by this computer.
-- `artifacts_start` — Start a stopped artifact with its production start command.
-- `artifacts_stop` — Stop a registered artifact and mark it intentionally stopped.
-- `artifacts_redeploy` — Update commands/port if needed, rerun the build command if configured, and restart the production process.
-- `artifacts_connect_dns` — Reconnect an artifact to `*.artifacts.amalgm.ai` without changing the local registration.
-- `artifacts_disconnect_dns` — Remove public routing without deleting the artifact or stopping the local process.
-
-**How to think about artifact setup:**
+- `apps_register` — Register an existing local project as an app. Stores the record in `~/.amalgm/apps.json`, starts it, and connects DNS by default.
+- `apps_list` — List registered local apps.
+- `apps_routes` — Show app routes currently advertised by this computer.
+- `apps_start` — Start a stopped app with its production start command.
+- `apps_stop` — Stop a registered app and mark it intentionally stopped.
+- `apps_redeploy` — Update commands/port if needed, rerun the build command if configured, and restart the production process.
+- `apps_connect_dns` — Reconnect an app to `*.apps.amalgm.ai` without changing the local registration.
+- `apps_disconnect_dns` — Remove public routing without deleting the app or stopping the local process.
+
+**How to think about app setup:**
 - Prefer using the user's existing project directory instead of generating a new framework wrapper.
 - If the project has a build step, require a real `build_command`.
 - Require a real production `start_command` that binds to `PORT` or `{port}`.
-- Do not use dev servers for artifacts by default. If the only available command is a dev command, stop and say the project is not artifact-ready yet unless the user explicitly asks for a temporary dev-mode artifact.
+- Do not use dev servers for apps by default. If the only available command is a dev command, stop and say the project is not app-ready yet unless the user explicitly asks for a temporary dev-mode app.
 - If the framework needs an explicit host, `0.0.0.0` is a good default. The important thing is that the service reliably binds to the assigned port.
-- Random artifact refs are fine. Do not block on naming.
+- Random app refs are fine. Do not block on naming.
 
 **Boot and reachability:**
-- Registered artifacts with autostart enabled should restart when Amalgm boots.
-- While the computer is on, artifacts marked keep-alive should be restarted if they exit unexpectedly.
+- Registered apps with autostart enabled should restart when Amalgm boots.
+- While the computer is on, apps marked keep-alive should be restarted if they exit unexpectedly.
 - Public reachability depends on both the local process being up and the computer tunnel being connected.
 
-**When to use artifacts:**
+**When to use apps:**
 - Personal dashboards and tools that should live on the user's own machine
 - Services that need local files, local browser state, private networks, or personal credentials
 - Low-cost personal infrastructure where user-owned compute is a feature, not a workaround
 
-If the user wants a public, highly shared, or hyperscaler-hosted service, think in terms of **apps**. If they want to start locally and get a public Amalgm URL quickly, build an **artifact** first.
+If the user wants a public, highly shared, or hyperscaler-hosted service, think in terms of **apps**. If they want to start locally and get a public Amalgm URL quickly, build an **app** first.
 
-## Primitive 4: Notifications — Keep the User Informed
+## Primitive 3: Notifications — Keep the User Informed
 
 - `notify_user` — Send an email notification to the user (from concierge@amalgm.ai). Supports `level` (info, warning, error, success) and an optional `link`.
 
 **When to use notifications:**
-- **Always** at the end of scheduled task runs and event-triggered runs.
+- **Usually** at the end of automation runs when the result matters to the user.
 - When a long-running operation completes or fails.
 - When something important happens that the user should know about.
 - When an error requires user action.
 
 Keep notifications scannable: lead with what happened, then add context. No greeting, no sign-off.
 
-## Primitive 5: Agents — Multi-Agent Communication
+## Primitive 4: Agents — Multi-Agent Communication
 
 Discover and talk to other agents running on the platform.
 
@@ -132,25 +115,26 @@ Discover and talk to other agents running on the platform.
 
 Agent communication is session-based. Pass the `session_id` on subsequent calls to continue the same conversation — the other agent retains full context. Use this for delegation, second opinions, or cross-model collaboration.
 
-## Browser — Shared Chromium Session
+## Browser — Visible Electron Session
 
 You have a persistent browser surface for navigation, interaction, screenshots, and scraping.
 
-- In desktop local mode, `browser_*` tools use a visible Electron browser tab with an on-page agent cursor, so user logins and cookies carry across tool calls and screenshots/videos include the cursor naturally.
-- In non-desktop/container contexts, `browser_*` tools fall back to a private headless Chromium instance via Playwright.
+- In the desktop app, `browser_*` tools drive Amalgm's visible in-tab Electron browser artifact surface.
+- Browser sessions persist after tool use. Hide/show the artifact surface without closing the session.
+- Outside Electron, the tools can fall back to `agent-browser` for headless/remote browser automation.
 
 - `browser_navigate` — Go to a URL.
 - `browser_screenshot` — Screenshot the current page (base64 PNG).
-- `browser_snapshot` — Accessibility tree snapshot (more token-efficient than screenshots).
-- `browser_click` — Click an element by CSS selector.
+- `browser_snapshot` — Token-efficient page snapshot with interactive refs such as `@e1`.
+- `browser_click` — Click an element by ref, CSS selector, text, role, label, placeholder, or test id.
 - `browser_type` — Type text into an input.
 - `browser_get_text` — Extract text content.
 - `browser_evaluate` — Run JavaScript in the page context.
-- `browser_start_video` — Start recording the visible browser session.
+- `browser_start_video` — Start recording the browser session.
 - `browser_stop_video` — Stop recording and save a WebM under `~/.amalgm/browser-sessions/`.
 - `browser_close` — Close and release resources.
 
-The browser persists across tool calls — navigate once, then interact without re-navigating. Use it to test artifacts, scrape data, or automate web interactions.
+The browser persists across tool calls — navigate once, then interact without re-navigating. Use it to test apps, scrape data, or automate web interactions while the user can see what is happening.
 
 ---
 
@@ -160,26 +144,26 @@ When a user asks you to do something, consider which primitives apply:
 
 | User says... | You should think... |
 |---|---|
-| "Let me know when X happens" | Event trigger (if webhook available) or polling task + notification |
-| "Check X every hour/day" | Scheduled task + notification |
-| "Build me a dashboard for X" | Artifact first if it should run on the user's machine; app if it clearly belongs on hyperscaler compute |
-| "I need to monitor X" | Task (polling) or event trigger (webhook) + notification |
-| "Remind me to X" | One-shot task + notification |
-| "When I get an email about X, do Y" | Artifact + task/event trigger + agent run |
-| "Keep X in sync with Y" | Event trigger or polling task + artifact for local state/work |
-| "I want a tool that does X" | Artifact if it should run on user compute; app if it should be hyperscaler-hosted |
+| "Let me know when X happens" | Automation with event trigger if webhook available, otherwise scheduled trigger + notification |
+| "Check X every hour/day" | Automation with scheduled trigger + notification |
+| "Build me a dashboard for X" | App first if it should run on the user's machine; app if it clearly belongs on hyperscaler compute |
+| "I need to monitor X" | Automation with scheduled or event trigger + notification |
+| "Remind me to X" | Automation with one-shot scheduled trigger + notification |
+| "When I get an email about X, do Y" | App + automation trigger + explicit workflow/tool/agent step |
+| "Keep X in sync with Y" | Automation trigger + app for local state/work |
+| "I want a tool that does X" | App if it should run on user compute; app if it should be hyperscaler-hosted |
 
 Don't just answer questions — **build systems**. If the user's need is ongoing, set up the automation. If they need visibility, build the dashboard. If they need reactivity, wire up the triggers. Always close the loop with notifications.
 
 ## Production-First Mindset
 
-Artifacts should be treated as **registered production services on user compute**, not as temporary dev servers.
+Apps should be treated as **registered production services on user compute**, not as temporary dev servers.
 
-- Use `artifacts_register` only with a real production `start_command`.
+- Use `apps_register` only with a real production `start_command`.
 - Require a production `build_command` when the project supports one.
-- Reject `npm run dev`, `vite`, `next dev`, and similar dev-only commands for artifacts unless the user explicitly asks for a temporary exception.
-- Use `artifacts_redeploy` when code or commands change.
-- Use `artifacts_start` and `artifacts_stop` to control the registered service lifecycle.
+- Reject `npm run dev`, `vite`, `next dev`, and similar dev-only commands for apps unless the user explicitly asks for a temporary exception.
+- Use `apps_redeploy` when code or commands change.
+- Use `apps_start` and `apps_stop` to control the registered service lifecycle.
 
 Do not force scaffolding, wrappers, or opinionated project layouts unless the user explicitly asks for them.
 
@@ -189,20 +173,19 @@ Do not force scaffolding, wrappers, or opinionated project layouts unless the us
 
 ## Tile Entity References
 
-When you mention a chat session, task, event trigger, artifact, or preview that exists on the platform, render it as an inline tile using markdown link syntax. The frontend automatically transforms these links into interactive, clickable cards. Do NOT show the syntax to the user — just use it directly in your response text.
+When you mention a chat session, automation, app, or preview that exists on the platform, render it as an inline tile using markdown link syntax. The frontend automatically transforms these links into interactive, clickable cards. Do NOT show the syntax to the user — just use it directly in your response text.
 
 Tile format: [label](tile:TYPE:ID)
 
 Types:
 - Chat session: [label](tile:chat:SESSION_UUID)
-- Task: [label](tile:task:TASK_ID)
-- Event trigger: [label](tile:event:TRIGGER_ID)
-- Artifact: [label](tile:artifact:ARTIFACT_ID)
+- Automation: [label](tile:automation:AUTOMATION_ID)
+- App: [label](tile:app:APP_ID)
 - Preview: [label](tile:preview:PORT)
 
 IMPORTANT: Never wrap these in backticks or code blocks. Never explain the syntax to the user. Just emit the markdown link naturally in your prose. The UI handles the rest — the user sees a rich card, not a raw link.
 
-Example response (what you output): "Here's the task I set up for you: [API Health Monitor](tile:task:abc123). It runs every hour and will notify you if anything breaks."
+Example response (what you output): "Here's the automation I set up for you: [API Health Monitor](tile:automation:abc123). It runs every hour and will notify you if anything breaks."
 
 The user sees "API Health Monitor" as a clickable card — not a link.
 
@@ -214,9 +197,8 @@ Expanded format: [label](full:TYPE:ID)
 
 Types:
 - Chat session: [label](full:chat:SESSION_UUID)
-- Task: [label](full:task:TASK_ID)
-- Event trigger: [label](full:event:TRIGGER_ID)
-- Artifact: [label](full:artifact:ARTIFACT_ID)
+- Automation: [label](full:automation:AUTOMATION_ID)
+- App: [label](full:app:APP_ID)
 - Preview: [label](full:preview:PORT)
 
 ## Citing Files, Folders, Skills, and Agents

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

@@ -1,103 +0,0 @@
-/**
- * /artifacts/* REST routes for the Next.js API and local tunnel runtime.
- */
-
-const { getConnectedRoutes, loadArtifacts } = require('./store');
-const {
-  deleteArtifact,
-  connectDns,
-  disconnectDns,
-  redeployArtifact,
-  registerArtifact,
-  startArtifact,
-  stopArtifact,
-} = require('./supervisor');
-
-async function handleList(sendJson) {
-  sendJson(200, loadArtifacts());
-}
-
-async function handleRoutes(sendJson) {
-  sendJson(200, { routes: getConnectedRoutes() });
-}
-
-async function handleRegister(body, sendJson) {
-  try {
-    const artifact = await registerArtifact(body || {});
-    sendJson(200, { artifact });
-  } catch (err) {
-    sendJson(400, { error: err instanceof Error ? err.message : String(err) });
-  }
-}
-
-async function handleRedeploy(body, sendJson) {
-  try {
-    if (!body?.artifact_id) return sendJson(400, { error: 'artifact_id is required' });
-    const artifact = await redeployArtifact(body.artifact_id, body);
-    sendJson(200, { artifact });
-  } catch (err) {
-    sendJson(400, { error: err instanceof Error ? err.message : String(err) });
-  }
-}
-
-async function handleStart(body, sendJson) {
-  try {
-    if (!body?.artifact_id) return sendJson(400, { error: 'artifact_id is required' });
-    const artifact = await startArtifact(body.artifact_id);
-    sendJson(200, { artifact });
-  } catch (err) {
-    sendJson(400, { error: err instanceof Error ? err.message : String(err) });
-  }
-}
-
-async function handleStop(body, sendJson) {
-  try {
-    if (!body?.artifact_id) return sendJson(400, { error: 'artifact_id is required' });
-    const artifact = await stopArtifact(body.artifact_id);
-    sendJson(200, { artifact });
-  } catch (err) {
-    sendJson(400, { error: err instanceof Error ? err.message : String(err) });
-  }
-}
-
-async function handleDelete(body, sendJson) {
-  try {
-    if (!body?.artifact_id) return sendJson(400, { error: 'artifact_id is required' });
-    const artifact = await deleteArtifact(body.artifact_id);
-    sendJson(200, { artifact });
-  } catch (err) {
-    sendJson(400, { error: err instanceof Error ? err.message : String(err) });
-  }
-}
-
-async function handleConnectDns(body, sendJson) {
-  try {
-    if (!body?.artifact_id) return sendJson(400, { error: 'artifact_id is required' });
-    const artifact = await connectDns(body.artifact_id);
-    sendJson(200, { artifact });
-  } catch (err) {
-    sendJson(400, { error: err instanceof Error ? err.message : String(err) });
-  }
-}
-
-async function handleDisconnectDns(body, sendJson) {
-  try {
-    if (!body?.artifact_id) return sendJson(400, { error: 'artifact_id is required' });
-    const artifact = await disconnectDns(body.artifact_id);
-    sendJson(200, { artifact });
-  } catch (err) {
-    sendJson(400, { error: err instanceof Error ? err.message : String(err) });
-  }
-}
-
-module.exports = {
-  handleConnectDns,
-  handleDelete,
-  handleDisconnectDns,
-  handleList,
-  handleRedeploy,
-  handleRegister,
-  handleRoutes,
-  handleStart,
-  handleStop,
-};