amalgm 0.1.146 → 0.1.147

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

@@ -28,23 +28,19 @@ const restartTimers = new Map();
 // Crash containment: an app that keeps dying must not keep the supervisor busy
 // forever. Restarts back off exponentially, and after maxCrashes unexpected
 // exits inside windowMs the app is parked as 'degraded' until someone starts
-// it explicitly (or the runtime reboots). Apps are allowed to fail; they are
-// not allowed to consume the runtime.
+// it explicitly. The crash history lives ON THE APP RECORD (apps.json), not in
+// this process: a degraded app stays parked across runtime restarts, otherwise
+// a runtime-level restart loop hands every broken app a fresh crash budget.
 const APP_RESTART_POLICY = {
   initialDelayMs: 2000,
   maxDelayMs: 60_000,
   maxCrashes: 5,
   windowMs: 5 * 60_000,
 };
-const crashHistory = new Map();
 
-function recordCrash(appId) {
-  const now = Date.now();
-  const recent = (crashHistory.get(appId) || [])
-    .filter((time) => now - time <= APP_RESTART_POLICY.windowMs);
-  recent.push(now);
-  crashHistory.set(appId, recent);
-  return recent.length;
+function recentCrashes(app, now = Date.now()) {
+  const history = Array.isArray(app?.crashHistory) ? app.crashHistory : [];
+  return history.filter((time) => Number.isFinite(time) && now - time <= APP_RESTART_POLICY.windowMs);
 }
 
 function restartDelayMs(crashCount) {
@@ -358,13 +354,16 @@ function startAppProcess(app) {
     if (!current) return;
 
     if (current.desiredState === 'running' && current.keepAlive !== false) {
-      const crashes = recordCrash(app.id);
+      const history = recentCrashes(current);
+      history.push(Date.now());
+      const crashes = history.length;
       if (crashes >= APP_RESTART_POLICY.maxCrashes) {
         const windowMinutes = Math.round(APP_RESTART_POLICY.windowMs / 60_000);
         console.error(`[App:${app.id}] degraded: crashed ${crashes} times in ${windowMinutes}m; automatic restarts paused (logs: ${appLogPath(app.id)})`);
         updateAppMeta(app.id, {
           status: 'degraded',
           pid: null,
+          crashHistory: history,
           error: `Crashed ${crashes} times in ${windowMinutes} minutes; automatic restarts paused. Fix the app, then start it again. Logs: ${appLogPath(app.id)}`,
         });
         void syncRoutesBestEffort(`degraded:${app.id}`);
@@ -375,6 +374,7 @@ function startAppProcess(app) {
       updateAppMeta(app.id, {
         status: 'restarting',
         pid: null,
+        crashHistory: history,
         error: code === 0 ? null : `Process exited with code ${code}`,
       });
       void syncRoutesBestEffort(`exit:${app.id}`);
@@ -408,8 +408,8 @@ async function startApp(appId) {
   restartTimers.delete(appId);
 
   // A degraded app has no pending restart timer, so reaching here means an
-  // explicit start (user/API/boot) — give it a fresh crash budget.
-  if (app.status === 'degraded') crashHistory.delete(appId);
+  // explicit start (user/API) — give it a fresh crash budget.
+  if (app.status === 'degraded') updateAppMeta(appId, { crashHistory: [] });
 
   if (running.has(appId)) {
     const current = updateAppMeta(app.id, {
@@ -476,7 +476,6 @@ async function stopApp(appId, options = {}) {
     console.warn(`[Apps] Could not clean listeners for ${appId} on port ${app.port}: ${err.message}`);
   });
   running.delete(appId);
-  crashHistory.delete(appId);
   closeAppLog(appId);
 
   setTimeout(() => stopping.delete(appId), 1000);
@@ -484,6 +483,7 @@ async function stopApp(appId, options = {}) {
     desiredState: options.desiredState || 'stopped',
     status: 'stopped',
     pid: null,
+    crashHistory: [],
   });
   await syncRoutesBestEffort(`stop:${appId}`);
   return current;
@@ -630,6 +630,14 @@ async function startRegisteredApps() {
       updateAppMeta(app.id, { pid: null });
     }
 
+    // A degraded app stays parked across runtime restarts — its crash budget
+    // is spent until a user/API start resets it. Auto-starting it here would
+    // let a runtime-level restart loop re-arm every broken app on each boot.
+    if (app.status === 'degraded') {
+      console.warn(`[App:${app.id}] skipping autostart: degraded (${app.error || 'no error recorded'})`);
+      return;
+    }
+
     if (app.autostart !== false && app.desiredState === 'running') {
       await startApp(app.id).catch((err) => {
         updateAppMeta(app.id, { status: 'error', error: err.message, pid: null });

package/runtime/scripts/amalgm-mcp/index.js

@@ -87,6 +87,14 @@ async function ensureProxyToken() {
 }
 
 async function boot() {
+  const { listen } = require('./server/http');
+
+  // Bind the port and answer /healthz before any slow init (proxy token is a
+  // network call, store init hits disk). The parent supervisor kills children
+  // that don't answer within its cold-start window; a booting runtime must
+  // look alive first and warm up second.
+  await listen();
+
   await ensureProxyToken();
 
   const { ensureAutomationsStore } = require('./automations/store');
@@ -95,17 +103,15 @@ async function boot() {
   const { startAppRouteSyncLoop } = require('./apps/advertise');
   const { startRegisteredApps } = require('./apps/supervisor');
   const { startProjectContextService } = require('./project-context/store');
-  const { listen } = require('./server/http');
 
-  // Make sure every storage dir/file exists before we accept traffic.
   ensureAutomationsStore();
   ensureAgentsDirs();
   ensureAppsDirs();
   startProjectContextService();
 
-  await listen();
   await startRegisteredApps();
   startAppRouteSyncLoop();
+  require('./state/ports').startPortsBridge();
 }
 
 boot().catch((err) => {

package/runtime/scripts/amalgm-mcp/lib/chat-payloads.js

@@ -6,6 +6,14 @@ const { insertStateEvent, publishStateEvent } = require('../state/events');
 const CHAT_PAYLOADS_META_KEY = 'chat_payloads';
 const CHAT_PAYLOADS_RESOURCE = 'chat_payloads';
 
+// Records are keyed by UI tab id and nothing deletes them when a tab closes, so
+// the map grows forever without a sweep. GC of a live tab's record is safe:
+// before every launch the client re-publishes unless its own confirmed-write
+// memory is fresher than 10 minutes.
+const CHAT_PAYLOAD_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const CHAT_PAYLOAD_MAX_RECORDS = 300;
+let chatPayloadSweepDone = false;
+
 function isPlainObject(value) {
   return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }
@@ -51,17 +59,66 @@ function normalizeRecord(input, existing = null) {
   };
 }
 
+function recordTimestamp(record) {
+  const parsed = Date.parse(record?.updatedAt || '');
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function sweepChatPayloadsOnce() {
+  if (chatPayloadSweepDone) return;
+  chatPayloadSweepDone = true;
+  try {
+    const db = openLocalDb();
+    const event = db.transaction(() => {
+      const current = readPayloadMap();
+      const cutoff = Date.now() - CHAT_PAYLOAD_TTL_MS;
+      let kept = Object.values(current)
+        .filter((record) => isPlainObject(record) && cleanString(record.id))
+        .filter((record) => recordTimestamp(record) >= cutoff);
+      if (kept.length > CHAT_PAYLOAD_MAX_RECORDS) {
+        kept = kept
+          .sort((a, b) => recordTimestamp(b) - recordTimestamp(a))
+          .slice(0, CHAT_PAYLOAD_MAX_RECORDS);
+      }
+      if (kept.length === Object.keys(current).length) return null;
+
+      const next = {};
+      for (const record of kept) next[record.id] = record;
+      db.prepare(`
+        INSERT INTO local_meta (key, value, updated_at)
+        VALUES (?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+        ON CONFLICT(key) DO UPDATE SET
+          value = excluded.value,
+          updated_at = excluded.updated_at
+      `).run(CHAT_PAYLOADS_META_KEY, JSON.stringify(next));
+
+      return insertStateEvent(db, {
+        resource: CHAT_PAYLOADS_RESOURCE,
+        op: 'invalidate',
+        source: 'chat-payloads-gc',
+      });
+    })();
+
+    publishStateEvent(event);
+  } catch (error) {
+    console.warn('[chat-payloads] GC sweep failed:', error?.message || error);
+  }
+}
+
 function listChatPayloads() {
+  sweepChatPayloadsOnce();
   return readPayloadMap();
 }
 
 function getChatPayload(id) {
+  sweepChatPayloadsOnce();
   const payloadId = cleanString(id);
   if (!payloadId) return null;
   return readPayloadMap()[payloadId] || null;
 }
 
 function writeChatPayload(input, options = {}) {
+  sweepChatPayloadsOnce();
   const db = openLocalDb();
   let record;
   const event = db.transaction(() => {

package/runtime/scripts/amalgm-mcp/server/routes/health.js

@@ -1,27 +1,52 @@
 'use strict';
 
-const { loadAgents } = require('../../agents/store');
-const { loadApps } = require('../../apps/store');
 const { activeAgentConversations } = require('../../agents/talk');
-const { listAutomations } = require('../../automations/store');
+
+// /healthz is a liveness signal: the parent supervisor kills this process
+// after three slow answers, so the handler must never touch disk. Counts are
+// informational — serve a cached snapshot and refresh it off the request path.
+const COUNTS_TTL_MS = 30_000;
+let cachedCounts = { automations: 0, enabledAutomations: 0, apps: 0, customAgents: 0 };
+let countsRefreshedAt = 0;
+let countsRefreshing = false;
+
+function refreshCountsSoon() {
+  if (countsRefreshing || Date.now() - countsRefreshedAt < COUNTS_TTL_MS) return;
+  countsRefreshing = true;
+  setImmediate(() => {
+    try {
+      const { loadAgents } = require('../../agents/store');
+      const { loadApps } = require('../../apps/store');
+      const { listAutomations } = require('../../automations/store');
+      const automations = listAutomations();
+      cachedCounts = {
+        automations: automations.length,
+        enabledAutomations: automations.filter((automation) => automation.enabled !== false).length,
+        apps: loadApps().apps.length,
+        customAgents: loadAgents().agents.length,
+      };
+      countsRefreshedAt = Date.now();
+    } catch {
+      // Counts stay stale; liveness must not depend on store reads succeeding.
+    } finally {
+      countsRefreshing = false;
+    }
+  });
+}
 
 async function handleHealthRoutes(ctx) {
   if (ctx.pathname !== '/healthz') return false;
 
-  const agents = loadAgents();
-  const automations = listAutomations();
   ctx.sendJson(200, {
     status: 'ok',
     service: 'amalgm-mcp',
     runtime_label: process.env.AMALGM_RUNTIME_LABEL || 'main',
     runtime_instance_id: process.env.AMALGM_RUNTIME_INSTANCE_ID || '',
     pid: process.pid,
-    automations: automations.length,
-    enabledAutomations: automations.filter((automation) => automation.enabled !== false).length,
-    apps: loadApps().apps.length,
-    customAgents: agents.agents.length,
+    ...cachedCounts,
     activeAgentConversations: activeAgentConversations.size,
   });
+  refreshCountsSoon();
   return true;
 }
 

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

@@ -0,0 +1,98 @@
+'use strict';
+
+/**
+ * Bridges the standalone port-monitor service into the Local Live Store.
+ *
+ * Browsers used to poll /api/ports over the network (per open client, per
+ * visible computer, every 2.5s). The poll now lives here instead: loopback
+ * only, one per runtime, and it publishes a `ports` state event only when the
+ * port set actually changes — connected clients get it over the existing
+ * stream for free.
+ */
+
+const { appendStateEvent } = require('./events');
+
+const PORTS_RESOURCE = 'ports';
+const POLL_MS = 3000;
+
+let timer = null;
+let lastJson = null;
+let currentPorts = [];
+
+function portMonitorEndpoint() {
+  const { runtimePort } = require('../../../lib/runtime-manifest');
+  return `http://127.0.0.1:${runtimePort('port-monitor')}/api/ports`;
+}
+
+function runtimeAuthHeaders() {
+  const token = String(process.env.AMALGM_RUNTIME_TOKEN || '').trim();
+  return token ? { 'x-amalgm-runtime-token': token } : {};
+}
+
+function normalizePorts(ports) {
+  if (!Array.isArray(ports)) return [];
+  return ports
+    .filter((entry) => entry && Number.isInteger(entry.port))
+    .map((entry) => ({
+      port: entry.port,
+      processName: typeof entry.processName === 'string' ? entry.processName : null,
+    }))
+    .sort((a, b) => a.port - b.port);
+}
+
+function getCurrentPorts() {
+  return currentPorts;
+}
+
+async function pollOnce() {
+  let ports;
+  try {
+    const res = await fetch(portMonitorEndpoint(), { headers: runtimeAuthHeaders() });
+    if (!res.ok) return;
+    const data = await res.json().catch(() => null);
+    ports = normalizePorts(data?.ports);
+  } catch {
+    // port-monitor may not be up yet (it boots independently); keep the last
+    // known set and try again next tick.
+    return;
+  }
+
+  const json = JSON.stringify(ports);
+  if (json === lastJson) return;
+  lastJson = json;
+  currentPorts = ports;
+
+  try {
+    appendStateEvent({
+      resource: PORTS_RESOURCE,
+      op: 'replace',
+      value: ports,
+      source: 'ports-bridge',
+    });
+  } catch (error) {
+    console.warn('[PortsBridge] Failed to publish ports event:', error?.message || error);
+  }
+}
+
+function startPortsBridge() {
+  if (timer) return;
+  void pollOnce();
+  timer = setInterval(() => {
+    void pollOnce();
+  }, POLL_MS);
+  if (typeof timer.unref === 'function') timer.unref();
+}
+
+function stopPortsBridge() {
+  if (timer) {
+    clearInterval(timer);
+    timer = null;
+  }
+}
+
+module.exports = {
+  PORTS_RESOURCE,
+  getCurrentPorts,
+  startPortsBridge,
+  stopPortsBridge,
+};

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

@@ -68,8 +68,10 @@ function handleStream(req, res, query) {
     sendSseEvent(res, event);
   }
 
+  // A named event (not an SSE comment) so EventSource clients can observe it
+  // and detect a silently dead stream, e.g. tunnel frame drops.
   const heartbeat = setInterval(() => {
-    res.write(': heartbeat\n\n');
+    sendSseControl(res, 'ping', { t: Date.now() });
   }, 25_000);
 
   req.on('close', () => {

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

@@ -2,7 +2,7 @@
 
 const { currentSeq } = require('./events');
 
-const DEFAULT_RESOURCES = ['automations', 'triggers', 'workflows', 'automation_runs', 'workflow_cell_runs', 'agents', 'agent_configs', 'skills', 'apps', 'toolbox', 'tools', 'tool_actions', 'hooks', 'projects', 'workspaces', 'project_context', 'user_preferences', 'chat_payloads', 'mcp_connections', 'browser_profiles', 'browser_auth_bundles', 'browser_login_sessions'];
+const DEFAULT_RESOURCES = ['automations', 'triggers', 'workflows', 'automation_runs', 'workflow_cell_runs', 'agents', 'agent_configs', 'skills', 'apps', 'ports', 'toolbox', 'tools', 'tool_actions', 'hooks', 'projects', 'workspaces', 'project_context', 'user_preferences', 'chat_payloads', 'mcp_connections', 'browser_profiles', 'browser_auth_bundles', 'browser_login_sessions'];
 
 function normalizeResources(resources) {
   const values = resources ? String(resources).split(',') : DEFAULT_RESOURCES;
@@ -45,6 +45,8 @@ function readResource(resource, cache) {
       return require('../skills/store').listSkills();
     case 'apps':
       return require('../apps/store').loadApps().apps;
+    case 'ports':
+      return require('./ports').getCurrentPorts();
     case 'toolbox':
       cache.toolbox ||= require('../toolbox/service').defaultToolboxService.readCatalog();
       return cache.toolbox;

package/runtime/scripts/amalgm-mcp/tests/apps-crash-loop.test.js

@@ -13,8 +13,8 @@ process.env.AMALGM_RUNTIME_LABEL = 'test';
 process.env.AMALGM_WORKSPACES_DIR = path.join(process.env.AMALGM_DIR, 'workspaces');
 
 const { getApp, saveApps } = require('../apps/store');
-const { APP_RESTART_POLICY, startApp, stopApp } = require('../apps/supervisor');
-const { APPS_DIR } = require('../config');
+const { APP_RESTART_POLICY, startApp, startRegisteredApps, stopApp } = require('../apps/supervisor');
+const { APPS_DIR, APPS_FILE } = require('../config');
 
 function waitFor(predicate, label, timeoutMs = 10_000) {
   const deadline = Date.now() + timeoutMs;
@@ -73,6 +73,17 @@ test('a crash-looping app is parked as degraded instead of restarting forever',
   await new Promise((resolve) => setTimeout(resolve, 400));
   assert.equal(getApp('app-crash-loop').status, 'degraded');
 
+  // The crash budget is written on the app record itself, so a fresh runtime
+  // process would see it too — not lost with this process's memory.
+  const persisted = JSON.parse(fs.readFileSync(APPS_FILE, 'utf8'))
+    .apps.find((item) => item.id === 'app-crash-loop');
+  assert.equal(persisted.status, 'degraded');
+  assert.equal(persisted.crashHistory.length >= APP_RESTART_POLICY.maxCrashes, true);
+
+  // Boot (a "new runtime") must leave the parked app alone.
+  await startRegisteredApps();
+  assert.equal(getApp('app-crash-loop').status, 'degraded');
+
   // App output landed in the app's own log file, not the runtime log.
   const logFile = path.join(APPS_DIR, 'logs', 'app-crash-loop.log');
   await waitFor(() => fs.existsSync(logFile), 'app log file');

package/runtime/scripts/chat-core/adapters/cursor.js

@@ -49,13 +49,24 @@ function matchAcpModel(availableModels, requested) {
   if (clean === 'auto' || clean === 'default') clean = 'default';
   const findBase = (base) => models.find((m) => baseOf(m.modelId) === base)
     || models.find((m) => String(m.name || '').toLowerCase() === base.toLowerCase());
+  const acpBaseAliases = (base) => {
+    const aliases = [];
+    const claudeVersionFirst = String(base || '').match(/^claude-(4(?:\.\d+)?)-(opus|sonnet)(?:-.+)?$/);
+    if (claudeVersionFirst) {
+      const [, version, family] = claudeVersionFirst;
+      aliases.push(`claude-${family}-${version.replace('.', '-')}`);
+    }
+    return aliases;
+  };
   let candidate = clean;
   // Legacy amalgm cursor cliModels carry effort/speed suffixes ("gpt-5.3-codex-high",
   // "composer-2.5-fast") that ACP model ids do not; strip them until a base matches.
   for (let i = 0; i < 6; i += 1) {
-    const match = findBase(candidate);
-    if (match) return match;
-    const stripped = candidate.replace(/-(?:fast|thinking|low|medium|high|xhigh|max)$/, '');
+    for (const base of [candidate, ...acpBaseAliases(candidate)]) {
+      const match = findBase(base);
+      if (match) return match;
+    }
+    const stripped = candidate.replace(/-(?:extra-high|fast|thinking|none|low|medium|high|xhigh|max)$/, '');
     if (stripped === candidate) return null;
     candidate = stripped;
   }

package/runtime/scripts/chat-core/contract.js

@@ -60,6 +60,107 @@ function gatewayModelId(raw) {
   return bare;
 }
 
+const CURSOR_CLI_ALIASES = {
+  'composer-2': 'composer-2.5',
+  'composer-2-fast': 'composer-2.5-fast',
+  'claude-fable-5': 'claude-fable-5-high',
+  'claude-fable-5-thinking': 'claude-fable-5-thinking-high',
+  'claude-opus-4-8': 'claude-opus-4-8-high',
+  'claude-opus-4-8-thinking': 'claude-opus-4-8-thinking-high',
+  'claude-opus-4-7': 'claude-opus-4-7-xhigh',
+  'claude-opus-4-7-thinking': 'claude-opus-4-7-thinking-xhigh',
+  'claude-opus-4-6': 'claude-4.6-opus-high',
+  'claude-opus-4-6-thinking': 'claude-4.6-opus-high-thinking',
+  'claude-opus-4-5': 'claude-4.5-opus-high',
+  'claude-opus-4-5-thinking': 'claude-4.5-opus-high-thinking',
+  'claude-sonnet-5': 'claude-sonnet-5-high',
+  'claude-sonnet-5-thinking': 'claude-sonnet-5-thinking-high',
+  'claude-sonnet-4-6': 'claude-4.6-sonnet-medium',
+  'claude-sonnet-4-6-thinking': 'claude-4.6-sonnet-medium-thinking',
+  'gpt-5.5': 'gpt-5.5-medium',
+  'gpt-5.4': 'gpt-5.4-medium',
+  'gpt-5.4-mini': 'gpt-5.4-mini-medium',
+  'gpt-5.4-nano': 'gpt-5.4-nano-medium',
+  'grok-4.5': 'grok-4.5-xhigh',
+  'glm-5.2': 'glm-5.2-high',
+};
+
+const CURSOR_CANONICAL_MODEL_ALIASES = {
+  'cursor/composer-2': 'cursor/composer-2.5',
+  'cursor/composer-2-fast': 'cursor/composer-2.5-fast',
+  'anthropic/claude-fable-5': 'anthropic/claude-fable-5-high',
+  'anthropic/claude-fable-5-thinking': 'anthropic/claude-fable-5-thinking-high',
+  'anthropic/claude-opus-4.8': 'anthropic/claude-opus-4.8-high',
+  'anthropic/claude-opus-4.8-thinking': 'anthropic/claude-opus-4.8-thinking-high',
+  'anthropic/claude-opus-4.7': 'anthropic/claude-opus-4.7-xhigh',
+  'anthropic/claude-opus-4.7-thinking': 'anthropic/claude-opus-4.7-thinking-xhigh',
+  'anthropic/claude-opus-4.6': 'anthropic/claude-opus-4.6-high',
+  'anthropic/claude-opus-4.6-thinking': 'anthropic/claude-opus-4.6-high-thinking',
+  'anthropic/claude-opus-4.5': 'anthropic/claude-opus-4.5-high',
+  'anthropic/claude-opus-4.5-thinking': 'anthropic/claude-opus-4.5-high-thinking',
+  'anthropic/claude-sonnet-5': 'anthropic/claude-sonnet-5-high',
+  'anthropic/claude-sonnet-5-thinking': 'anthropic/claude-sonnet-5-thinking-high',
+  'anthropic/claude-sonnet-4.6': 'anthropic/claude-sonnet-4.6-medium',
+  'anthropic/claude-sonnet-4.6-thinking': 'anthropic/claude-sonnet-4.6-medium-thinking',
+  'openai/gpt-5.5': 'openai/gpt-5.5-medium',
+  'openai/gpt-5.4': 'openai/gpt-5.4-medium',
+  'openai/gpt-5.4-mini': 'openai/gpt-5.4-mini-medium',
+  'openai/gpt-5.4-nano': 'openai/gpt-5.4-nano-medium',
+  'google/gemini-3.1-pro-preview': 'google/gemini-3.1-pro',
+  'xai/grok-4.5': 'xai/grok-4.5-xhigh',
+  'zai/glm-5.2': 'zai/glm-5.2-high',
+};
+
+function cursorCliAlias(cliModel) {
+  return CURSOR_CLI_ALIASES[cliModel] || cliModel;
+}
+
+function cursorAnthropicCliModel(model) {
+  const versioned = model.match(/^claude-(opus|sonnet)-(4(?:\.\d+)?)(?:-(.+))?$/);
+  if (!versioned) {
+    return model.replace(/-(\d+)\.(\d+)(?=$|-)/, '-$1-$2');
+  }
+  const [, family, version, rawSuffix] = versioned;
+  const suffix = rawSuffix || '';
+  if (family === 'sonnet' && version === '4.6') {
+    if (!suffix) return 'claude-4.6-sonnet-medium';
+    if (suffix === 'thinking') return 'claude-4.6-sonnet-medium-thinking';
+    return `claude-4.6-sonnet-${suffix}`;
+  }
+  if (family === 'sonnet' && (version === '4.5' || version === '4')) {
+    return `claude-${version}-sonnet${suffix ? `-${suffix}` : ''}`;
+  }
+  if (family === 'opus' && version === '4.6') {
+    if (!suffix) return 'claude-4.6-opus-high';
+    if (suffix === 'thinking') return 'claude-4.6-opus-high-thinking';
+    return `claude-4.6-opus-${suffix}`;
+  }
+  if (family === 'opus' && version === '4.5') {
+    if (!suffix) return 'claude-4.5-opus-high';
+    if (suffix === 'thinking') return 'claude-4.5-opus-high-thinking';
+    return `claude-4.5-opus-${suffix}`;
+  }
+  return model.replace(/-(\d+)\.(\d+)(?=$|-)/, '-$1-$2');
+}
+
+function cursorCliModelFor(raw) {
+  const clean = String(raw || '').trim().replace(/^vercel\//i, '').toLowerCase();
+  const canonical = CURSOR_CANONICAL_MODEL_ALIASES[clean] || clean;
+  if (canonical.startsWith('cursor/')) return cursorCliAlias(canonical.slice('cursor/'.length));
+  if (canonical.startsWith('cursor-')) return cursorCliAlias(canonical.slice('cursor-'.length));
+  if (canonical.startsWith('openai/')) return canonical.slice('openai/'.length);
+  if (canonical.startsWith('google/')) return canonical.slice('google/'.length);
+  if (canonical.startsWith('moonshotai/')) return canonical.slice('moonshotai/'.length);
+  if (canonical.startsWith('zai/')) return canonical.slice('zai/'.length);
+  if (canonical.startsWith('xai/')) {
+    return canonical.slice('xai/'.length).replace(/^grok-4\.20/, 'grok-4-20');
+  }
+  if (canonical.startsWith('anthropic/')) {
+    return cursorAnthropicCliModel(canonical.slice('anthropic/'.length));
+  }
+  return cursorCliAlias(canonical);
+}
+
 function canonicalModel(modelId, harness) {
   const raw = String(modelId || '').trim();
   if (!raw) {
@@ -197,7 +298,7 @@ function cliModelFor({ harness, modelId, cliModel, reasoningEffort }) {
   }
   if (harness === 'cursor') {
     // The adapter matches this against cursor-agent's ACP availableModels.
-    return clean.replace(/^cursor\//, '');
+    return cursorCliModelFor(clean);
   }
   if (harness === 'pi') {
     // Pi's vercel-ai-gateway provider takes bare '<provider>/<model>' ids.

package/runtime/scripts/chat-core/normalizers/normalizer_spec.md

@@ -35,7 +35,7 @@ Cursor rides the generic ACP client (`../adapters/acp-client.js`) + `cursor.js`
 | `usage_update` / `PromptResponse.usage` | `usage.final` | ⚠️ mapped but **cursor emits neither today** — no token usage exists for this harness; snapshots are `billable:false, exact:false`, prompt usage would be `exact:true chat_turn` the day Cursor ships the ACP session-usage extension |
 | `session_info_update`, `available_commands_update`, `plan`, `current_mode_update`, `user_message_chunk` (session/load replay) | dropped | ❌ intentional |
 
-Sessions: one `cursor-agent acp` process per amalgm session; resume = `session/load` (full history replay is discarded — nothing subscribes during `create`). Model selection: `session/set_model` accepts ONLY exact ids from `availableModels` (base + bracket params); `matchAcpModel` resolves amalgm cliModels (bare base names, legacy effort/speed suffixes stripped) to those ids. Auth: provider_auth only — the login token lives in the macOS Keychain, so the managed home gets a `Library/Keychains` alias (`syncCursorProviderAuth`).
+Sessions: one `cursor-agent acp` process per amalgm session; resume = `session/load` (full history replay is discarded — nothing subscribes during `create`). Model selection: `session/set_model` accepts ONLY ids Cursor advertises over ACP. Amalgm keeps central ids separate (`anthropic/claude-sonnet-5-high`, `openai/gpt-5.5-medium`, `cursor/composer-2.5`) and `cliModelFor` translates them to current Cursor CLI-style ids (`claude-sonnet-5-high`, `claude-sonnet-5-thinking-high`, `claude-4.6-sonnet-medium`, `composer-2.5-fast`). `matchAcpModel` then resolves those cliModels to ACP `availableModels` ids; ACP uses base names plus bracket params, so version-first CLI names can map to family-first ACP bases (`claude-4.6-sonnet-medium` -> `claude-sonnet-4-6[...]`). Raw provider ids cannot be sent straight to Cursor; stale ids like `composer-2-fast` are aliases only. Auth: provider_auth only — the login token lives in the macOS Keychain, so the managed home gets a `Library/Keychains` alias (`syncCursorProviderAuth`).
 
 ---
 

package/runtime/scripts/chat-core/normalizers/usage_contract.md

@@ -264,6 +264,14 @@ We intentionally keep separate identities:
 `Opus` and `Opus 1M` can share the same billing model while using different
 context profiles.
 
+Cursor follows the same split but is not a billing surface for us: display /
+central ids may be provider-shaped (`anthropic/claude-sonnet-5-high`), while
+the runtime cliModel is a Cursor CLI-style token (`claude-sonnet-5-high`,
+`claude-4.6-sonnet-medium`, `composer-2.5-fast`). The ACP adapter may translate
+that again to a Cursor-advertised ACP id (`claude-sonnet-4-6[...]`). Cursor's
+`gatewayModelId` is for grouping/analytics only until Cursor emits real token
+usage.
+
 ## Provider mapping targets
 
 ### Claude Code

package/runtime/scripts/chat-core/tests/cursor.test.js

@@ -18,7 +18,11 @@ test('cursor harness resolves through contract model naming', () => {
   assert.equal(canonicalModel('cursor/composer-2.5', 'cursor'), 'cursor/composer-2.5');
   assert.equal(canonicalModel('anthropic/claude-opus-4.8', 'cursor'), 'anthropic/claude-opus-4.8');
   assert.equal(cliModelFor({ harness: 'cursor', modelId: 'cursor/composer-2.5' }), 'composer-2.5');
-  assert.equal(cliModelFor({ harness: 'cursor', modelId: 'anthropic/claude-opus-4.8', cliModel: 'claude-opus-4-8' }), 'claude-opus-4-8');
+  assert.equal(cliModelFor({ harness: 'cursor', modelId: 'cursor/composer-2-fast' }), 'composer-2.5-fast');
+  assert.equal(cliModelFor({ harness: 'cursor', modelId: 'anthropic/claude-sonnet-5' }), 'claude-sonnet-5-high');
+  assert.equal(cliModelFor({ harness: 'cursor', modelId: 'anthropic/claude-sonnet-5-thinking' }), 'claude-sonnet-5-thinking-high');
+  assert.equal(cliModelFor({ harness: 'cursor', modelId: 'anthropic/claude-sonnet-4.6' }), 'claude-4.6-sonnet-medium');
+  assert.equal(cliModelFor({ harness: 'cursor', modelId: 'anthropic/claude-opus-4.8', cliModel: 'claude-opus-4-8' }), 'claude-opus-4-8-high');
 });
 
 test('cursor is provider_auth-only with a stable per-agent CLI home', () => {
@@ -41,12 +45,19 @@ test('matchAcpModel resolves amalgm cliModels to exact ACP model ids', () => {
   const availableModels = [
     { modelId: 'default[]', name: 'Auto' },
     { modelId: 'composer-2.5[fast=true]', name: 'composer-2.5' },
+    { modelId: 'claude-sonnet-5[thinking=true,context=300k,effort=high]', name: 'claude-sonnet-5' },
+    { modelId: 'claude-sonnet-4-6[thinking=true,context=200k,effort=medium]', name: 'claude-sonnet-4-6' },
     { modelId: 'claude-opus-4-8[thinking=true,context=300k,effort=high,fast=false]', name: 'claude-opus-4-8' },
     { modelId: 'gpt-5.3-codex[reasoning=medium,fast=false]', name: 'gpt-5.3-codex' },
+    { modelId: 'gpt-5.5[context=272k,reasoning=medium,fast=false]', name: 'gpt-5.5' },
   ];
   assert.equal(matchAcpModel(availableModels, 'composer-2.5').modelId, 'composer-2.5[fast=true]');
   assert.equal(matchAcpModel(availableModels, 'cursor/composer-2.5').modelId, 'composer-2.5[fast=true]');
+  assert.equal(matchAcpModel(availableModels, 'composer-2.5-fast').modelId, 'composer-2.5[fast=true]');
   assert.equal(matchAcpModel(availableModels, 'auto').modelId, 'default[]');
+  assert.equal(matchAcpModel(availableModels, 'claude-sonnet-5-high').modelId, 'claude-sonnet-5[thinking=true,context=300k,effort=high]');
+  assert.equal(matchAcpModel(availableModels, 'claude-4.6-sonnet-medium').modelId, 'claude-sonnet-4-6[thinking=true,context=200k,effort=medium]');
+  assert.equal(matchAcpModel(availableModels, 'gpt-5.5-extra-high').modelId, 'gpt-5.5[context=272k,reasoning=medium,fast=false]');
   assert.equal(matchAcpModel(availableModels, 'claude-opus-4-8').modelId, 'claude-opus-4-8[thinking=true,context=300k,effort=high,fast=false]');
   // Legacy effort/speed suffixes strip down to the ACP base model.
   assert.equal(matchAcpModel(availableModels, 'gpt-5.3-codex-high').modelId, 'gpt-5.3-codex[reasoning=medium,fast=false]');