amalgm 0.1.78 → 0.1.79

package/README.md

@@ -9,8 +9,8 @@ amalgm doctor
 amalgm start
 ```
 
-To move an existing install to the newest stable published build, run `amalgm update`.
-Set `AMALGM_AUTO_UPDATE=1` when running `amalgm start` to let the CLI update itself to the latest stable release before launching.
+To move an existing install to the newest stable published build immediately, run `amalgm update`.
+`amalgm start` checks for updates before launch by default; set `AMALGM_AUTO_UPDATE=0` or `AMALGM_DISABLE_AUTO_UPDATE=1` to opt out.
 
 `amalgm login` opens a browser approval page, then registers the machine and stores its local tunnel/computer record in `~/.amalgm/computer.json`.
 
@@ -34,6 +34,8 @@ amalgm run
 - Linux host with real user systemd: systemd user service
 - random/container shell where no service manager is available: portable best-effort watchdog
 
+Running service-managed runtimes also check for updates in the background. Normal updates restart only when chat/tunnel work is idle; critical updates can restart immediately. If the runtime is not service-managed, background updates are installed but the running process stays on the old code until it is manually restarted.
+
 The runtime supervisor keeps the declared local essentials alive:
 
 - port monitor on `8081`

package/lib/cli.js

@@ -28,7 +28,6 @@ const {
 } = require('./paths');
 const {
   normalizeRuntimeLabel,
-  npmTagForRuntimeLabel,
   sanitizeScopeSegment,
 } = require('./runtime-identity');
 const { startSupervisor } = require('./supervisor');
@@ -65,6 +64,10 @@ const {
   ensureAgentCommandShims,
   ensureNativeBinaries,
 } = require('../runtime/scripts/chat-core/tooling/native-binaries');
+const {
+  shouldAutoUpdate,
+  updatePackage,
+} = require('./updater');
 
 const PACKAGE_VERSION = require('../package.json').version;
 const SETUP_CODE_LENGTH = 16;
@@ -107,7 +110,7 @@ function usage() {
     '',
     'Usage:',
     '  amalgm login [--app-url https://amalgm.ai] [--name "My Mac"] [--setup-code ABCD-EFGH-JKLM-NPQR] [--no-open] [--no-poll]',
-    '  amalgm start [--foreground] [--local-only] [--branch main|preview] [--user <user-id>]',
+    '  amalgm start [--foreground] [--local-only] [--no-auto-update] [--branch main|preview] [--user <user-id>]',
     '  amalgm run [--local-only]',
     '  amalgm stop',
     '  amalgm status',
@@ -119,7 +122,8 @@ function usage() {
     '',
     'Environment:',
     '  AMALGM_APP_URL        Web app base URL for login/register',
-    '  AMALGM_AUTO_UPDATE    Set to 1 to update to the latest stable release before start',
+    '  AMALGM_AUTO_UPDATE    Auto-update before start unless set to 0/false/off',
+    '  AMALGM_DISABLE_AUTO_UPDATE Set to 1 to disable startup/background auto-updates',
     '  AMALGM_DIR            Explicit runtime state dir override',
     '  AMALGM_HOME           Runtime state root (default ~/.amalgm)',
     '  AMALGM_RUNTIME_LABEL  Runtime label: main, preview, or local',
@@ -197,13 +201,21 @@ function hasRequiredComputerFields(record) {
 }
 
 const SAFE_DAEMON_ENV_KEYS = [
+  'AMALGM_AUTO_UPDATE',
   'AMALGM_BIND_HOST',
   'AMALGM_BRANCH',
   'AMALGM_DEFAULT_CWD',
+  'AMALGM_DISABLE_AUTO_UPDATE',
   'AMALGM_GATEWAY_PORT',
   'AMALGM_HOME',
   'AMALGM_MCP_PORT',
   'AMALGM_NATIVE_NODE_MODULES',
+  'AMALGM_UPDATE_CHECK_INTERVAL_MS',
+  'AMALGM_UPDATE_CRITICAL',
+  'AMALGM_UPDATE_IDLE_TIMEOUT_MS',
+  'AMALGM_UPDATE_INITIAL_DELAY_MS',
+  'AMALGM_UPDATE_IDLE_POLL_MS',
+  'AMALGM_AUTO_UPDATE_CRITICAL',
   'AMALGM_RUNTIME_INSTANCE_ID',
   'AMALGM_RUNTIME_LABEL',
   'AMALGM_RUNTIME_STATE_DIR',
@@ -421,91 +433,6 @@ function commandExists(command) {
   });
 }
 
-function parseSemver(value) {
-  const [core, prerelease = ''] = String(value || '').trim().replace(/^v/, '').split('-', 2);
-  const parts = core.split('.').map((part) => Number.parseInt(part, 10));
-  return {
-    major: Number.isFinite(parts[0]) ? parts[0] : 0,
-    minor: Number.isFinite(parts[1]) ? parts[1] : 0,
-    patch: Number.isFinite(parts[2]) ? parts[2] : 0,
-    prerelease: prerelease ? prerelease.split('.') : [],
-  };
-}
-
-function comparePrerelease(left, right) {
-  if (left.length === 0 && right.length === 0) return 0;
-  if (left.length === 0) return 1;
-  if (right.length === 0) return -1;
-
-  const length = Math.max(left.length, right.length);
-  for (let i = 0; i < length; i += 1) {
-    const a = left[i];
-    const b = right[i];
-    if (a === undefined) return -1;
-    if (b === undefined) return 1;
-    const aNum = /^\d+$/.test(a) ? Number.parseInt(a, 10) : null;
-    const bNum = /^\d+$/.test(b) ? Number.parseInt(b, 10) : null;
-    if (aNum !== null && bNum !== null && aNum !== bNum) return aNum > bNum ? 1 : -1;
-    if (aNum !== null && bNum === null) return -1;
-    if (aNum === null && bNum !== null) return 1;
-    if (a !== b) return a > b ? 1 : -1;
-  }
-  return 0;
-}
-
-function compareVersions(left, right) {
-  const a = parseSemver(left);
-  const b = parseSemver(right);
-  for (const key of ['major', 'minor', 'patch']) {
-    if (a[key] !== b[key]) return a[key] > b[key] ? 1 : -1;
-  }
-  return comparePrerelease(a.prerelease, b.prerelease);
-}
-
-function npmCommand() {
-  return process.platform === 'win32' ? 'npm.cmd' : 'npm';
-}
-
-function npmInstallTag(options = {}) {
-  const explicit = options.tag || options.channel;
-  if (explicit && explicit !== true) return String(explicit).replace(/^@/, '');
-  return npmTagForRuntimeLabel(AMALGM_RUNTIME_LABEL);
-}
-
-function npmPackageVersionForTag(tag) {
-  const result = spawnSync(npmCommand(), ['view', `amalgm@${tag}`, 'version', '--json'], {
-    encoding: 'utf8',
-    timeout: 15000,
-    env: {
-      ...process.env,
-      npm_config_audit: 'false',
-      npm_config_fund: 'false',
-    },
-  });
-  if (result.status !== 0) {
-    const detail = String(result.stderr || result.stdout || '').trim();
-    throw new Error(`Could not check npm dist-tag "${tag}". ${detail}`);
-  }
-
-  const raw = String(result.stdout || '').trim();
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return raw.replace(/^"|"$/g, '');
-  }
-}
-
-function installNpmPackageTag(tag) {
-  return spawnSync(npmCommand(), ['install', '-g', `amalgm@${tag}`], {
-    stdio: 'inherit',
-    env: {
-      ...process.env,
-      npm_config_audit: 'false',
-      npm_config_fund: 'false',
-    },
-  });
-}
-
 function openBrowser(url) {
   const command =
     process.platform === 'darwin'
@@ -819,22 +746,21 @@ function ensureAgentRuntimeCommands(options = {}) {
 }
 
 async function update(options = {}) {
-  const tag = npmInstallTag(options);
-  const targetVersion = npmPackageVersionForTag(tag);
-  if (!targetVersion) throw new Error(`npm did not return a version for amalgm@${tag}`);
+  const result = await updatePackage({
+    ...options,
+    currentVersion: PACKAGE_VERSION,
+    onOutput: (text, stream) => {
+      if (stream === 'stderr') process.stderr.write(text);
+      else process.stdout.write(text);
+    },
+  });
 
-  if (compareVersions(targetVersion, PACKAGE_VERSION) <= 0) {
-    console.log(`Amalgm is already current for ${tag}: ${PACKAGE_VERSION}`);
+  if (!result.updated) {
+    console.log(`Amalgm is already current for ${result.tag}: ${PACKAGE_VERSION}`);
     return false;
   }
 
-  console.log(`Updating Amalgm from ${PACKAGE_VERSION} to ${targetVersion} (${tag}).`);
-  const result = installNpmPackageTag(tag);
-  if (result.status !== 0) {
-    throw new Error(`npm install -g amalgm@${tag} failed with status ${result.status ?? result.signal ?? 'unknown'}`);
-  }
-
-  console.log(`Amalgm updated to ${targetVersion}.`);
+  console.log(`Amalgm updated from ${PACKAGE_VERSION} to ${result.targetVersion} (${result.tag}).`);
   const pid = readPid();
   if (isPidRunning(pid)) {
     console.log('A previous Amalgm daemon is still running. Run `amalgm stop && amalgm start` to restart it with the new package.');
@@ -843,7 +769,9 @@ async function update(options = {}) {
 }
 
 async function updateBeforeStartIfRequested(options = {}) {
-  const requested = options['auto-update'] || process.env.AMALGM_AUTO_UPDATE === '1';
+  const requested = !options['no-auto-update']
+    && process.env.AMALGM_AUTO_UPDATE_RELAUNCHED !== '1'
+    && shouldAutoUpdate();
   if (!requested) return false;
 
   try {
@@ -854,11 +782,28 @@ async function updateBeforeStartIfRequested(options = {}) {
   }
 }
 
+function relaunchCurrentCommandAfterUpdate() {
+  console.log('Launching the updated Amalgm package.');
+  const result = spawnSync(process.execPath, process.argv.slice(1), {
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      AMALGM_AUTO_UPDATE_RELAUNCHED: '1',
+    },
+  });
+  if (result.error) throw result.error;
+  if (result.signal) {
+    process.kill(process.pid, result.signal);
+    return 1;
+  }
+  return Number.isInteger(result.status) ? result.status : 0;
+}
+
 async function start(options) {
   ensureBaseDirs();
 
   if (await updateBeforeStartIfRequested(options)) {
-    console.log('Run `amalgm start` again to launch the updated package.');
+    process.exitCode = relaunchCurrentCommandAfterUpdate();
     return;
   }
 

package/lib/paths.js

@@ -40,6 +40,7 @@ const AUTH_FILE = path.join(AMALGM_DIR, 'auth.json');
 const RUNTIME_TOKEN_FILE = path.join(AMALGM_RUNTIME_STATE_DIR, 'runtime-token.json');
 const PID_FILE = path.join(AMALGM_RUNTIME_STATE_DIR, 'amalgm.pid');
 const RUNTIME_STATE_FILE = path.join(AMALGM_RUNTIME_STATE_DIR, 'runtime-state.json');
+const AUTO_UPDATE_STATE_FILE = path.join(AMALGM_RUNTIME_STATE_DIR, 'auto-update-state.json');
 const LOG_DIR = path.join(AMALGM_RUNTIME_STATE_DIR, 'logs');
 const SERVICE_DIR = path.join(AMALGM_RUNTIME_STATE_DIR, 'service');
 const SERVICE_PID_FILE = path.join(AMALGM_RUNTIME_STATE_DIR, 'amalgm-service.pid');
@@ -57,6 +58,7 @@ module.exports = {
   AMALGM_RUNTIME_LABEL,
   AMALGM_RUNTIME_USER_SCOPE,
   AUTH_FILE,
+  AUTO_UPDATE_STATE_FILE,
   COMPUTER_FILE,
   DEFAULT_APP_URL,
   DEVICE_FILE,

package/lib/service.js

@@ -38,9 +38,11 @@ const AMALGM_BIN = path.join(PACKAGE_ROOT, 'bin', 'amalgm.js');
 const SERVICE_ENV_KEYS = [
   'AMALGM_APP_URL',
   'AMALGM_AUTH_BACKUP_ENABLED',
+  'AMALGM_AUTO_UPDATE',
   'AMALGM_BIND_HOST',
   'AMALGM_CREATE_AUTH_WATCH_DIRS',
   'AMALGM_DEFAULT_CWD',
+  'AMALGM_DISABLE_AUTO_UPDATE',
   'AMALGM_GATEWAY_PORT',
   'AMALGM_HOME',
   'AMALGM_RUNTIME_INSTANCE_ID',
@@ -50,6 +52,12 @@ const SERVICE_ENV_KEYS = [
   'AMALGM_NATIVE_NODE_MODULES',
   'AMALGM_PROJECTS_DIR',
   'AMALGM_SKIP_NATIVE_INSTALL',
+  'AMALGM_UPDATE_CHECK_INTERVAL_MS',
+  'AMALGM_UPDATE_CRITICAL',
+  'AMALGM_UPDATE_IDLE_TIMEOUT_MS',
+  'AMALGM_UPDATE_INITIAL_DELAY_MS',
+  'AMALGM_UPDATE_IDLE_POLL_MS',
+  'AMALGM_AUTO_UPDATE_CRITICAL',
   'AMALGM_WORKSPACES_DIR',
   'CHAT_SERVER_PORT',
   'ELECTRON_RUN_AS_NODE',

package/lib/supervisor.js

@@ -12,6 +12,7 @@ const {
   AMALGM_DIR,
   AMALGM_BRANCH,
   AMALGM_HOME,
+  AUTO_UPDATE_STATE_FILE,
   LOG_DIR,
   PID_FILE,
   AMALGM_RUNTIME_INSTANCE_ID,
@@ -44,6 +45,11 @@ const {
   runtimePortsState,
   runtimeServiceScripts,
 } = require('./runtime-manifest');
+const {
+  checkForUpdate,
+  shouldAutoUpdate,
+  updatePackage,
+} = require('./updater');
 const PACKAGE_VERSION = require('../package.json').version;
 
 const CHILD_RESTART_POLICY = {
@@ -61,6 +67,13 @@ const CHILD_HEALTH_POLICY = {
   maxFailures: 3,
 };
 
+const AUTO_UPDATE_POLICY = {
+  checkIntervalMs: 15 * 60_000,
+  initialDelayMs: 60_000,
+  idlePollMs: 10_000,
+  idleTimeoutMs: 2_500,
+};
+
 function ensureDir(dir, mode = 0o700) {
   fs.mkdirSync(dir, { recursive: true, mode });
   try {
@@ -374,6 +387,304 @@ function appendServiceState(name, update) {
   updateRuntimeState({ services: next });
 }
 
+function numberFromEnv(name, fallback, minimum = 0) {
+  const value = Number(process.env[name]);
+  if (!Number.isFinite(value) || value <= 0) return fallback;
+  return Math.max(minimum, value);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    if (typeof timer.unref === 'function') timer.unref();
+  });
+}
+
+function writeAutoUpdateState(update) {
+  const current = readJson(AUTO_UPDATE_STATE_FILE, {});
+  const next = {
+    ...current,
+    ...update,
+    updated_at: new Date().toISOString(),
+  };
+  writeJsonSecret(AUTO_UPDATE_STATE_FILE, next);
+  updateRuntimeState({
+    auto_update: {
+      status: next.status,
+      current_version: next.current_version || PACKAGE_VERSION,
+      target_version: next.target_version || null,
+      tag: next.tag || null,
+      critical: !!next.critical,
+      service_managed: !!next.service_managed,
+      last_checked_at: next.last_checked_at || null,
+      last_error: next.last_error || null,
+      active_turns: next.active_turns ?? null,
+      mcp_active: next.mcp_active ?? null,
+      tunnel_active: next.tunnel_active ?? null,
+    },
+  });
+  return next;
+}
+
+function localJsonRequest(port, requestPath, runtimeToken, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const req = http.request(
+      {
+        host: '127.0.0.1',
+        port,
+        path: requestPath,
+        method: 'GET',
+        timeout: timeoutMs,
+        headers: runtimeToken ? { 'x-amalgm-runtime-token': runtimeToken } : {},
+      },
+      (res) => {
+        const chunks = [];
+        res.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+        res.on('end', () => {
+          const body = Buffer.concat(chunks).toString('utf8');
+          if (res.statusCode < 200 || res.statusCode >= 300) {
+            reject(new Error(`HTTP ${res.statusCode}: ${body}`));
+            return;
+          }
+          try {
+            resolve(body ? JSON.parse(body) : {});
+          } catch (error) {
+            reject(error);
+          }
+        });
+      },
+    );
+    req.on('timeout', () => {
+      req.destroy(new Error('request timed out'));
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+async function runtimeIdleStatus({ ports, runtimeToken, tunnels }) {
+  const tunnelActive = tunnels.reduce((sum, tunnel) => (
+    sum + (typeof tunnel.activeCount === 'function' ? Number(tunnel.activeCount()) || 0 : 0)
+  ), 0);
+  const timeoutMs = numberFromEnv('AMALGM_UPDATE_IDLE_TIMEOUT_MS', AUTO_UPDATE_POLICY.idleTimeoutMs, 500);
+  const [chat, mcp] = await Promise.all([
+    localJsonRequest(ports.chatServer, '/runtime-idle', runtimeToken, timeoutMs),
+    localJsonRequest(ports.amalgmMcp, '/healthz', runtimeToken, timeoutMs),
+  ]);
+  const activeTurns = Number(chat?.active_turns) || 0;
+  const mcpActive = Number(mcp?.activeAgentConversations) || 0;
+  return {
+    idle: activeTurns === 0 && mcpActive === 0 && tunnelActive === 0,
+    active_turns: activeTurns,
+    mcp_active: mcpActive,
+    tunnel_active: tunnelActive,
+  };
+}
+
+function envFlag(name) {
+  const value = String(process.env[name] || '').trim().toLowerCase();
+  return ['1', 'true', 'yes', 'on'].includes(value);
+}
+
+function isServiceManaged() {
+  return envFlag('AMALGM_SERVICE_MANAGED');
+}
+
+function isCriticalUpdate(check) {
+  if (check?.critical === true || check?.required === true) return true;
+  return envFlag('AMALGM_UPDATE_CRITICAL') || envFlag('AMALGM_AUTO_UPDATE_CRITICAL');
+}
+
+function createAutoUpdateManager({ ports, runtimeToken, tunnels, foreground, requestRestart }) {
+  let stopped = false;
+  let timer = null;
+  let inFlight = false;
+  let installedUpdate = false;
+  const checkIntervalMs = numberFromEnv(
+    'AMALGM_UPDATE_CHECK_INTERVAL_MS',
+    AUTO_UPDATE_POLICY.checkIntervalMs,
+    60_000,
+  );
+  const initialDelayMs = numberFromEnv(
+    'AMALGM_UPDATE_INITIAL_DELAY_MS',
+    AUTO_UPDATE_POLICY.initialDelayMs,
+    5_000,
+  );
+  const idlePollMs = numberFromEnv(
+    'AMALGM_UPDATE_IDLE_POLL_MS',
+    AUTO_UPDATE_POLICY.idlePollMs,
+    1_000,
+  );
+  const serviceManaged = isServiceManaged();
+
+  function log(message, stream = 'stdout') {
+    const line = `[auto-update] ${message}`;
+    if (foreground) {
+      if (stream === 'stderr') console.error(line);
+      else console.log(line);
+    }
+  }
+
+  function schedule(delayMs) {
+    if (stopped || installedUpdate || timer) return;
+    timer = setTimeout(() => {
+      timer = null;
+      void checkAndUpdate();
+    }, delayMs);
+    if (typeof timer.unref === 'function') timer.unref();
+  }
+
+  async function waitForIdleAndRestart(check) {
+    const critical = isCriticalUpdate(check);
+    if (!serviceManaged) {
+      writeAutoUpdateState({
+        status: critical ? 'critical_restart_required' : 'restart_required',
+        current_version: PACKAGE_VERSION,
+        target_version: check.targetVersion,
+        tag: check.tag,
+        critical,
+        service_managed: false,
+        idle_blocked_reason: 'runtime is not service-managed',
+      });
+      log(`updated to ${check.targetVersion}; restart required because this runtime is not service-managed`);
+      return;
+    }
+
+    if (critical) {
+      writeAutoUpdateState({
+        status: 'critical_restart_pending',
+        current_version: PACKAGE_VERSION,
+        target_version: check.targetVersion,
+        tag: check.tag,
+        critical: true,
+        service_managed: true,
+        idle_blocked_reason: null,
+      });
+      log(`critical update installed; restarting into ${check.targetVersion}`);
+      requestRestart('critical_auto_update');
+      return;
+    }
+
+    while (!stopped) {
+      let idle;
+      try {
+        idle = await runtimeIdleStatus({ ports, runtimeToken, tunnels });
+      } catch (error) {
+        idle = {
+          idle: false,
+          active_turns: null,
+          mcp_active: null,
+          tunnel_active: null,
+          reason: error.message,
+        };
+      }
+
+      writeAutoUpdateState({
+        status: 'restart_pending',
+        current_version: PACKAGE_VERSION,
+        target_version: check.targetVersion,
+        tag: check.tag,
+        critical: false,
+        service_managed: true,
+        active_turns: idle.active_turns,
+        mcp_active: idle.mcp_active,
+        tunnel_active: idle.tunnel_active,
+        idle_blocked_reason: idle.idle ? null : idle.reason || 'runtime is busy',
+      });
+
+      if (idle.idle) {
+        log(`restarting into ${check.targetVersion}`);
+        requestRestart('auto_update');
+        return;
+      }
+      await sleep(idlePollMs);
+    }
+  }
+
+  async function checkAndUpdate() {
+    if (stopped || inFlight || installedUpdate) return;
+    inFlight = true;
+    const checkedAt = new Date().toISOString();
+    try {
+      writeAutoUpdateState({
+        status: 'checking',
+        current_version: PACKAGE_VERSION,
+        target_version: null,
+        tag: null,
+        service_managed: serviceManaged,
+        last_checked_at: checkedAt,
+        last_error: null,
+      });
+      const check = await checkForUpdate({ currentVersion: PACKAGE_VERSION });
+      if (!check.updateAvailable) {
+        writeAutoUpdateState({
+          status: 'current',
+          current_version: PACKAGE_VERSION,
+          target_version: check.targetVersion,
+          tag: check.tag,
+          service_managed: serviceManaged,
+          last_checked_at: checkedAt,
+          last_error: null,
+        });
+        return;
+      }
+
+      log(`installing ${check.targetVersion} from ${check.tag}`);
+      writeAutoUpdateState({
+        status: 'installing',
+        current_version: PACKAGE_VERSION,
+        target_version: check.targetVersion,
+        tag: check.tag,
+        critical: isCriticalUpdate(check),
+        service_managed: serviceManaged,
+        last_checked_at: checkedAt,
+        last_error: null,
+      });
+      await updatePackage({
+        check,
+        onOutput: (text, stream) => {
+          const trimmed = String(text || '').trim();
+          if (trimmed) log(trimmed, stream);
+        },
+      });
+      installedUpdate = true;
+      await waitForIdleAndRestart(check);
+    } catch (error) {
+      writeAutoUpdateState({
+        status: 'error',
+        current_version: PACKAGE_VERSION,
+        service_managed: serviceManaged,
+        last_checked_at: checkedAt,
+        last_error: error.message,
+      });
+      log(`skipped: ${error.message}`, 'stderr');
+    } finally {
+      inFlight = false;
+      if (!stopped && !installedUpdate) schedule(checkIntervalMs);
+    }
+  }
+
+  return {
+    start() {
+      if (!shouldAutoUpdate()) {
+        writeAutoUpdateState({
+          status: 'disabled',
+          current_version: PACKAGE_VERSION,
+          service_managed: serviceManaged,
+          last_error: null,
+        });
+        return;
+      }
+      schedule(initialDelayMs);
+    },
+    stop() {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+      timer = null;
+    },
+  };
+}
+
 function checkServiceHealth(spec, timeoutMs = CHILD_HEALTH_POLICY.timeoutMs) {
   if (!spec.port) return Promise.resolve(true);
   return new Promise((resolve) => {
@@ -675,9 +986,11 @@ async function startSupervisor(options = {}) {
 
   await new Promise((resolve) => {
     let cleaned = false;
+    let autoUpdateManager = null;
     const cleanup = (signal) => {
       if (cleaned) return;
       cleaned = true;
+      if (autoUpdateManager) autoUpdateManager.stop();
       writeShutdownReason(signal);
       for (const tunnel of tunnels) tunnel.stop();
       for (const proc of managed) proc.stop();
@@ -696,6 +1009,15 @@ async function startSupervisor(options = {}) {
       resolve();
     };
 
+    autoUpdateManager = createAutoUpdateManager({
+      ports,
+      runtimeToken,
+      tunnels,
+      foreground: options.foreground,
+      requestRestart: cleanup,
+    });
+    autoUpdateManager.start();
+
     process.once('SIGINT', () => cleanup('SIGINT'));
     process.once('SIGTERM', () => cleanup('SIGTERM'));
     process.once('SIGHUP', () => cleanup('SIGHUP'));

package/lib/tunnel-chat.js

@@ -113,6 +113,7 @@ function createChatTunnel({ record, foreground = false }) {
   let backoffMs = 1000;
   let connectStartedAt = 0;
   let lastGatewayFrameAt = 0;
+  const upstreamStreams = new Map();
 
   function log(message) {
     if (foreground) console.log(`[chat-tunnel] ${message}`);
@@ -245,12 +246,19 @@ function createChatTunnel({ record, foreground = false }) {
           });
         });
         res.on('end', () => {
+          upstreamStreams.delete(frame.req_id);
           send({ type: 'stream_res_end', req_id: frame.req_id });
         });
+        res.on('close', () => {
+          upstreamStreams.delete(frame.req_id);
+        });
       },
     );
 
+    upstreamStreams.set(frame.req_id, req);
+
     req.on('error', (error) => {
+      upstreamStreams.delete(frame.req_id);
       send({
         type: 'stream_res_error',
         req_id: frame.req_id,
@@ -320,6 +328,14 @@ function createChatTunnel({ record, foreground = false }) {
       stopped = true;
       if (reconnectTimer) clearTimeout(reconnectTimer);
       stopWatchdog();
+      for (const stream of upstreamStreams.values()) {
+        try {
+          stream.destroy(new Error('chat tunnel stopped'));
+        } catch {
+          // noop
+        }
+      }
+      upstreamStreams.clear();
       if (ws) {
         try {
           ws.close();
@@ -328,6 +344,9 @@ function createChatTunnel({ record, foreground = false }) {
         }
       }
     },
+    activeCount() {
+      return upstreamStreams.size;
+    },
   };
 }
 

package/lib/tunnel-events.js

@@ -425,6 +425,9 @@ function createEventTunnel({ record, foreground = false }) {
           upstreamStreams.delete(frame.req_id);
           send({ type: 'stream_res_end', req_id: frame.req_id });
         });
+        res.on('close', () => {
+          upstreamStreams.delete(frame.req_id);
+        });
       },
     );
 
@@ -609,6 +612,9 @@ function createEventTunnel({ record, foreground = false }) {
         }
       }
     },
+    activeCount() {
+      return upstreamStreams.size + upstreamSockets.size;
+    },
   };
 }
 

package/lib/updater.js

@@ -0,0 +1,205 @@
+'use strict';
+
+const { spawn } = require('child_process');
+const {
+  AMALGM_RUNTIME_LABEL,
+} = require('./paths');
+const {
+  npmTagForRuntimeLabel,
+} = require('./runtime-identity');
+
+const PACKAGE_VERSION = require('../package.json').version;
+const DEFAULT_VIEW_TIMEOUT_MS = 15_000;
+const DEFAULT_INSTALL_TIMEOUT_MS = 10 * 60_000;
+
+function parseSemver(value) {
+  const raw = String(value || '').trim().replace(/^v/, '');
+  const [core, prerelease = ''] = raw.split('-', 2);
+  const [major = '0', minor = '0', patch = '0'] = core.split('.');
+  return {
+    major: Number(major) || 0,
+    minor: Number(minor) || 0,
+    patch: Number(patch) || 0,
+    prerelease,
+  };
+}
+
+function comparePrerelease(left, right) {
+  if (!left && !right) return 0;
+  if (!left) return 1;
+  if (!right) return -1;
+
+  const aParts = left.split('.');
+  const bParts = right.split('.');
+  const count = Math.max(aParts.length, bParts.length);
+  for (let i = 0; i < count; i += 1) {
+    const a = aParts[i] || '';
+    const b = bParts[i] || '';
+    if (a === b) continue;
+    if (!a) return -1;
+    if (!b) return 1;
+    const aNum = /^\d+$/.test(a) ? Number(a) : null;
+    const bNum = /^\d+$/.test(b) ? Number(b) : null;
+    if (aNum !== null && bNum !== null) return aNum > bNum ? 1 : -1;
+    if (aNum !== null && bNum === null) return -1;
+    if (aNum === null && bNum !== null) return 1;
+    if (a !== b) return a > b ? 1 : -1;
+  }
+  return 0;
+}
+
+function compareVersions(left, right) {
+  const a = parseSemver(left);
+  const b = parseSemver(right);
+  for (const key of ['major', 'minor', 'patch']) {
+    if (a[key] !== b[key]) return a[key] > b[key] ? 1 : -1;
+  }
+  return comparePrerelease(a.prerelease, b.prerelease);
+}
+
+function npmCommand() {
+  return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+
+function npmInstallTag(options = {}) {
+  const explicit = options.tag || options.channel;
+  if (explicit && explicit !== true) return String(explicit).replace(/^@/, '');
+  return npmTagForRuntimeLabel(options.runtimeLabel || AMALGM_RUNTIME_LABEL);
+}
+
+function npmEnv(env = process.env) {
+  return {
+    ...env,
+    npm_config_audit: 'false',
+    npm_config_fund: 'false',
+  };
+}
+
+function runNpm(args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(npmCommand(), args, {
+      env: npmEnv(options.env),
+      windowsHide: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+    const onOutput = typeof options.onOutput === 'function' ? options.onOutput : null;
+    const timeoutMs = Number(options.timeoutMs || 0);
+    const timer = timeoutMs > 0 ? setTimeout(() => {
+      timedOut = true;
+      try {
+        child.kill('SIGTERM');
+      } catch {
+        // noop
+      }
+    }, timeoutMs) : null;
+    if (timer && typeof timer.unref === 'function') timer.unref();
+
+    child.stdout.on('data', (chunk) => {
+      const text = chunk.toString();
+      stdout += text;
+      if (onOutput) onOutput(text, 'stdout');
+    });
+    child.stderr.on('data', (chunk) => {
+      const text = chunk.toString();
+      stderr += text;
+      if (onOutput) onOutput(text, 'stderr');
+    });
+    child.once('error', (error) => {
+      if (timer) clearTimeout(timer);
+      reject(error);
+    });
+    child.once('close', (status, signal) => {
+      if (timer) clearTimeout(timer);
+      resolve({ status, signal, stdout, stderr, timedOut });
+    });
+  });
+}
+
+function npmFailureDetail(result) {
+  if (result.timedOut) return 'npm command timed out';
+  return String(result.stderr || result.stdout || '').trim();
+}
+
+async function npmPackageVersionForTag(tag, options = {}) {
+  const result = await runNpm(['view', `amalgm@${tag}`, 'version', '--json'], {
+    timeoutMs: options.timeoutMs || DEFAULT_VIEW_TIMEOUT_MS,
+    env: options.env,
+  });
+  if (result.status !== 0) {
+    const detail = npmFailureDetail(result);
+    throw new Error(`Could not check npm dist-tag "${tag}". ${detail}`);
+  }
+
+  const raw = String(result.stdout || '').trim();
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw.replace(/^"|"$/g, '');
+  }
+}
+
+async function installNpmPackageTag(tag, options = {}) {
+  const result = await runNpm(['install', '-g', `amalgm@${tag}`], {
+    timeoutMs: options.timeoutMs || DEFAULT_INSTALL_TIMEOUT_MS,
+    env: options.env,
+    onOutput: options.onOutput,
+  });
+  if (result.status !== 0) {
+    const detail = npmFailureDetail(result);
+    const status = result.status ?? result.signal ?? 'unknown';
+    throw new Error(`npm install -g amalgm@${tag} failed with status ${status}${detail ? `: ${detail}` : ''}`);
+  }
+  return result;
+}
+
+async function checkForUpdate(options = {}) {
+  const tag = npmInstallTag(options);
+  const currentVersion = options.currentVersion || PACKAGE_VERSION;
+  const targetVersion = await npmPackageVersionForTag(tag, options);
+  if (!targetVersion) throw new Error(`npm did not return a version for amalgm@${tag}`);
+  return {
+    tag,
+    currentVersion,
+    targetVersion,
+    updateAvailable: compareVersions(targetVersion, currentVersion) > 0,
+  };
+}
+
+async function updatePackage(options = {}) {
+  const check = options.check || await checkForUpdate(options);
+  if (!check.updateAvailable) return { ...check, updated: false };
+  await installNpmPackageTag(check.tag, options);
+  return { ...check, updated: true };
+}
+
+function envDisablesAutoUpdate(env = process.env) {
+  const disable = String(env.AMALGM_DISABLE_AUTO_UPDATE || '').trim().toLowerCase();
+  if (['1', 'true', 'yes', 'on'].includes(disable)) return true;
+  const auto = String(env.AMALGM_AUTO_UPDATE || '').trim().toLowerCase();
+  return ['0', 'false', 'no', 'off'].includes(auto);
+}
+
+function autoUpdateSupported(options = {}) {
+  const label = options.runtimeLabel || AMALGM_RUNTIME_LABEL;
+  return label !== 'local';
+}
+
+function shouldAutoUpdate(options = {}) {
+  const env = options.env || process.env;
+  return autoUpdateSupported(options) && !envDisablesAutoUpdate(env);
+}
+
+module.exports = {
+  checkForUpdate,
+  compareVersions,
+  envDisablesAutoUpdate,
+  installNpmPackageTag,
+  npmInstallTag,
+  npmPackageVersionForTag,
+  parseSemver,
+  shouldAutoUpdate,
+  updatePackage,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.78",
+  "version": "0.1.79",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,
@@ -17,7 +17,7 @@
     "sync-runtime": "node ../../scripts/sync-npm-package-runtime.mjs",
     "prepack": "node ../../scripts/sync-npm-package-runtime.mjs",
     "pack:dry": "npm pack --dry-run",
-    "check": "node --check bin/amalgm.js && node --check lib/auth-store.js && node --check lib/cli.js && node --check lib/paths.js && node --check lib/process-cleanup.js && node --check lib/runtime-identity.js && node --check lib/runtime-manifest.js && node --check lib/service.js && node --check lib/state-migration.js && node --check lib/supervisor.js && node --check lib/tunnel-chat.js && node --check lib/tunnel-events.js && node --check runtime/lib/runtime-manifest.js && node --check runtime/scripts/runtime-auth.js && node --check runtime/scripts/proxy-token-store.js && node --check runtime/scripts/local-gateway.js && node --check runtime/scripts/port-monitor.js && node --check runtime/scripts/chat-server.js && node --check runtime/scripts/chat-server/index.js && node --check runtime/scripts/chat-server/config.js && node --check runtime/scripts/chat-core/tooling/native-binaries.js && node --check runtime/scripts/chat-core/tooling/package-import.js && node --check runtime/scripts/chat-core/tooling/runtime-home.js && node --check runtime/scripts/amalgm-mcp/index.js && node --check runtime/scripts/amalgm-mcp/config.js && node --check runtime/scripts/lib/project-paths.js && node --check runtime/scripts/lib/runtime-paths.js"
+    "check": "node --check bin/amalgm.js && node --check lib/auth-store.js && node --check lib/cli.js && node --check lib/paths.js && node --check lib/process-cleanup.js && node --check lib/runtime-identity.js && node --check lib/runtime-manifest.js && node --check lib/service.js && node --check lib/state-migration.js && node --check lib/supervisor.js && node --check lib/tunnel-chat.js && node --check lib/tunnel-events.js && node --check lib/updater.js && node --check runtime/lib/runtime-manifest.js && node --check runtime/scripts/runtime-auth.js && node --check runtime/scripts/proxy-token-store.js && node --check runtime/scripts/local-gateway.js && node --check runtime/scripts/port-monitor.js && node --check runtime/scripts/chat-server.js && node --check runtime/scripts/chat-server/index.js && node --check runtime/scripts/chat-server/config.js && node --check runtime/scripts/chat-core/tooling/native-binaries.js && node --check runtime/scripts/chat-core/tooling/package-import.js && node --check runtime/scripts/chat-core/tooling/runtime-home.js && node --check runtime/scripts/amalgm-mcp/index.js && node --check runtime/scripts/amalgm-mcp/config.js && node --check runtime/scripts/lib/project-paths.js && node --check runtime/scripts/lib/runtime-paths.js"
   },
   "engines": {
     "node": ">=20"

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

@@ -50,6 +50,7 @@ class ClaudeAdapter {
       mcpServers: toClaudeMcpServers(contract),
       permissionMode: 'bypassPermissions',
       allowDangerouslySkipPermissions: true,
+      includePartialMessages: true,
       ...(process.env.CHAT_CORE_DEBUG_CLAUDE === '1'
         ? { debug: true, debugFile: path.join(runtime.runtimeHome, 'claude-debug.log') }
         : {}),

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

@@ -95,6 +95,14 @@ class ChatCore {
     };
   }
 
+  idleStatus() {
+    const activeTurns = typeof this.turns.activeCount === 'function' ? this.turns.activeCount() : 0;
+    return {
+      idle: activeTurns === 0,
+      active_turns: activeTurns,
+    };
+  }
+
   async finalizeActiveTurn(sessionId) {
     const entry = this.turns.active(sessionId);
     if (!entry) return false;

package/runtime/scripts/chat-core/normalizers/claude.js

@@ -133,6 +133,7 @@ function ensureClaudeTextState(state) {
   if (!state) return null;
   if (!state.claudeTextByIndex) state.claudeTextByIndex = new Map();
   if (!state.claudeReasoningByIndex) state.claudeReasoningByIndex = new Map();
+  if (!state.claudeBlockIndexByType) state.claudeBlockIndexByType = new Map();
   return state;
 }
 
@@ -141,10 +142,34 @@ function blockIndex(value) {
   return Number.isInteger(index) && index >= 0 ? index : null;
 }
 
-function emitIndexedTextDelta(state, index, kind, delta, providerSessionId, raw) {
-  if (!delta) return [];
+function indexedTextKey(messageKey, index) {
+  const key = blockIndex(index);
+  if (key === null) return null;
+  return `${messageKey || 'current'}:${key}`;
+}
+
+function snapshotBlockType(block) {
+  if (block?.type === 'thinking' || block?.type === 'redacted_thinking') return 'reasoning';
+  return String(block?.type || 'unknown');
+}
+
+function rememberSnapshotBlockIndex(state, messageKey, block, index) {
   const textState = ensureClaudeTextState(state);
   const key = blockIndex(index);
+  if (!textState || key === null) return;
+  textState.claudeBlockIndexByType.set(`${messageKey || 'current'}:${snapshotBlockType(block)}`, key);
+}
+
+function snapshotBlockIndex(state, messageKey, block, fallback) {
+  const textState = ensureClaudeTextState(state);
+  const known = textState?.claudeBlockIndexByType?.get(`${messageKey || 'current'}:${snapshotBlockType(block)}`);
+  return known ?? fallback;
+}
+
+function emitIndexedTextDelta(state, messageKey, index, kind, delta, providerSessionId, raw) {
+  if (!delta) return [];
+  const textState = ensureClaudeTextState(state);
+  const key = indexedTextKey(messageKey, index);
   if (textState && key !== null) {
     const map = kind === 'reasoning' ? textState.claudeReasoningByIndex : textState.claudeTextByIndex;
     map.set(key, `${map.get(key) || ''}${delta}`);
@@ -159,11 +184,13 @@ function emitIndexedTextSnapshot(block, field, kind, providerSessionId, state, r
   if (!text) return [];
   let delta = text;
   const textState = ensureClaudeTextState(state);
-  const key = blockIndex(block.index);
+  const key = indexedTextKey(block.messageKey, block.index);
   if (textState && key !== null) {
     const map = kind === 'reasoning' ? textState.claudeReasoningByIndex : textState.claudeTextByIndex;
     const streamed = map.get(key) || '';
-    delta = streamed ? (text.startsWith(streamed) ? text.slice(streamed.length) : '') : text;
+    delta = streamed
+      ? (text === streamed ? '' : (text.startsWith(streamed) ? text.slice(streamed.length) : text))
+      : text;
     map.set(key, text);
   }
   if (!delta) return [];
@@ -354,18 +381,26 @@ function normalizeClaudeStreamEvent(message, providerSessionId, state) {
   if (!event || typeof event !== 'object') return [];
   const raw = eventRaw('claude.sdk.message', `claude/${event.type || 'unknown'}`, message);
 
+  if (event.type === 'message_start' && event.message?.id) {
+    if (state) state.claudeCurrentMessageKey = event.message.id;
+    return [];
+  }
+
+  const messageKey = state?.claudeCurrentMessageKey || message?.message?.id || message?.uuid || null;
+
   if (event.type === 'content_block_start') {
     const block = event.content_block || event.block;
+    rememberSnapshotBlockIndex(state, messageKey, block, event.index);
     if (!block || !TOOL_USE_BLOCK_TYPES.has(block.type)) return [];
     return startOrUpdateClaudeTool({ ...block, index: event.index }, providerSessionId, state, raw);
   }
 
   if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
-    return emitIndexedTextDelta(state, event.index, 'text', event.delta.text, providerSessionId, raw);
+    return emitIndexedTextDelta(state, messageKey, event.index, 'text', event.delta.text, providerSessionId, raw);
   }
 
   if (event.type === 'content_block_delta' && event.delta?.type === 'thinking_delta') {
-    return emitIndexedTextDelta(state, event.index, 'reasoning', event.delta.thinking, providerSessionId, raw);
+    return emitIndexedTextDelta(state, messageKey, event.index, 'reasoning', event.delta.thinking, providerSessionId, raw);
   }
 
   if (event.type === 'content_block_delta' && event.delta?.type === 'input_json_delta') {
@@ -429,9 +464,11 @@ function normalizeClaudeMessage(message, state) {
 
   if (message.type === 'assistant') {
     const events = [];
+    const messageKey = message.message?.id || message.uuid || state?.claudeCurrentMessageKey || null;
     for (const [index, block] of (message.message?.content || []).entries()) {
+      const blockSnapshotIndex = block?.index ?? snapshotBlockIndex(state, messageKey, block, index);
       events.push(...normalizeClaudeContentBlock(
-        { ...block, index },
+        { ...block, index: blockSnapshotIndex, messageKey },
         providerSessionId,
         state,
         eventRaw('claude.sdk.message', 'claude/assistant/content_block', message),

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

@@ -38,6 +38,7 @@ function parseRoute(url) {
   if (parts[0] === 'chat' && parts.length === 1) return { handler: 'chat' };
   if (parts[0] === 'raw-temp' && parts[1]) return { handler: 'raw-temp', id: parts[1], afterIndex: Number(u.searchParams.get('afterIndex') ?? -1) };
   if (parts[0] === 'active' && parts[1]) return { handler: 'active', id: parts[1] };
+  if (parts[0] === 'runtime-idle') return { handler: 'runtime-idle' };
   if (parts[0] === 'stop' && parts[1]) return { handler: 'stop', id: parts[1] };
   if (parts[0] === 'destroy' && parts[1]) return { handler: 'destroy', id: parts[1] };
   if (parts[0] === 'egress' && parts[1]) {
@@ -72,6 +73,7 @@ function createServer(core = createCore()) {
     try {
       if (route.handler === 'healthz') return sendJson(res, 200, { status: 'ok', runtime: 'chat-core', uptime: process.uptime() });
       if (route.handler === 'active') return sendJson(res, 200, core.active(route.id));
+      if (route.handler === 'runtime-idle') return sendJson(res, 200, core.idleStatus());
       if (route.handler === 'stop') {
         if (req.method !== 'POST') return sendJson(res, 405, { error: 'Method not allowed' });
         return sendJson(res, 200, { stopped: await core.stop(route.id), codeSessionId: route.id });

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

@@ -33,6 +33,15 @@ class TurnStore {
     return turnId ? this.turns.get(turnId) || null : null;
   }
 
+  activeCount() {
+    let count = 0;
+    for (const turnId of this.activeBySession.values()) {
+      const entry = this.turns.get(turnId);
+      if (entry && ['streaming', 'cancelling'].includes(entry.status)) count += 1;
+    }
+    return count;
+  }
+
   latest(sessionId) {
     return this.active(sessionId) || this.get(this.latestBySession.get(sessionId));
   }

package/runtime/scripts/chat-core/tests/claude-normalizer.test.js

@@ -54,3 +54,91 @@ test('claude thinking stream deltas emit reasoning before final snapshot without
   }, state);
   assert.deepEqual(finalSnapshot, []);
 });
+
+test('claude partial stream events emit text deltas', () => {
+  const state = { providerSessionId: 'claude-session' };
+
+  normalizeClaudeMessage({
+    type: 'stream_event',
+    event: {
+      type: 'message_start',
+      message: { id: 'msg_streaming' },
+    },
+  }, state);
+
+  normalizeClaudeMessage({
+    type: 'stream_event',
+    event: {
+      type: 'content_block_start',
+      index: 1,
+      content_block: { type: 'text', text: '' },
+    },
+  }, state);
+
+  const delta = normalizeClaudeMessage({
+    type: 'stream_event',
+    event: {
+      type: 'content_block_delta',
+      index: 1,
+      delta: { type: 'text_delta', text: 'streamed' },
+    },
+  }, state);
+
+  assert.equal(delta.length, 1);
+  assert.equal(delta[0].type, 'text.delta');
+  assert.equal(delta[0].text, 'streamed');
+
+  const finalSnapshot = normalizeClaudeMessage({
+    type: 'assistant',
+    message: {
+      id: 'msg_streaming',
+      content: [{ type: 'text', text: 'streamed' }],
+    },
+  }, state);
+  assert.deepEqual(finalSnapshot, []);
+});
+
+test('claude assistant snapshots with reused block indexes after tools are not dropped', () => {
+  const state = { providerSessionId: 'claude-session' };
+
+  const intro = normalizeClaudeMessage({
+    type: 'assistant',
+    message: {
+      id: 'msg_intro',
+      content: [{ type: 'text', text: 'Let me search first.' }],
+    },
+  }, state);
+  assert.equal(intro.length, 1);
+  assert.equal(intro[0].type, 'text.delta');
+  assert.equal(intro[0].text, 'Let me search first.');
+
+  const tool = normalizeClaudeMessage({
+    type: 'assistant',
+    message: {
+      id: 'msg_tool',
+      content: [{ type: 'tool_use', id: 'toolu_1', name: 'WebSearch', input: { query: 'news' } }],
+    },
+  }, state);
+  assert.equal(tool.length, 1);
+  assert.equal(tool[0].type, 'tool.started');
+
+  const result = normalizeClaudeMessage({
+    type: 'user',
+    message: {
+      content: [{ type: 'tool_result', tool_use_id: 'toolu_1', content: 'results' }],
+    },
+  }, state);
+  assert.equal(result.length, 1);
+  assert.equal(result[0].type, 'tool.completed');
+
+  const finalAnswer = normalizeClaudeMessage({
+    type: 'assistant',
+    message: {
+      id: 'msg_final',
+      content: [{ type: 'text', text: 'Here are the results.' }],
+    },
+  }, state);
+  assert.equal(finalAnswer.length, 1);
+  assert.equal(finalAnswer[0].type, 'text.delta');
+  assert.equal(finalAnswer[0].text, 'Here are the results.');
+});

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

@@ -117,3 +117,43 @@ test('POST /chat streams from the same indexed raw chunks as /raw-temp', async (
     await new Promise((resolve) => server.close(resolve));
   }
 });
+
+test('GET /runtime-idle reports active turn count', async () => {
+  process.env.AMALGM_RUNTIME_AUTH = 'disabled';
+
+  const core = new ChatCore({
+    db: {
+      mergeSessionMetadata: async () => {},
+    },
+    runtime: runtime(),
+    turns: new TurnStore(),
+    options: {
+      beginTurn: async () => {},
+    },
+  });
+  const server = createServer(core);
+  const baseUrl = await listen(server);
+
+  try {
+    let res = await fetch(`${baseUrl}/runtime-idle`);
+    assert.equal(res.status, 200);
+    assert.deepEqual(await res.json(), { idle: true, active_turns: 0 });
+
+    const entry = core.turns.start({
+      sessionId: 'session-test',
+      turnId: 'turn-test',
+      assistantMessageId: 'assistant-test',
+      userMessageId: 'user-test',
+    });
+    res = await fetch(`${baseUrl}/runtime-idle`);
+    assert.equal(res.status, 200);
+    assert.deepEqual(await res.json(), { idle: false, active_turns: 1 });
+
+    core.turns.mark(entry.turnId, 'complete');
+    res = await fetch(`${baseUrl}/runtime-idle`);
+    assert.equal(res.status, 200);
+    assert.deepEqual(await res.json(), { idle: true, active_turns: 0 });
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+  }
+});