amalgm 0.1.44 → 0.1.47

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

@@ -9,8 +9,9 @@ const { promptText } = require('../input');
 const { runtimeEnv } = require('../auth');
 const { codexErrorMessage, normalizeCodexNotification } = require('../normalizers/codex');
 const { recordNativeEvent } = require('../recorder');
-const { toCodexMcpToml } = require('../tooling/mcp-bundle');
+const { relayedMcpServers, toCodexMcpToml } = require('../tooling/mcp-bundle');
 const { bundledCodexBinary, bundledCodexPathDirs, executableExists } = require('../tooling/native-binaries');
+const { syncCodexNativeConfig } = require('../tooling/native-config');
 const { composeSystemPrompt } = require('../tooling/system-prompt');
 
 class JsonLineRpc {
@@ -176,11 +177,167 @@ function isCompactCommand(text) {
   return String(text || '').trim().toLowerCase() === '/compact';
 }
 
+function readTextFile(file) {
+  try {
+    return fs.readFileSync(file, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function tomlSectionName(line) {
+  const match = String(line || '').match(/^\s*\[([^\]]+)\]\s*$/);
+  return match ? match[1].trim() : null;
+}
+
+function removeTopLevelKeys(toml, keys) {
+  const remove = new Set(keys);
+  let inTopLevel = true;
+  return String(toml || '')
+    .split(/\r?\n/)
+    .filter((line) => {
+      if (tomlSectionName(line)) inTopLevel = false;
+      if (!inTopLevel) return true;
+      const match = line.match(/^\s*([A-Za-z0-9_-]+)\s*=/);
+      return !match || !remove.has(match[1]);
+    })
+    .join('\n');
+}
+
+function removeTomlSections(toml, sectionNames) {
+  const remove = new Set(sectionNames);
+  let skipping = false;
+  const out = [];
+  for (const line of String(toml || '').split(/\r?\n/)) {
+    const section = tomlSectionName(line);
+    if (section) {
+      skipping = [...remove].some((name) => section === name || section.startsWith(`${name}.`));
+    }
+    if (!skipping) out.push(line);
+  }
+  return out.join('\n');
+}
+
+function ensureFeatureBoolean(toml, key, value) {
+  const lines = String(toml || '').split(/\r?\n/);
+  const sectionIndex = lines.findIndex((line) => tomlSectionName(line) === 'features');
+  const rendered = `${key} = ${value ? 'true' : 'false'}`;
+  if (sectionIndex === -1) {
+    return `${String(toml || '').trimEnd()}\n\n[features]\n${rendered}\n`;
+  }
+  let insertAt = lines.length;
+  for (let i = sectionIndex + 1; i < lines.length; i += 1) {
+    if (tomlSectionName(lines[i])) {
+      insertAt = i;
+      break;
+    }
+    if (new RegExp(`^\\s*${key}\\s*=`).test(lines[i])) {
+      lines[i] = rendered;
+      return lines.join('\n');
+    }
+  }
+  lines.splice(insertAt, 0, rendered);
+  return lines.join('\n');
+}
+
+function tomlQuoted(value) {
+  return JSON.stringify(String(value || ''));
+}
+
+function hookTrustBlocks(toml) {
+  const lines = String(toml || '').split(/\r?\n/);
+  const blocks = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    const section = tomlSectionName(lines[i]);
+    const match = section?.match(/^hooks\.state\."([^"]+)"$/);
+    if (!match) continue;
+    let end = lines.length;
+    for (let j = i + 1; j < lines.length; j += 1) {
+      if (tomlSectionName(lines[j])) {
+        end = j;
+        break;
+      }
+    }
+    blocks.push({ key: match[1], lines: lines.slice(i, end) });
+  }
+  return blocks;
+}
+
+function mirrorCodexHookTrust(toml, sourceDir, runtimeHome) {
+  if (!sourceDir || !runtimeHome) return toml;
+  const sourceHookPrefix = `${path.join(sourceDir, 'hooks.json')}:`;
+  const runtimePrefixes = [
+    `${path.join(runtimeHome, 'hooks.json')}:`,
+    `${path.join(runtimeHome, '.codex', 'hooks.json')}:`,
+  ];
+  const blocks = hookTrustBlocks(toml);
+  if (blocks.length === 0) return toml;
+  const existing = new Set(blocks.map((block) => block.key));
+  const additions = [];
+  for (const block of blocks) {
+    if (!block.key.startsWith(sourceHookPrefix)) continue;
+    const suffix = block.key.slice(sourceHookPrefix.length);
+    for (const prefix of runtimePrefixes) {
+      const nextKey = `${prefix}${suffix}`;
+      if (existing.has(nextKey)) continue;
+      existing.add(nextKey);
+      const lines = [...block.lines];
+      lines[0] = `[hooks.state.${tomlQuoted(nextKey)}]`;
+      additions.push(lines.join('\n'));
+    }
+  }
+  if (additions.length === 0) return toml;
+  const parent = /\n\s*\[hooks\.state\]\s*(?:\n|$)/.test(`\n${toml}`) ? '' : '\n[hooks.state]\n';
+  return `${String(toml || '').trimEnd()}${parent}\n${additions.join('\n\n')}\n`;
+}
+
+function generatedMcpSectionNames(contract) {
+  return relayedMcpServers(contract).map((server) => `mcp_servers.${server.name}`);
+}
+
+function buildCodexConfig(contract, existingConfig, syncInfo) {
+  const mcpToml = toCodexMcpToml(contract);
+  const topLevelKeys = [
+    ...(contract.authMethod === 'provider_auth' ? [] : ['model_provider']),
+    ...(contract.authMethod === 'amalgm' ? ['model_context_window', 'model_auto_compact_token_limit'] : []),
+  ];
+  let config = removeTopLevelKeys(existingConfig, topLevelKeys);
+  config = removeTomlSections(config, [
+    ...(contract.authMethod === 'amalgm' ? ['model_providers.amalgm'] : []),
+    ...generatedMcpSectionNames(contract),
+  ]);
+  config = mirrorCodexHookTrust(config, syncInfo?.sourceDir, contract.auth.runtimeHome);
+  if (fs.existsSync(path.join(contract.auth.runtimeHome, 'hooks.json'))) {
+    config = ensureFeatureBoolean(config, 'codex_hooks', true);
+  }
+  const generated = contract.authMethod === 'amalgm'
+    ? [
+        'model_provider = "amalgm"',
+        ...modelWindowConfigLines(contract),
+        '',
+        '[model_providers.amalgm]',
+        'name = "amalgm"',
+        `base_url = "${contract.auth.baseUrl}"`,
+        'env_key = "OPENAI_API_KEY"',
+        'wire_api = "responses"',
+        'requires_openai_auth = false',
+      ].join('\n')
+    : contract.authMethod === 'byok'
+      ? 'model_provider = "openai"'
+      : '';
+  return [
+    generated.trimEnd(),
+    String(config || '').trim(),
+    String(mcpToml || '').trim(),
+  ].filter(Boolean).join('\n\n') + '\n';
+}
+
 function writeConfig(contract) {
   const home = contract.auth.runtimeHome;
   if (!home) return;
   fs.mkdirSync(home, { recursive: true });
-  const mcpToml = toCodexMcpToml(contract);
+  const syncInfo = syncCodexNativeConfig(home);
+  const configPath = path.join(home, 'config.toml');
   if (contract.authMethod === 'provider_auth') {
     const sourceAuth = path.join(os.homedir(), '.codex', 'auth.json');
     const targetAuth = path.join(home, 'auth.json');
@@ -188,34 +345,10 @@ function writeConfig(contract) {
       fs.copyFileSync(sourceAuth, targetAuth);
       fs.chmodSync(targetAuth, 0o600);
     }
-    fs.writeFileSync(path.join(home, 'config.toml'), [
-      'model_provider = "openai"',
-      '',
-      mcpToml,
-    ].join('\n'), { mode: 0o600 });
+    fs.writeFileSync(configPath, buildCodexConfig(contract, readTextFile(configPath), syncInfo), { mode: 0o600 });
     return;
   }
-  if (contract.authMethod === 'amalgm') {
-    fs.writeFileSync(path.join(home, 'config.toml'), [
-      'model_provider = "amalgm"',
-      ...modelWindowConfigLines(contract),
-      '',
-      '[model_providers.amalgm]',
-      'name = "amalgm"',
-      `base_url = "${contract.auth.baseUrl}"`,
-      'env_key = "OPENAI_API_KEY"',
-      'wire_api = "responses"',
-      'requires_openai_auth = false',
-      '',
-      mcpToml,
-    ].join('\n'), { mode: 0o600 });
-  } else {
-    fs.writeFileSync(path.join(home, 'config.toml'), [
-      'model_provider = "openai"',
-      '',
-      mcpToml,
-    ].join('\n'), { mode: 0o600 });
-  }
+  fs.writeFileSync(configPath, buildCodexConfig(contract, readTextFile(configPath), syncInfo), { mode: 0o600 });
   fs.writeFileSync(path.join(home, 'auth.json'), JSON.stringify({
     auth_mode: 'apikey',
     OPENAI_API_KEY: contract.auth.tokenRef,
@@ -350,4 +483,15 @@ class CodexAdapter {
   }
 }
 
-module.exports = { CodexAdapter, __private: { modelWindowConfigLines, writeConfig } };
+module.exports = {
+  CodexAdapter,
+  __private: {
+    buildCodexConfig,
+    ensureFeatureBoolean,
+    mirrorCodexHookTrust,
+    modelWindowConfigLines,
+    removeTomlSections,
+    removeTopLevelKeys,
+    writeConfig,
+  },
+};

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

@@ -70,7 +70,7 @@ function coerceAuth(harness, requested) {
 }
 
 function runtimeHome({ amalgmDir, sessionId, harness, authMethod, tokenFingerprint }) {
-  if (authMethod === 'provider_auth' && harness !== 'codex') return null;
+  if (authMethod === 'provider_auth' && !['claude_code', 'codex'].includes(harness)) return null;
   const suffix = tokenFingerprint || 'default';
   return path.join(amalgmDir, 'runtime', sessionId, harness, suffix);
 }

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

@@ -5,6 +5,7 @@ const os = require('os');
 const path = require('path');
 const { AMALGM_DIR, DEFAULT_CWD, PROXY_BASE_URL, PROXY_TOKEN } = require('../chat-server/config');
 const { authEnvelope, coerceAuth, fingerprint } = require('./auth');
+const { runtimePort } = require('../../lib/runtime-manifest');
 
 function agentToHarness(agent) {
   const clean = String(agent || '').trim();
@@ -323,7 +324,7 @@ function createContract(payload, options = {}) {
   const fastMode = payload.fastMode === true;
   const cliModel = cliModelFor({ harness, modelId, cliModel: payload.cliModel, reasoningEffort });
   const cwd = resolveCwd(payload.cwd, options);
-  const localBaseUrl = options.localBaseUrl || `http://127.0.0.1:${options.port || process.env.CHAT_SERVER_PORT || 8084}`;
+  const localBaseUrl = options.localBaseUrl || `http://127.0.0.1:${options.port || runtimePort('chat-server')}`;
   const origin = normalizeOrigin({ ...payload, cwd });
   const auth = authEnvelope({
     harness,

package/runtime/scripts/chat-core/tooling/mcp-bundle.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { getRuntimeToken } = require('../../runtime-auth');
+const { runtimePort } = require('../../../lib/runtime-manifest');
 
 function headerArrayToRecord(headers) {
   const out = {};
@@ -49,12 +50,11 @@ function normalizeServer(server) {
 }
 
 function localBaseUrl(contract) {
-  return String(contract.localBaseUrl || `http://127.0.0.1:${process.env.CHAT_SERVER_PORT || 8084}`).replace(/\/$/, '');
+  return String(contract.localBaseUrl || `http://127.0.0.1:${runtimePort('chat-server')}`).replace(/\/$/, '');
 }
 
 function amalgmMcpServer(contract) {
-  const port = process.env.AMALGM_MCP_PORT || '8083';
-  const url = process.env.AMALGM_MCP_URL || `http://127.0.0.1:${port}/mcp`;
+  const url = process.env.AMALGM_MCP_URL || `http://127.0.0.1:${runtimePort('amalgm-mcp')}/mcp`;
   const headers = [
     { name: 'x-amalgm-runtime-token', value: getRuntimeToken() },
     { name: 'x-amalgm-session-id', value: contract.sessionId },

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

@@ -0,0 +1,133 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const EXCLUDED_DIR_NAMES = new Set([
+  '.cache',
+  '.npm',
+  '.tmp',
+  'cache',
+  'log',
+  'logs',
+  'projects',
+  'sessions',
+  'shell_snapshots',
+  'tmp',
+]);
+
+const EXCLUDED_FILE_PATTERNS = [
+  /^logs?_\d+\.sqlite(?:-.+)?$/i,
+  /^state_\d+\.sqlite(?:-.+)?$/i,
+  /^.*\.db-(?:shm|wal)$/i,
+  /^.*\.sqlite-(?:shm|wal)$/i,
+];
+
+function exists(p) {
+  try {
+    fs.accessSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function shouldCopyConfigPath(root, source) {
+  const relative = path.relative(root, source);
+  if (!relative || relative === '.') return true;
+  const parts = relative.split(path.sep);
+  if (parts.some((part) => EXCLUDED_DIR_NAMES.has(part))) return false;
+  const basename = path.basename(source);
+  return !EXCLUDED_FILE_PATTERNS.some((pattern) => pattern.test(basename));
+}
+
+function copyConfigTree(sourceDir, targetDir) {
+  if (!sourceDir || !targetDir || !exists(sourceDir)) return false;
+  if (path.resolve(sourceDir) === path.resolve(targetDir)) return true;
+  fs.mkdirSync(targetDir, { recursive: true });
+  fs.cpSync(sourceDir, targetDir, {
+    recursive: true,
+    force: true,
+    errorOnExist: false,
+    dereference: false,
+    filter: (source) => shouldCopyConfigPath(sourceDir, source),
+  });
+  return true;
+}
+
+function copyFileIfPresent(source, target) {
+  if (!exists(source)) return false;
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.copyFileSync(source, target);
+  try {
+    fs.chmodSync(target, fs.statSync(source).mode & 0o777);
+  } catch {}
+  return true;
+}
+
+function copyIntoHomeAlias(runtimeHome, dotDirName, sourceDir) {
+  if (!runtimeHome || !dotDirName || !sourceDir || !exists(sourceDir)) return;
+  const alias = path.join(runtimeHome, dotDirName);
+  try {
+    const stat = fs.lstatSync(alias);
+    if (stat.isSymbolicLink()) {
+      const target = fs.readlinkSync(alias);
+      if (target === '.' || path.resolve(runtimeHome, target) === path.resolve(runtimeHome)) return;
+      fs.rmSync(alias, { recursive: true, force: true });
+    } else if (stat.isDirectory()) {
+      copyConfigTree(sourceDir, alias);
+      return;
+    } else {
+      fs.rmSync(alias, { recursive: true, force: true });
+    }
+  } catch {}
+  try {
+    fs.symlinkSync('.', alias, 'dir');
+  } catch {
+    copyConfigTree(sourceDir, alias);
+  }
+}
+
+function syncCodexNativeConfig(runtimeHome) {
+  if (!runtimeHome) return null;
+  const nativeHome = os.homedir();
+  const sourceDir = path.join(nativeHome, '.codex');
+  fs.mkdirSync(runtimeHome, { recursive: true });
+  const copied = copyConfigTree(sourceDir, runtimeHome);
+  copyIntoHomeAlias(runtimeHome, '.codex', sourceDir);
+  copyConfigTree(path.join(nativeHome, '.codex-supermemory'), path.join(runtimeHome, '.codex-supermemory'));
+  copyFileIfPresent(path.join(nativeHome, '.codex-supermemory.log'), path.join(runtimeHome, '.codex-supermemory.log'));
+  return copied ? { sourceDir, runtimeHome } : null;
+}
+
+function syncClaudeNativeConfig(runtimeHome) {
+  if (!runtimeHome) return null;
+  const nativeHome = os.homedir();
+  const sourceDir = path.join(nativeHome, '.claude');
+  fs.mkdirSync(runtimeHome, { recursive: true });
+  const copied = copyConfigTree(sourceDir, runtimeHome);
+  copyIntoHomeAlias(runtimeHome, '.claude', sourceDir);
+  copyFileIfPresent(path.join(nativeHome, '.claude.json'), path.join(runtimeHome, '.claude.json'));
+  copyConfigTree(path.join(nativeHome, '.config', 'claude'), path.join(runtimeHome, '.config', 'claude'));
+  return copied ? { sourceDir, runtimeHome } : null;
+}
+
+function syncNativeHarnessConfig(contract) {
+  const runtimeHome = contract?.auth?.runtimeHome;
+  if (!runtimeHome) return null;
+  if (contract.harness === 'codex') return syncCodexNativeConfig(runtimeHome);
+  if (contract.harness === 'claude_code') return syncClaudeNativeConfig(runtimeHome);
+  return null;
+}
+
+module.exports = {
+  __private: {
+    copyConfigTree,
+    copyFileIfPresent,
+    shouldCopyConfigPath,
+  },
+  syncClaudeNativeConfig,
+  syncCodexNativeConfig,
+  syncNativeHarnessConfig,
+};

package/runtime/scripts/chat-server/config.js

@@ -14,6 +14,7 @@ const {
   proxyBaseUrl,
   readProxyToken,
 } = require('../proxy-token-store');
+const { runtimePort } = require('../../lib/runtime-manifest');
 
 // ── Paths ──────────────────────────────────────────────────────────────────
 // Set by the orchestrator (entrypoint.sh or electron/main.ts).
@@ -24,7 +25,7 @@ const DEFAULT_CWD = process.env.AMALGM_DEFAULT_CWD || '/workspace';
 
 // ── Server ──────────────────────────────────────────────────────────────────
 
-const PORT = parseInt(process.env.CHAT_SERVER_PORT || '8084', 10);
+const PORT = runtimePort('chat-server');
 const BIND_HOST = process.env.AMALGM_BIND_HOST || '0.0.0.0';
 
 // ── API keys / proxy ────────────────────────────────────────────────────────

package/runtime/scripts/local-gateway.js

@@ -22,6 +22,7 @@ const {
   isAuthorizedRuntimeRequest,
   runtimeAuthHeaders,
 } = require('./runtime-auth');
+const { runtimePort } = require('../lib/runtime-manifest');
 
 function loadPty() {
   const candidates = [
@@ -51,7 +52,7 @@ const BIND_HOST = process.env.AMALGM_BIND_HOST || '127.0.0.1';
 const OWNER = process.env.AMALGM_RUNTIME_SOURCE || 'local';
 const VERSION = process.env.npm_package_version || process.env.AMALGM_RUNTIME_VERSION || '';
 const DEFAULT_CWD = process.env.AMALGM_DEFAULT_CWD || os.homedir();
-const PORT = Number.parseInt(process.env.AMALGM_GATEWAY_PORT || '28781', 10);
+const PORT = runtimePort('local-gateway');
 const RUNTIME_TOKEN_HEADER = 'x-amalgm-runtime-token';
 const DEFAULT_DIAGNOSTIC_LOG_TAIL_BYTES = 256 * 1024;
 const MAX_DIAGNOSTIC_LOG_TAIL_BYTES = 2 * 1024 * 1024;
@@ -61,7 +62,6 @@ const DIAGNOSTIC_LOG_FILES = Object.freeze({
   'chat-server': 'chat-server.log',
   'local-gateway': 'local-gateway.log',
   'amalgm-mcp': 'amalgm-mcp.log',
-  'fs-watcher': 'fs-watcher.log',
   'port-monitor': 'port-monitor.log',
 });
 
@@ -77,10 +77,9 @@ const DIAGNOSTIC_LOG_ALIASES = Object.freeze({
 
 const SERVICE_PORTS = {
   gateway: PORT,
-  portMonitor: Number.parseInt(process.env.PORT_MONITOR_PORT || '8081', 10),
-  fsWatcher: Number.parseInt(process.env.FS_WATCHER_PORT || '8082', 10),
-  mcp: Number.parseInt(process.env.AMALGM_MCP_PORT || '8083', 10),
-  chat: Number.parseInt(process.env.CHAT_SERVER_PORT || '8084', 10),
+  portMonitor: runtimePort('port-monitor'),
+  mcp: runtimePort('amalgm-mcp'),
+  chat: runtimePort('chat-server'),
 };
 const LOCAL_AGENT_APP_PORT = Number.parseInt(process.env.AMALGM_LOCAL_APP_PORT || '3456', 10);
 
@@ -275,6 +274,14 @@ function readJson(file, fallback = null) {
   }
 }
 
+function runtimeStateOwnedHere(previous) {
+  if (!previous || typeof previous !== 'object' || Object.keys(previous).length === 0) return true;
+  return previous.pid === process.pid
+    || previous.gateway_pid === process.pid
+    || previous.pid === process.ppid
+    || previous.supervisor_pid === process.ppid;
+}
+
 function ensurePtySpawnHelperExecutable() {
   try {
     const nodePtyRoot = path.dirname(require.resolve(`${pty.packageName}/package.json`));
@@ -294,6 +301,10 @@ function ensurePtySpawnHelperExecutable() {
 function writeRuntimeState(actualPort) {
   const computer = readJson(path.join(AMALGM_DIR, 'computer.json'), null);
   const previous = readJson(STATE_FILE, {});
+  if (!runtimeStateOwnedHere(previous)) {
+    console.warn('[local-gateway] runtime-state belongs to another Amalgm runtime; skipping write');
+    return;
+  }
   writeJsonSecret(STATE_FILE, {
     ...previous,
     schema_version: 1,
@@ -312,7 +323,6 @@ function writeRuntimeState(actualPort) {
     ports: {
       gateway: actualPort,
       port_monitor: SERVICE_PORTS.portMonitor,
-      fs_watcher: SERVICE_PORTS.fsWatcher,
       amalgm_mcp: SERVICE_PORTS.mcp,
       chat_server: SERVICE_PORTS.chat,
     },
@@ -550,12 +560,6 @@ function serviceForPath(pathname) {
   if (MCP_PREFIXES.some((prefix) => pathname === prefix || pathname.startsWith(`${prefix}/`))) {
     return { port: SERVICE_PORTS.mcp, stripPrefix: '' };
   }
-  if (pathname === '/fs-watcher' || pathname.startsWith('/fs-watcher/')) {
-    return {
-      port: SERVICE_PORTS.fsWatcher,
-      stripPrefix: '/fs-watcher',
-    };
-  }
   if (PORT_MONITOR_PREFIXES.some((prefix) => pathname === prefix || pathname.startsWith(`${prefix}/`))) {
     return {
       port: SERVICE_PORTS.portMonitor,
@@ -971,10 +975,6 @@ server.on('upgrade', (req, socket, head) => {
       bridgePtyWebSocket(req, ws, url.pathname);
       return;
     }
-    if (url.pathname === '/ws/fs' || url.pathname === '/fs-watcher/ws') {
-      proxyWebSocket(req, ws, { port: SERVICE_PORTS.fsWatcher, stripPrefix: '' }, '/');
-      return;
-    }
     const target = serviceForPath(url.pathname);
     if (!target) {
       ws.close(1008, 'Unknown local gateway route');

package/runtime/scripts/port-monitor.js

@@ -4,27 +4,26 @@
  * Polls `ss -tlnp` every 2s and pushes
  * port_opened / port_closed events over SSE.
  *
- * Runs alongside chat-server on a separate port (8081).
+ * Runs alongside chat-server on the port-monitor runtime port.
  */
 
 const http = require('http');
 const fs = require('fs');
 const { execSync } = require('child_process');
 const { authorizeRuntimeHttp } = require('./runtime-auth');
+const { runtimePort } = require('../lib/runtime-manifest');
 
-const PORT = parseInt(process.env.PORT_MONITOR_PORT || '8081', 10);
+const PORT = runtimePort('port-monitor');
 const BIND_HOST = process.env.AMALGM_BIND_HOST || '0.0.0.0';
 const AGENT_PORT = parseInt(process.env.PORT || '8080');
-const FS_WATCHER_PORT = parseInt(process.env.FS_WATCHER_PORT || '8082', 10);
-const AMALGM_MCP_PORT = parseInt(process.env.AMALGM_MCP_PORT || '8083', 10);
-const CHAT_SERVER_PORT = parseInt(process.env.CHAT_SERVER_PORT || '8084', 10);
-const AMALGM_GATEWAY_PORT = parseInt(process.env.AMALGM_GATEWAY_PORT || '28781', 10);
+const AMALGM_MCP_PORT = runtimePort('amalgm-mcp');
+const CHAT_SERVER_PORT = runtimePort('chat-server');
+const AMALGM_GATEWAY_PORT = runtimePort('local-gateway');
 const LOCAL_AGENT_APP_PORT = parseInt(process.env.AMALGM_LOCAL_APP_PORT || '3456', 10);
 const INTERNAL_SERVICE_PORTS = new Set([
   AGENT_PORT,
   LOCAL_AGENT_APP_PORT,
   PORT,
-  FS_WATCHER_PORT,
   AMALGM_MCP_PORT,
   CHAT_SERVER_PORT,
   AMALGM_GATEWAY_PORT,
@@ -33,7 +32,7 @@ const INTERNAL_SERVICE_PORTS = new Set([
 const COMMON_DEV_PORTS = new Set([3000, 3001, 3002, 3003, 4000, 4200, 4321, 5000, 5001, 5173, 5174, 6006, 7000, 8000, 8001, 8888]);
 const BLOCKED_PREVIEW_PROCESSES = new Set(['.opencode', 'controlce', 'figma_age', 'figma_agent', 'loom', 'opencode', 'rapportd']);
 const DEV_PREVIEW_PROCESS_RE = /^(node|bun|deno|npm|pnpm|yarn|vite|next|astro|nuxt|svelte|remix|webpack|rspack|parcel|serve|http-server|tsx|python|python3|uvicorn|gunicorn|flask|django|ruby|rails|puma|php|java|go|air|cargo|trunk|dotnet|nginx)$/i;
-const INTERNAL_COMMAND_RE = /(?:^|\s)(?:node(?:-[^\s]+)?\s+)?[^\s]*(?:\/|\\)runtime(?:\/|\\)scripts(?:\/|\\)(?:port-monitor|fs-watcher|chat-server|local-gateway|amalgm-mcp(?:\/|\\)index)\.js(?:\s|$)/i;
+const INTERNAL_COMMAND_RE = /(?:^|\s)(?:node(?:-[^\s]+)?\s+)?[^\s]*(?:\/|\\)runtime(?:\/|\\)scripts(?:\/|\\)(?:port-monitor|chat-server|local-gateway|amalgm-mcp(?:\/|\\)index)\.js(?:\s|$)/i;
 const BLOCKED_COMMAND_RE = /(?:agent-browser|chromium|chrome)(?:\s|$)/i;
 
 const knownPorts = new Map();