@parall/daemon 1.30.0 → 1.31.0

package/bundle/parall-daemon.js

@@ -1,4 +1,622 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ts/daemon/dist/config.js
+var config_exports = {};
+__export(config_exports, {
+  agentClaudeCredentialsFileFor: () => agentClaudeCredentialsFileFor,
+  agentClaudeHomeFor: () => agentClaudeHomeFor,
+  agentStateDirFor: () => agentStateDirFor,
+  agentWorkspaceDirFor: () => agentWorkspaceDirFor,
+  daemonConfigDir: () => daemonConfigDir,
+  daemonConfigPath: () => daemonConfigPath,
+  resolveBundleDir: () => resolveBundleDir,
+  resolveClaudeDaemonConfig: () => resolveClaudeDaemonConfig,
+  resolveWsUrl: () => resolveWsUrl,
+  sharedClaudeCredentialsFileFor: () => sharedClaudeCredentialsFileFor
+});
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+function resolvePath(value) {
+  return path.isAbsolute(value) ? value : path.resolve(process.cwd(), value);
+}
+function parseMs(value, fallback) {
+  if (!value)
+    return fallback;
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function parseMsAllowZero(value, fallback) {
+  if (value === void 0)
+    return fallback;
+  const n = Number(value);
+  return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
+function daemonConfigDir(env = process.env) {
+  return path.join(env.HOME || os.homedir(), ".parall-daemon");
+}
+function daemonConfigPath(env = process.env) {
+  return path.join(daemonConfigDir(env), "config.json");
+}
+function tryLoadConfigFile(env) {
+  const cfgPath = daemonConfigPath(env);
+  let content;
+  try {
+    content = fs.readFileSync(cfgPath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return null;
+    console.error(`Failed to read daemon config at ${cfgPath}: ${String(err)}`);
+    return null;
+  }
+  try {
+    return JSON.parse(content);
+  } catch (err) {
+    console.error(`Failed to parse daemon config at ${cfgPath}: ${String(err)}`);
+    return null;
+  }
+}
+function resolveClaudeDaemonConfig(env = process.env) {
+  let apiUrl = env.PRLL_API_URL?.trim() || "";
+  let apiKey = env.PRLL_API_KEY?.trim() || "";
+  if (!apiUrl || !apiKey) {
+    const file = tryLoadConfigFile(env);
+    if (file) {
+      if (!apiUrl && file.api_url)
+        apiUrl = file.api_url.trim();
+      if (!apiKey && file.api_key)
+        apiKey = file.api_key.trim();
+    }
+  }
+  if (!apiUrl)
+    throw new Error("Missing required env var: PRLL_API_URL");
+  if (!apiKey)
+    throw new Error("Missing required env var: PRLL_API_KEY");
+  if (!apiKey.startsWith("mck_")) {
+    throw new Error(`PRLL_API_KEY does not look like a Machine bearer (expected prefix "mck_"). Daemon mode requires a machine-scoped key issued via POST /machines/{id}/keys.`);
+  }
+  const rootClaudeHome = resolvePath(env.PRLL_CLAUDE_HOME?.trim() || env.HOME || os.homedir());
+  const rootStateDir = resolvePath(env.PRLL_CLAUDE_STATE_DIR?.trim() || path.join(rootClaudeHome, ".parall-agent"));
+  return {
+    apiUrl,
+    apiKey,
+    agentBin: env.PRLL_CLAUDE_AGENT_BIN?.trim() || "parall-claude-agent",
+    rootStateDir,
+    rootClaudeHome,
+    wsUrl: env.PRLL_WS_URL?.trim() || void 0,
+    swimlaneName: env.PRLL_SWIMLANE_NAME?.trim() || void 0,
+    pollIntervalMs: parseMs(env.PRLL_DAEMON_POLL_INTERVAL_MS, 3e4),
+    heartbeatIntervalMs: parseMs(env.PRLL_DAEMON_HEARTBEAT_INTERVAL_MS, 3e4),
+    restartBackoffMs: parseMs(env.PRLL_DAEMON_RESTART_BACKOFF_MS, 5e3),
+    restartBackoffMaxMs: parseMs(env.PRLL_DAEMON_RESTART_BACKOFF_MAX_MS, 5 * 6e4),
+    bootstrapBackoffMs: parseMsAllowZero(env.PRLL_DAEMON_BOOTSTRAP_BACKOFF_MS, 2e3),
+    bootstrapBackoffMaxMs: parseMs(env.PRLL_DAEMON_BOOTSTRAP_BACKOFF_MAX_MS, 6e4),
+    supervisorRestartBackoffMs: parseMsAllowZero(env.PRLL_DAEMON_SUPERVISOR_RESTART_BACKOFF_MS, 5e3),
+    supervisorRestartBackoffMaxMs: parseMs(env.PRLL_DAEMON_SUPERVISOR_RESTART_BACKOFF_MAX_MS, 5 * 6e4),
+    updateCdnUrl: env.PRLL_DAEMON_UPDATE_CDN_URL?.trim() || ((env.PRLL_DAEMON_UPDATE_CHANNEL?.trim() ?? "production") === "staging" ? "https://releases.staging.prll.sh/daemon/staging" : "https://releases.parall.com/daemon/production"),
+    updateIntervalMs: parseMsAllowZero(env.PRLL_DAEMON_UPDATE_INTERVAL_MS, 6 * 60 * 6e4),
+    updateDisabled: env.PRLL_DAEMON_UPDATE_DISABLED === "true" || !!env.KUBERNETES_SERVICE_HOST
+  };
+}
+function assertSafeAgentId(agentId) {
+  if (!/^[A-Za-z0-9_-]+$/.test(agentId)) {
+    throw new Error(`Invalid agentId for filesystem path: ${agentId}`);
+  }
+  return agentId;
+}
+function agentStateDirFor(rootStateDir, agentId) {
+  return path.join(rootStateDir, "agents", assertSafeAgentId(agentId));
+}
+function agentClaudeHomeFor(rootClaudeHome, agentId) {
+  return path.join(rootClaudeHome, "agents", assertSafeAgentId(agentId));
+}
+function sharedClaudeCredentialsFileFor(rootClaudeHome) {
+  return path.join(rootClaudeHome, ".claude", ".credentials.json");
+}
+function agentClaudeCredentialsFileFor(agentClaudeHome) {
+  return path.join(agentClaudeHome, ".claude", ".credentials.json");
+}
+function agentWorkspaceDirFor(rootStateDir, agentId) {
+  return path.join(rootStateDir, "agents", assertSafeAgentId(agentId), "workspace");
+}
+function resolveBundleDir(env = process.env) {
+  if (env.PRLL_DAEMON_BUNDLE_DIR)
+    return resolvePath(env.PRLL_DAEMON_BUNDLE_DIR);
+  return path.join(daemonConfigDir(env), "bundle");
+}
+function resolveWsUrl(apiUrl, explicitWsUrl, swimlaneName) {
+  const base = explicitWsUrl || `${apiUrl.replace(/\/$/, "").replace(/^http/, "ws")}/ws`;
+  if (!swimlaneName)
+    return base;
+  const url = new URL(base);
+  url.searchParams.set("swimlane", swimlaneName);
+  return url.toString();
+}
+var init_config = __esm({
+  "ts/daemon/dist/config.js"() {
+    "use strict";
+  }
+});
+
+// ts/daemon/dist/updater-manifest.js
+import { verify } from "node:crypto";
+function canonicalize(obj) {
+  if (Array.isArray(obj))
+    return obj.map(canonicalize);
+  if (obj !== null && typeof obj === "object") {
+    const sorted = {};
+    for (const k of Object.keys(obj).sort()) {
+      sorted[k] = canonicalize(obj[k]);
+    }
+    return sorted;
+  }
+  return obj;
+}
+function verifyManifestSignature(manifest, publicKey) {
+  const { signature, ...rest } = manifest;
+  const canonical = JSON.stringify(canonicalize(rest));
+  try {
+    return verify(null, Buffer.from(canonical), publicKey, Buffer.from(signature, "base64"));
+  } catch {
+    return false;
+  }
+}
+function semverCompare(a, b) {
+  const pa = parseSemver(a);
+  const pb = parseSemver(b);
+  if (!pa || !pb)
+    return null;
+  for (let i = 0; i < 3; i++) {
+    if (pa.nums[i] < pb.nums[i])
+      return -1;
+    if (pa.nums[i] > pb.nums[i])
+      return 1;
+  }
+  if (!pa.pre && !pb.pre)
+    return 0;
+  if (!pa.pre)
+    return 1;
+  if (!pb.pre)
+    return -1;
+  if (pa.pre < pb.pre)
+    return -1;
+  if (pa.pre > pb.pre)
+    return 1;
+  return 0;
+}
+function parseSemver(v) {
+  const parts = v.split(".");
+  if (parts.length < 3)
+    return null;
+  const major = Number(parts[0]);
+  const minor = Number(parts[1]);
+  const rest = parts.slice(2).join(".");
+  const hyphen = rest.indexOf("-");
+  let patchStr;
+  let pre;
+  if (hyphen >= 0) {
+    patchStr = rest.slice(0, hyphen);
+    pre = rest.slice(hyphen + 1);
+  } else {
+    patchStr = rest;
+  }
+  const patch = Number(patchStr);
+  if (isNaN(major) || isNaN(minor) || isNaN(patch))
+    return null;
+  return { nums: [major, minor, patch], pre };
+}
+var init_updater_manifest = __esm({
+  "ts/daemon/dist/updater-manifest.js"() {
+    "use strict";
+  }
+});
+
+// ts/daemon/dist/updater.js
+var updater_exports = {};
+__export(updater_exports, {
+  DaemonUpdater: () => DaemonUpdater
+});
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
+import * as https from "node:https";
+import * as http from "node:http";
+import { createHash as createHash2 } from "node:crypto";
+var SIGNING_PUBLIC_KEY, DaemonUpdater;
+var init_updater = __esm({
+  "ts/daemon/dist/updater.js"() {
+    "use strict";
+    init_updater_manifest();
+    SIGNING_PUBLIC_KEY = process.env.PRLL_DAEMON_SIGNING_PUBLIC_KEY ?? "";
+    DaemonUpdater = class {
+      bundleDir;
+      cdnBaseUrl;
+      log;
+      signingEnabled;
+      updating = false;
+      periodicTimer = null;
+      constructor(bundleDir, cdnBaseUrl, log2, signingEnabled) {
+        this.bundleDir = bundleDir;
+        this.cdnBaseUrl = cdnBaseUrl;
+        this.log = log2;
+        this.signingEnabled = signingEnabled;
+      }
+      // --- Public API ---
+      /**
+       * Start periodic update checks. Call once after supervisor bootstrap.
+       */
+      startPeriodicCheck(intervalMs) {
+        if (intervalMs <= 0 || this.periodicTimer)
+          return;
+        this.periodicTimer = setInterval(() => {
+          this.checkAndApply().catch((err) => {
+            this.log.warn(`periodic update check failed: ${String(err)}`);
+          });
+        }, intervalMs);
+        this.periodicTimer.unref?.();
+      }
+      stopPeriodicCheck() {
+        if (this.periodicTimer) {
+          clearInterval(this.periodicTimer);
+          this.periodicTimer = null;
+        }
+      }
+      /**
+       * Check CDN for a newer version. Returns true if update was applied
+       * (caller should exit for service manager restart).
+       */
+      async checkAndApply(targetVersion) {
+        if (this.updating)
+          return false;
+        this.updating = true;
+        try {
+          return await this.doUpdate(targetVersion);
+        } catch (err) {
+          this.log.warn(`update check failed: ${String(err)}`);
+          return false;
+        } finally {
+          this.updating = false;
+        }
+      }
+      /**
+       * Handle WS-triggered update. Adds jitter for non-mandatory updates.
+       */
+      async triggerUpdate(targetVersion, mandatory) {
+        if (!mandatory) {
+          const jitter = Math.random() * 18e4;
+          await new Promise((r) => setTimeout(r, jitter));
+        }
+        return this.checkAndApply(targetVersion);
+      }
+      /**
+       * Check if we need to roll back from a failed update.
+       * Call on every daemon startup, before bootstrap.
+       * Returns true if rollback was performed (caller should exit immediately).
+       */
+      checkRollback() {
+        const state = this.loadUpdateState();
+        const current = this.loadLocalManifest();
+        if (!state || !current)
+          return false;
+        if (!state.pending_version || state.pending_version !== current.version)
+          return false;
+        state.boot_count = (state.boot_count ?? 0) + 1;
+        this.saveUpdateState(state);
+        if (state.boot_count < 3)
+          return false;
+        if (!state.previous_version)
+          return false;
+        const previousDir = path6.join(this.bundleDir, "versions", state.previous_version);
+        if (!fs6.existsSync(previousDir))
+          return false;
+        this.log.warn(`rollback: ${current.version} failed ${state.boot_count} boots, reverting to ${state.previous_version}`);
+        if (process.platform === "win32") {
+          const currentDir = path6.join(this.bundleDir, "current");
+          if (fs6.existsSync(currentDir)) {
+            for (const file of fs6.readdirSync(currentDir)) {
+              fs6.unlinkSync(path6.join(currentDir, file));
+            }
+          }
+          fs6.mkdirSync(currentDir, { recursive: true });
+          for (const file of fs6.readdirSync(previousDir)) {
+            fs6.copyFileSync(path6.join(previousDir, file), path6.join(currentDir, file));
+          }
+        } else {
+          this.swapSymlink(state.previous_version);
+        }
+        state.confirmed_version = state.previous_version;
+        state.pending_version = void 0;
+        state.boot_count = 0;
+        state.rollback_from = current.version;
+        state.rollback_at = (/* @__PURE__ */ new Date()).toISOString();
+        this.saveUpdateState(state);
+        return true;
+      }
+      /**
+       * Confirm the current version after successful health check.
+       * Clears pending state so rollback won't trigger.
+       */
+      confirmVersion() {
+        const current = this.loadLocalManifest();
+        if (!current)
+          return;
+        const state = this.loadUpdateState() ?? {};
+        state.confirmed_version = current.version;
+        state.confirmed_at = (/* @__PURE__ */ new Date()).toISOString();
+        state.pending_version = void 0;
+        state.boot_count = 0;
+        this.saveUpdateState(state);
+        this.log.info(`update: confirmed version ${current.version}`);
+      }
+      /**
+       * Get the current local manifest version (for heartbeat reporting).
+       */
+      getLocalVersion() {
+        return this.loadLocalManifest()?.version;
+      }
+      /**
+       * Check CDN for available update without downloading.
+       * Returns remote version info for CLI --check display.
+       */
+      async checkAvailable() {
+        const local = this.loadLocalManifest();
+        const manifestUrl = `${this.cdnBaseUrl}/latest/manifest.json`;
+        try {
+          const remoteJson = await this.httpGet(manifestUrl);
+          const remote = JSON.parse(remoteJson);
+          const current = local?.version;
+          if (current) {
+            const cmp = semverCompare(remote.version, current);
+            return { available: cmp !== null && cmp > 0, currentVersion: current, remoteVersion: remote.version };
+          }
+          return { available: true, remoteVersion: remote.version };
+        } catch {
+          return { available: false, currentVersion: local?.version };
+        }
+      }
+      // --- Internal ---
+      async doUpdate(targetVersion) {
+        const local = this.loadLocalManifest();
+        const manifestUrl = targetVersion ? `${this.cdnBaseUrl}/${targetVersion}/manifest.json` : `${this.cdnBaseUrl}/latest/manifest.json`;
+        let remoteJson;
+        try {
+          remoteJson = await this.httpGet(manifestUrl);
+        } catch (err) {
+          this.log.warn(`update: failed to fetch manifest from ${manifestUrl}: ${String(err)}`);
+          return false;
+        }
+        let remote;
+        try {
+          remote = JSON.parse(remoteJson);
+        } catch {
+          this.log.warn("update: failed to parse remote manifest");
+          return false;
+        }
+        if (local) {
+          const cmp = semverCompare(remote.version, local.version);
+          if (cmp === null || cmp <= 0)
+            return false;
+        }
+        const state = this.loadUpdateState();
+        if (state?.rollback_from === remote.version) {
+          this.log.info(`update: skipping ${remote.version} (previously rolled back)`);
+          return false;
+        }
+        if (this.signingEnabled) {
+          if (!SIGNING_PUBLIC_KEY) {
+            this.log.error("update: signing enabled but PRLL_DAEMON_SIGNING_PUBLIC_KEY is empty \u2014 rejecting update");
+            return false;
+          }
+          if (!verifyManifestSignature(remote, SIGNING_PUBLIC_KEY)) {
+            this.log.error(`update: signature verification failed for ${remote.version}`);
+            return false;
+          }
+        }
+        const stagingDir = path6.join(this.bundleDir, "staging");
+        this.cleanDir(stagingDir);
+        fs6.mkdirSync(stagingDir, { recursive: true });
+        for (const [filename, meta] of Object.entries(remote.files)) {
+          const filePath = path6.join(stagingDir, filename);
+          const fileUrl = `${this.cdnBaseUrl}/${remote.version}/${filename}`;
+          try {
+            await this.downloadFile(fileUrl, filePath);
+          } catch (err) {
+            this.log.error(`update: download failed for ${filename}: ${String(err)}`);
+            this.cleanDir(stagingDir);
+            return false;
+          }
+          const content = fs6.readFileSync(filePath);
+          const hash = createHash2("sha256").update(content).digest("hex");
+          if (hash !== meta.sha256) {
+            this.log.error(`update: sha256 mismatch for ${filename} (expected ${meta.sha256}, got ${hash})`);
+            this.cleanDir(stagingDir);
+            return false;
+          }
+          if (content.length !== meta.size) {
+            this.log.error(`update: size mismatch for ${filename} (expected ${meta.size}, got ${content.length})`);
+            this.cleanDir(stagingDir);
+            return false;
+          }
+        }
+        fs6.writeFileSync(path6.join(stagingDir, "manifest.json"), JSON.stringify(remote, null, 2));
+        this.atomicSwap(stagingDir, remote.version);
+        const newState = {
+          confirmed_version: local?.version ?? state?.confirmed_version,
+          previous_version: local?.version,
+          pending_version: remote.version,
+          pending_at: (/* @__PURE__ */ new Date()).toISOString(),
+          boot_count: 0
+        };
+        this.saveUpdateState(newState);
+        this.log.info(`update: ${local?.version ?? "unknown"} \u2192 ${remote.version} applied, restarting`);
+        return true;
+      }
+      atomicSwap(stagingDir, newVersion) {
+        const versionsDir = path6.join(this.bundleDir, "versions");
+        const targetDir = path6.join(versionsDir, newVersion);
+        const currentLink = path6.join(this.bundleDir, "current");
+        fs6.mkdirSync(versionsDir, { recursive: true });
+        if (fs6.existsSync(targetDir)) {
+          fs6.rmSync(targetDir, { recursive: true });
+        }
+        fs6.renameSync(stagingDir, targetDir);
+        if (process.platform === "win32") {
+          const currentDir = currentLink;
+          if (fs6.existsSync(currentDir)) {
+            for (const file of fs6.readdirSync(currentDir)) {
+              fs6.unlinkSync(path6.join(currentDir, file));
+            }
+          }
+          fs6.mkdirSync(currentDir, { recursive: true });
+          for (const file of fs6.readdirSync(targetDir)) {
+            fs6.copyFileSync(path6.join(targetDir, file), path6.join(currentDir, file));
+          }
+        } else {
+          this.swapSymlink(newVersion);
+        }
+        this.pruneOldVersions(versionsDir, newVersion);
+      }
+      swapSymlink(version) {
+        const currentLink = path6.join(this.bundleDir, "current");
+        const tmpLink = `${currentLink}.new`;
+        try {
+          fs6.unlinkSync(tmpLink);
+        } catch {
+        }
+        fs6.symlinkSync(`versions/${version}`, tmpLink);
+        fs6.renameSync(tmpLink, currentLink);
+      }
+      pruneOldVersions(versionsDir, currentVersion) {
+        const state = this.loadUpdateState();
+        const keep = /* @__PURE__ */ new Set([currentVersion]);
+        if (state?.previous_version)
+          keep.add(state.previous_version);
+        if (state?.confirmed_version)
+          keep.add(state.confirmed_version);
+        try {
+          for (const entry of fs6.readdirSync(versionsDir)) {
+            if (!keep.has(entry)) {
+              fs6.rmSync(path6.join(versionsDir, entry), { recursive: true });
+            }
+          }
+        } catch {
+        }
+      }
+      // --- Manifest & State I/O ---
+      loadLocalManifest() {
+        const currentDir = path6.join(this.bundleDir, "current");
+        const manifestPath = path6.join(currentDir, "manifest.json");
+        try {
+          return JSON.parse(fs6.readFileSync(manifestPath, "utf-8"));
+        } catch {
+          return null;
+        }
+      }
+      loadUpdateState() {
+        const statePath = path6.join(this.bundleDir, "update-state.json");
+        try {
+          return JSON.parse(fs6.readFileSync(statePath, "utf-8"));
+        } catch {
+          return null;
+        }
+      }
+      saveUpdateState(state) {
+        const statePath = path6.join(this.bundleDir, "update-state.json");
+        fs6.mkdirSync(path6.dirname(statePath), { recursive: true });
+        fs6.writeFileSync(statePath, JSON.stringify(state, null, 2));
+      }
+      // --- HTTP helpers ---
+      httpGet(url, maxRedirects = 5) {
+        return new Promise((resolve5, reject) => {
+          const mod = url.startsWith("https") ? https : http;
+          const req = mod.get(url, (res) => {
+            if (res.statusCode === 301 || res.statusCode === 302) {
+              if (res.headers.location && maxRedirects > 0) {
+                this.httpGet(res.headers.location, maxRedirects - 1).then(resolve5, reject);
+                return;
+              }
+              res.resume();
+              reject(new Error(`too many redirects or missing location for ${url}`));
+              return;
+            }
+            if (res.statusCode !== 200) {
+              res.resume();
+              reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+              return;
+            }
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => resolve5(Buffer.concat(chunks).toString("utf-8")));
+            res.on("error", reject);
+          });
+          req.on("error", reject);
+          req.setTimeout(3e4, () => {
+            req.destroy(new Error(`timeout fetching ${url}`));
+          });
+        });
+      }
+      downloadFile(url, dest, maxRedirects = 5) {
+        return new Promise((resolve5, reject) => {
+          const mod = url.startsWith("https") ? https : http;
+          const req = mod.get(url, (res) => {
+            if (res.statusCode === 301 || res.statusCode === 302) {
+              if (res.headers.location && maxRedirects > 0) {
+                this.downloadFile(res.headers.location, dest, maxRedirects - 1).then(resolve5, reject);
+                return;
+              }
+              res.resume();
+              reject(new Error(`too many redirects or missing location for ${url}`));
+              return;
+            }
+            if (res.statusCode !== 200) {
+              res.resume();
+              reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+              return;
+            }
+            const file = fs6.createWriteStream(dest);
+            res.pipe(file);
+            file.on("finish", () => {
+              file.close();
+              resolve5();
+            });
+            file.on("error", (err) => {
+              fs6.unlinkSync(dest);
+              reject(err);
+            });
+          });
+          req.on("error", reject);
+          req.setTimeout(12e4, () => {
+            req.destroy(new Error(`timeout downloading ${url}`));
+          });
+        });
+      }
+      cleanDir(dir) {
+        try {
+          fs6.rmSync(dir, { recursive: true });
+        } catch {
+        }
+      }
+    };
+  }
+});
+
+// ts/agent-core/dist/provider-config.js
+function clearAllProviderCreds(env) {
+  delete env.ANTHROPIC_AUTH_TOKEN;
+  delete env.ANTHROPIC_BASE_URL;
+  delete env.ANTHROPIC_API_KEY;
+  delete env.OPENAI_API_KEY;
+  delete env.OPENAI_BASE_URL;
+  delete env.PRLL_CLAUDE_ALLOW_API_KEY;
+}
 
 // ts/agent-core/dist/logger.js
 function createLogger(prefix) {
@@ -40,6 +658,7 @@ var ENDPOINTS = {
   ORG_MEMBER: (orgId, userId) => `${API_BASE}/orgs/${orgId}/members/${userId}`,
   ORG_MEMBER_CHATS: (orgId, memberId) => `${API_BASE}/orgs/${orgId}/members/${memberId}/chats`,
   ORG_MEMBER_TASKS: (orgId, memberId) => `${API_BASE}/orgs/${orgId}/members/${memberId}/tasks`,
+  REF_SEARCH: (orgId) => `${API_BASE}/orgs/${orgId}/refs/search`,
   // Direct messages (org-scoped, atomic find-or-create + send)
   DM: (orgId) => `${API_BASE}/orgs/${orgId}/dm`,
   // Onboarding
@@ -122,6 +741,7 @@ var ENDPOINTS = {
   MACHINE_KEY: (orgId, machineId, keyId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/keys/${keyId}`,
   MACHINE_RUNTIME_AUTH_SESSIONS: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/runtime-auth-sessions`,
   MACHINE_RUNTIME_AUTH_SESSION_COMPLETE: (orgId, machineId, sessionId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/runtime-auth-sessions/${sessionId}/complete`,
+  MACHINE_REQUEST_UPDATE: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/request-update`,
   MACHINE_BROWSE: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/browse`,
   // Machine self-control-plane (mck_-scoped). The bearer token implicitly
   // identifies the Machine, so there is no `:mid` URL parameter — these are
@@ -167,6 +787,12 @@ var ENDPOINTS = {
   INVITATION_ACCEPT: (id) => `${API_BASE}/invitations/${id}/accept`,
   INVITATION_DECLINE: (id) => `${API_BASE}/invitations/${id}/decline`,
   INVITATION_BY_TOKEN: (token) => `${API_BASE}/invitations/by-token/${token}`,
+  // Org-level shareable invite link
+  ORG_INVITE_LINK: (orgId) => `${API_BASE}/orgs/${orgId}/invite-link`,
+  ORG_INVITE_LINK_REGENERATE: (orgId) => `${API_BASE}/orgs/${orgId}/invite-link/regenerate`,
+  ORG_INVITE_LINK_JOIN_REQUESTS: (orgId) => `${API_BASE}/orgs/${orgId}/invite-link/join-requests`,
+  ORG_INVITE_LINK_JOIN_REQUEST_DECIDE: (orgId, jrId) => `${API_BASE}/orgs/${orgId}/invite-link/join-requests/${jrId}/decide`,
+  INVITE_LINK_JOIN: `${API_BASE}/invite-link/join`,
   // Wikis (org-scoped, served by wiki-service)
   WIKIS: (orgId) => `${WIKI_BASE}/orgs/${orgId}/wikis`,
   WIKI: (orgId, wikiId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}`,
@@ -286,6 +912,8 @@ var WS_EVENTS = {
   INVITATION_ACCEPTED: "invitation.accepted",
   INVITATION_DECLINED: "invitation.declined",
   INVITATION_REVOKED: "invitation.revoked",
+  ORG_JOIN_REQUEST_NEW: "org.join_request.new",
+  ORG_INVITE_LINK_JOINED: "org.invite_link.joined",
   AGENT_CONFIG_UPDATE: "agent_config.update",
   PRESENCE_UPDATE: "presence.update",
   WIKI_CHANGESET_CREATED: "wiki.changeset.created",
@@ -314,6 +942,8 @@ var WS_EVENTS = {
   MACHINE_STOP: "machine.stop",
   MACHINE_WORKSPACE_SETUP_REQUESTED: "machine.workspace.setup.requested",
   MACHINE_FILESYSTEM_BROWSE: "machine.filesystem.browse",
+  MACHINE_UPDATE: "machine.update",
+  MACHINE_CONFIG_UPDATED: "machine.config.updated",
   AGENT_NEW_SESSION: "agent.new_session"
 };
 
@@ -397,10 +1027,10 @@ var ParallClient = class _ParallClient {
    * REFRESH_THRESHOLD_S, refresh it **before** sending the request.
    * No-op when the token is still fresh, missing, or un-parseable.
    */
-  async ensureFreshToken(path7) {
+  async ensureFreshToken(path8) {
     if (!this.token || !this.getRefreshToken)
       return;
-    const pathSuffix = path7.replace(/^\/api\/v1/, "");
+    const pathSuffix = path8.replace(/^\/api\/v1/, "");
     if (_ParallClient.AUTH_PATHS.has(pathSuffix))
       return;
     const exp = _ParallClient.decodeJwtExp(this.token);
@@ -432,11 +1062,11 @@ var ParallClient = class _ParallClient {
       this.refreshPromise = null;
     }
   }
-  async request(method, path7, body, query, retried = false, opts) {
+  async request(method, path8, body, query, retried = false, opts) {
     if (!retried) {
-      await this.ensureFreshToken(path7);
+      await this.ensureFreshToken(path8);
     }
-    let url = `${this.baseUrl}${path7}`;
+    let url = `${this.baseUrl}${path8}`;
     if (query) {
       const params = new URLSearchParams();
       for (const [key, value] of Object.entries(query)) {
@@ -461,12 +1091,12 @@ var ParallClient = class _ParallClient {
       throw _ParallClient.normalizeFetchError(err);
     }
     if (res.status === 401) {
-      const pathSuffix = path7.replace(/^\/api\/v1/, "");
+      const pathSuffix = path8.replace(/^\/api\/v1/, "");
       const isAuthPath = _ParallClient.AUTH_PATHS.has(pathSuffix);
       if (!retried && !isAuthPath && this.getRefreshToken) {
         const refreshed = await this.tryRefresh();
         if (refreshed) {
-          return this.request(method, path7, body, query, true, opts);
+          return this.request(method, path8, body, query, true, opts);
         }
       }
       if (this.onTokenExpired && !isAuthPath) {
@@ -503,15 +1133,15 @@ var ParallClient = class _ParallClient {
    * hit the 100 MiB cap, so a longer 5-minute timeout is used so a
    * 50 MiB blob on a slow connection doesn't get chopped at 15 s.
    */
-  async multipartRequest(method, path7, body, retried = false) {
+  async multipartRequest(method, path8, body, retried = false) {
     if (!retried) {
-      await this.ensureFreshToken(path7);
+      await this.ensureFreshToken(path8);
     }
     const { "Content-Type": _drop, ...headers } = this.buildHeaders();
     void _drop;
     let res;
     try {
-      res = await fetch(`${this.baseUrl}${path7}`, {
+      res = await fetch(`${this.baseUrl}${path8}`, {
         method,
         headers,
         body,
@@ -521,12 +1151,12 @@ var ParallClient = class _ParallClient {
       throw _ParallClient.normalizeFetchError(err);
     }
     if (res.status === 401) {
-      const pathSuffix = path7.replace(/^\/api\/v1/, "");
+      const pathSuffix = path8.replace(/^\/api\/v1/, "");
       const isAuthPath = _ParallClient.AUTH_PATHS.has(pathSuffix);
       if (!retried && !isAuthPath && this.getRefreshToken) {
         const refreshed = await this.tryRefresh();
         if (refreshed) {
-          return this.multipartRequest(method, path7, body, true);
+          return this.multipartRequest(method, path8, body, true);
         }
       }
       if (this.onTokenExpired && !isAuthPath) {
@@ -643,6 +1273,9 @@ var ParallClient = class _ParallClient {
     const res = await this.request("GET", ENDPOINTS.ORG_MEMBERS_ONLINE(orgId));
     return res.user_ids ?? [];
   }
+  async searchRefs(orgId, params) {
+    return this.request("GET", ENDPOINTS.REF_SEARCH(orgId), void 0, params);
+  }
   async removeOrgMember(orgId, userId) {
     return this.request("DELETE", ENDPOINTS.ORG_MEMBER(orgId, userId));
   }
@@ -696,6 +1329,34 @@ var ParallClient = class _ParallClient {
   async getInvitationByToken(token) {
     return this.request("GET", ENDPOINTS.INVITATION_BY_TOKEN(token));
   }
+  // ---- Org-level shareable invite link ----
+  /** Fetch the org's current invite link. Auto-creates on first call
+   *  so the settings UI never sees an empty state. */
+  async getOrgInviteLink(orgId) {
+    return this.request("GET", ENDPOINTS.ORG_INVITE_LINK(orgId));
+  }
+  /** Rotate the token in place. The old token stops resolving immediately. */
+  async regenerateOrgInviteLink(orgId) {
+    return this.request("POST", ENDPOINTS.ORG_INVITE_LINK_REGENERATE(orgId));
+  }
+  /** Toggle the require-approval flag on the org's invite link. */
+  async updateOrgInviteLink(orgId, data) {
+    return this.request("PATCH", ENDPOINTS.ORG_INVITE_LINK(orgId), data);
+  }
+  /** Redeem an invite-link token. Caller must be authenticated; the
+   *  token is the lookup key so this endpoint is NOT org-scoped. */
+  async joinByInviteLink(token) {
+    return this.request("POST", ENDPOINTS.INVITE_LINK_JOIN, { token });
+  }
+  /** Admin: list pending invite-link join requests for an org. */
+  async listOrgJoinRequests(orgId) {
+    const res = await this.request("GET", ENDPOINTS.ORG_INVITE_LINK_JOIN_REQUESTS(orgId));
+    return res.data;
+  }
+  /** Admin: approve or reject a pending invite-link join request. */
+  async decideOrgJoinRequest(orgId, jrId, decision) {
+    return this.request("POST", ENDPOINTS.ORG_INVITE_LINK_JOIN_REQUEST_DECIDE(orgId, jrId), { decision });
+  }
   // ---- Direct Messages (org-scoped) ----
   async sendDirectMessage(orgId, req) {
     return this.request("POST", ENDPOINTS.DM(orgId), req);
@@ -965,19 +1626,20 @@ var ParallClient = class _ParallClient {
   }
   // ---- Daemon-mode Machine management (org-scoped, user auth) ----
   /**
-   * Create a new daemon-mode Machine. Returns the Machine row + one-shot
-   * mck_ token. The UI uses this when the user clicks "Create Workspace".
+   * Create a new self-hosted daemon-mode Machine. Returns the Machine row +
+   * one-shot mck_ token.
    */
   async createMachine(orgId, opts) {
     return this.request("POST", ENDPOINTS.MACHINES(orgId), opts);
   }
   /**
-   * Returns only daemon_mode=true machines (non-terminated). Backs the
-   * "Workspaces" UI list. Legacy 1:1 machines are excluded.
+   * Returns local daemon_mode=true machines (non-terminated). Backs the
+   * "Workspaces" UI list. Legacy 1:1 and retired hosted daemon machines are
+   * excluded.
    */
   async getDaemonMachines(orgId) {
     const all = await this.getMachines(orgId);
-    return all.filter((m) => m.daemon_mode && m.status !== "terminated");
+    return all.filter((m) => m.daemon_mode && m.compute_mode === "local" && m.status !== "terminated");
   }
   /** Attach an agent to a daemon-mode Machine. */
   async attachAgent(orgId, machineId, agentId, opts) {
@@ -997,8 +1659,8 @@ var ParallClient = class _ParallClient {
   async retryAgentWorkspaceSetup(orgId, machineId, agentId) {
     return this.request("POST", ENDPOINTS.MACHINE_AGENT_WORKSPACE_SETUP(orgId, machineId, agentId));
   }
-  async patchMachineLLMSource(orgId, machineId, llmSource2) {
-    return this.request("PATCH", ENDPOINTS.MACHINE_LLM_SOURCE(orgId, machineId), { llm_source: llmSource2 });
+  async patchMachineLLMSource(orgId, machineId, llmSource) {
+    return this.request("PATCH", ENDPOINTS.MACHINE_LLM_SOURCE(orgId, machineId), { llm_source: llmSource });
   }
   /** Get machine-level runtime auth state. */
   async getMachineRuntimeAuth(orgId, machineId) {
@@ -1039,8 +1701,9 @@ var ParallClient = class _ParallClient {
    * daemon should call this on a fixed cadence (e.g. every 30s) so an
    * external observer can detect a wedged supervisor.
    */
-  async postMachineHeartbeat() {
-    return this.request("POST", ENDPOINTS.MACHINES_ME_HEALTH);
+  async postMachineHeartbeat(daemonVersion) {
+    const body = daemonVersion ? { daemon_version: daemonVersion } : void 0;
+    return this.request("POST", ENDPOINTS.MACHINES_ME_HEALTH, body);
   }
   async reportAgentWorkspaceState(agentId, state) {
     const res = await this.request("PUT", ENDPOINTS.MACHINES_ME_AGENT_WORKSPACE_STATE(agentId), state);
@@ -1068,8 +1731,12 @@ var ParallClient = class _ParallClient {
   async resizeMachine(orgId, machineId, spec) {
     return this.request("PATCH", ENDPOINTS.MACHINE_SPEC(orgId, machineId), spec);
   }
-  async browseMachineFilesystem(orgId, machineId, path7) {
-    return this.request("POST", ENDPOINTS.MACHINE_BROWSE(orgId, machineId), { path: path7 }, void 0, false, { timeoutMs: 15e3 });
+  /** Signal a local daemon-mode Machine to check for and apply an update. */
+  async requestMachineUpdate(orgId, machineId, mandatory = false) {
+    await this.request("POST", ENDPOINTS.MACHINE_REQUEST_UPDATE(orgId, machineId), { mandatory });
+  }
+  async browseMachineFilesystem(orgId, machineId, path8) {
+    return this.request("POST", ENDPOINTS.MACHINE_BROWSE(orgId, machineId), { path: path8 }, void 0, false, { timeoutMs: 15e3 });
   }
   /** Create a new machine key. Returns the raw key string (shown once) + metadata. */
   async createMachineKey(orgId, machineId, name) {
@@ -1419,8 +2086,8 @@ var ParallClient = class _ParallClient {
   async deleteWikiPathScope(orgId, wikiId, scopeId) {
     await this.request("DELETE", ENDPOINTS.WIKI_PATH_SCOPE(orgId, wikiId, scopeId));
   }
-  async getWikiAccessStatus(orgId, wikiId, path7) {
-    return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path7 ? { path: path7 } : void 0);
+  async getWikiAccessStatus(orgId, wikiId, path8) {
+    return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path8 ? { path: path8 } : void 0);
   }
   async createWikiAccessRequest(orgId, wikiId, data) {
     await this.request("POST", ENDPOINTS.WIKI_ACCESS_REQUESTS(orgId, wikiId), data);
@@ -1429,11 +2096,11 @@ var ParallClient = class _ParallClient {
   async getWikiCommits(orgId, wikiId, params) {
     return this.request("GET", ENDPOINTS.WIKI_COMMITS(orgId, wikiId), void 0, params);
   }
-  async getWikiFileCommits(orgId, wikiId, path7, params) {
-    return this.request("GET", ENDPOINTS.WIKI_FILE_COMMITS(orgId, wikiId), void 0, { path: path7, ...params });
+  async getWikiFileCommits(orgId, wikiId, path8, params) {
+    return this.request("GET", ENDPOINTS.WIKI_FILE_COMMITS(orgId, wikiId), void 0, { path: path8, ...params });
   }
-  async getWikiBlame(orgId, wikiId, path7, ref) {
-    return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path7, ref });
+  async getWikiBlame(orgId, wikiId, path8, ref) {
+    return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path8, ref });
   }
   // ---- Wiki Operations (audit log) ----
   async getWikiOperations(orgId, wikiId, params) {
@@ -1917,121 +2584,12 @@ var ParallWs = class {
   }
 };
 
-// ts/daemon/dist/config.js
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-function resolvePath(value) {
-  return path.isAbsolute(value) ? value : path.resolve(process.cwd(), value);
-}
-function parseMs(value, fallback) {
-  if (!value)
-    return fallback;
-  const n = Number(value);
-  return Number.isFinite(n) && n > 0 ? n : fallback;
-}
-function parseMsAllowZero(value, fallback) {
-  if (value === void 0)
-    return fallback;
-  const n = Number(value);
-  return Number.isFinite(n) && n >= 0 ? n : fallback;
-}
-function daemonConfigDir(env = process.env) {
-  return path.join(env.HOME || os.homedir(), ".parall-daemon");
-}
-function daemonConfigPath(env = process.env) {
-  return path.join(daemonConfigDir(env), "config.json");
-}
-function tryLoadConfigFile(env) {
-  const cfgPath = daemonConfigPath(env);
-  let content;
-  try {
-    content = fs.readFileSync(cfgPath, "utf-8");
-  } catch (err) {
-    if (err.code === "ENOENT")
-      return null;
-    console.error(`Failed to read daemon config at ${cfgPath}: ${String(err)}`);
-    return null;
-  }
-  try {
-    return JSON.parse(content);
-  } catch (err) {
-    console.error(`Failed to parse daemon config at ${cfgPath}: ${String(err)}`);
-    return null;
-  }
-}
-function resolveClaudeDaemonConfig(env = process.env) {
-  let apiUrl = env.PRLL_API_URL?.trim() || "";
-  let apiKey = env.PRLL_API_KEY?.trim() || "";
-  if (!apiUrl || !apiKey) {
-    const file = tryLoadConfigFile(env);
-    if (file) {
-      if (!apiUrl && file.api_url)
-        apiUrl = file.api_url.trim();
-      if (!apiKey && file.api_key)
-        apiKey = file.api_key.trim();
-    }
-  }
-  if (!apiUrl)
-    throw new Error("Missing required env var: PRLL_API_URL");
-  if (!apiKey)
-    throw new Error("Missing required env var: PRLL_API_KEY");
-  if (!apiKey.startsWith("mck_")) {
-    throw new Error(`PRLL_API_KEY does not look like a Machine bearer (expected prefix "mck_"). Daemon mode requires a machine-scoped key issued via POST /machines/{id}/keys.`);
-  }
-  const rootClaudeHome = resolvePath(env.PRLL_CLAUDE_HOME?.trim() || env.HOME || os.homedir());
-  const rootStateDir = resolvePath(env.PRLL_CLAUDE_STATE_DIR?.trim() || path.join(rootClaudeHome, ".parall-agent"));
-  return {
-    apiUrl,
-    apiKey,
-    agentBin: env.PRLL_CLAUDE_AGENT_BIN?.trim() || "parall-claude-agent",
-    rootStateDir,
-    rootClaudeHome,
-    wsUrl: env.PRLL_WS_URL?.trim() || void 0,
-    swimlaneName: env.PRLL_SWIMLANE_NAME?.trim() || void 0,
-    pollIntervalMs: parseMs(env.PRLL_DAEMON_POLL_INTERVAL_MS, 3e4),
-    heartbeatIntervalMs: parseMs(env.PRLL_DAEMON_HEARTBEAT_INTERVAL_MS, 3e4),
-    restartBackoffMs: parseMs(env.PRLL_DAEMON_RESTART_BACKOFF_MS, 5e3),
-    restartBackoffMaxMs: parseMs(env.PRLL_DAEMON_RESTART_BACKOFF_MAX_MS, 5 * 6e4),
-    bootstrapBackoffMs: parseMsAllowZero(env.PRLL_DAEMON_BOOTSTRAP_BACKOFF_MS, 2e3),
-    bootstrapBackoffMaxMs: parseMs(env.PRLL_DAEMON_BOOTSTRAP_BACKOFF_MAX_MS, 6e4),
-    supervisorRestartBackoffMs: parseMsAllowZero(env.PRLL_DAEMON_SUPERVISOR_RESTART_BACKOFF_MS, 5e3),
-    supervisorRestartBackoffMaxMs: parseMs(env.PRLL_DAEMON_SUPERVISOR_RESTART_BACKOFF_MAX_MS, 5 * 6e4)
-  };
-}
-function assertSafeAgentId(agentId) {
-  if (!/^[A-Za-z0-9_-]+$/.test(agentId)) {
-    throw new Error(`Invalid agentId for filesystem path: ${agentId}`);
-  }
-  return agentId;
-}
-function agentStateDirFor(rootStateDir, agentId) {
-  return path.join(rootStateDir, "agents", assertSafeAgentId(agentId));
-}
-function agentClaudeHomeFor(rootClaudeHome, agentId) {
-  return path.join(rootClaudeHome, "agents", assertSafeAgentId(agentId));
-}
-function sharedClaudeCredentialsFileFor(rootClaudeHome) {
-  return path.join(rootClaudeHome, ".claude", ".credentials.json");
-}
-function agentClaudeCredentialsFileFor(agentClaudeHome) {
-  return path.join(agentClaudeHome, ".claude", ".credentials.json");
-}
-function agentWorkspaceDirFor(rootStateDir, agentId) {
-  return path.join(rootStateDir, "agents", assertSafeAgentId(agentId), "workspace");
-}
-function resolveWsUrl(apiUrl, explicitWsUrl, swimlaneName) {
-  const base = explicitWsUrl || `${apiUrl.replace(/\/$/, "").replace(/^http/, "ws")}/ws`;
-  if (!swimlaneName)
-    return base;
-  const url = new URL(base);
-  url.searchParams.set("swimlane", swimlaneName);
-  return url.toString();
-}
+// ts/daemon/dist/index.js
+init_config();
 
 // ts/daemon/dist/supervisor.js
 import { spawn as spawn2 } from "node:child_process";
-import * as fs4 from "node:fs";
+import * as fs5 from "node:fs";
 import * as path5 from "node:path";
 
 // ts/daemon/dist/filesystem.js
@@ -2148,106 +2706,52 @@ async function listDirectory(dirPath) {
   return { entries };
 }
 
+// ts/daemon/dist/supervisor.js
+init_config();
+
 // ts/daemon/dist/runtimes.js
+import * as fs3 from "node:fs";
 import * as path3 from "node:path";
-function llmSource(pc) {
-  if (pc?.llm_source)
-    return pc.llm_source;
-  if (pc?.openai_api_key || pc?.openai_base_url || pc?.anthropic_auth_token || pc?.anthropic_base_url) {
-    return "custom";
-  }
-  return "parall";
-}
-function clearAllProviderCreds(env) {
-  delete env.ANTHROPIC_AUTH_TOKEN;
-  delete env.ANTHROPIC_BASE_URL;
-  delete env.ANTHROPIC_API_KEY;
-  delete env.OPENAI_API_KEY;
-  delete env.OPENAI_BASE_URL;
-  delete env.PRLL_CLAUDE_ALLOW_API_KEY;
+init_config();
+function buildStandardEnv(baseEnv, agentId, orgId, apiKey, dirs, pc) {
+  const env = { ...baseEnv };
+  clearAllProviderCreds(env);
+  env.PRLL_API_KEY = apiKey;
+  env.PRLL_ORG_ID = orgId;
+  env.AGENT_ID = agentId;
+  env.PRLL_AGENT_ID = agentId;
+  env.PRLL_STATE_DIR = dirs.stateDir;
+  env.PRLL_WORKSPACE_DIR = dirs.workspaceDir;
+  if (pc)
+    env.PRLL_PROVIDER_CONFIG = JSON.stringify(pc);
+  delete env.PRLL_DAEMON_MODE;
+  return env;
 }
 var claudeCodeAdapter = {
   bin: "parall-claude-agent",
   buildEnv(baseEnv, agentId, orgId, apiKey, dirs, pc) {
-    const env = { ...baseEnv };
-    clearAllProviderCreds(env);
-    env.PRLL_API_KEY = apiKey;
-    env.PRLL_ORG_ID = orgId;
-    env.AGENT_ID = agentId;
-    env.PRLL_AGENT_ID = agentId;
+    const env = buildStandardEnv(baseEnv, agentId, orgId, apiKey, dirs, pc);
     env.PRLL_CLAUDE_HOME = dirs.claudeHome;
-    env.PRLL_CLAUDE_STATE_DIR = dirs.stateDir;
-    env.PRLL_CLAUDE_WORKSPACE_DIR = dirs.workspaceDir;
-    const source = llmSource(pc);
-    if (source === "parall") {
-      env.ANTHROPIC_AUTH_TOKEN = apiKey;
-      env.ANTHROPIC_BASE_URL = `${baseEnv.PRLL_API_URL}/api/llm`;
-      env.PRLL_CLAUDE_ALLOW_API_KEY = "1";
-    } else if (source === "custom") {
-      if (pc?.anthropic_auth_token) {
-        env.ANTHROPIC_AUTH_TOKEN = pc.anthropic_auth_token;
-        env.PRLL_CLAUDE_ALLOW_API_KEY = "1";
-      }
-      if (pc?.anthropic_base_url)
-        env.ANTHROPIC_BASE_URL = pc.anthropic_base_url;
-    }
-    delete env.PRLL_DAEMON_MODE;
     return env;
   }
 };
 var codexAdapter = {
   bin: "parall-codex-agent",
   buildEnv(baseEnv, agentId, orgId, apiKey, dirs, pc) {
-    const env = { ...baseEnv };
-    clearAllProviderCreds(env);
-    env.PRLL_API_KEY = apiKey;
-    env.PRLL_ORG_ID = orgId;
-    env.AGENT_ID = agentId;
-    env.PRLL_AGENT_ID = agentId;
-    env.PRLL_CODEX_STATE_DIR = dirs.stateDir;
-    env.PRLL_CODEX_WORKSPACE_DIR = dirs.workspaceDir;
+    const env = buildStandardEnv(baseEnv, agentId, orgId, apiKey, dirs, pc);
     env.PRLL_CODEX_HOME = path3.join(dirs.stateDir, ".codex");
-    const source = llmSource(pc);
-    if (source === "parall") {
-      env.OPENAI_API_KEY = apiKey;
-      env.OPENAI_BASE_URL = `${baseEnv.PRLL_API_URL}/api/llm/v1`;
-    } else if (source === "custom") {
-      if (pc?.openai_api_key)
-        env.OPENAI_API_KEY = pc.openai_api_key;
-      if (pc?.openai_base_url)
-        env.OPENAI_BASE_URL = pc.openai_base_url;
-    }
-    delete env.PRLL_DAEMON_MODE;
     return env;
   }
 };
 var defaultAdapter = {
   bin: "parall-agent",
-  buildEnv(baseEnv, agentId, orgId, apiKey, dirs) {
-    const env = { ...baseEnv };
-    env.PRLL_API_KEY = apiKey;
-    env.PRLL_ORG_ID = orgId;
-    env.AGENT_ID = agentId;
-    env.PRLL_AGENT_ID = agentId;
-    env.PRLL_STATE_DIR = dirs.stateDir;
-    env.PRLL_WORKSPACE_DIR = dirs.workspaceDir;
-    delete env.PRLL_DAEMON_MODE;
-    return env;
-  }
+  buildEnv: buildStandardEnv
 };
 var openclawAdapter = {
   bin: "parall-openclaw-agent",
-  buildEnv(baseEnv, agentId, orgId, apiKey, dirs) {
-    const env = { ...baseEnv };
-    clearAllProviderCreds(env);
-    env.PRLL_API_KEY = apiKey;
-    env.PRLL_ORG_ID = orgId;
-    env.AGENT_ID = agentId;
-    env.PRLL_AGENT_ID = agentId;
-    env.PRLL_OPENCLAW_STATE_DIR = dirs.stateDir;
-    env.PRLL_OPENCLAW_WORKSPACE_DIR = dirs.workspaceDir;
+  buildEnv(baseEnv, agentId, orgId, apiKey, dirs, pc) {
+    const env = buildStandardEnv(baseEnv, agentId, orgId, apiKey, dirs, pc);
     env.OPENCLAW_GATEWAY_PORT = env.OPENCLAW_GATEWAY_PORT || "0";
-    delete env.PRLL_DAEMON_MODE;
     return env;
   }
 };
@@ -2256,8 +2760,25 @@ var RUNTIME_ADAPTERS = {
   "codex": codexAdapter,
   "openclaw": openclawAdapter
 };
+var OVERLAY_BIN_NAMES = {
+  "claude-code": "parall-claude-agent.js",
+  "codex": "parall-codex-agent.js",
+  "openclaw": "parall-openclaw-agent.js"
+};
 function getRuntimeAdapter(runtimeType) {
-  return RUNTIME_ADAPTERS[runtimeType] ?? defaultAdapter;
+  const base = RUNTIME_ADAPTERS[runtimeType] ?? defaultAdapter;
+  const overlayName = OVERLAY_BIN_NAMES[runtimeType];
+  if (!overlayName)
+    return base;
+  try {
+    const bundleDir = resolveBundleDir();
+    const overlayBin = path3.join(bundleDir, "current", overlayName);
+    if (fs3.existsSync(overlayBin)) {
+      return { ...base, bin: overlayBin };
+    }
+  } catch {
+  }
+  return base;
 }
 function assertAgentKey(apiKey) {
   if (apiKey.startsWith("mck_")) {
@@ -2268,7 +2789,7 @@ function assertAgentKey(apiKey) {
 // ts/daemon/dist/workspace.js
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import * as fs3 from "node:fs";
+import * as fs4 from "node:fs";
 import * as path4 from "node:path";
 var OUTPUT_TAIL_LIMIT = 32 * 1024;
 var DEFAULT_SETUP_TIMEOUT_SEC = 600;
@@ -2386,7 +2907,7 @@ function resolveWorkspaceDir(workspace, defaultWorkspaceDir) {
 async function ensureWorkspace(plan, log2) {
   const ws = plan.workspace;
   if (ws.mode === "default") {
-    fs3.mkdirSync(plan.workspaceDir, { recursive: true });
+    fs4.mkdirSync(plan.workspaceDir, { recursive: true });
     assertWritableWorkspaceDir(plan.workspaceDir);
     return;
   }
@@ -2394,7 +2915,7 @@ async function ensureWorkspace(plan, log2) {
     assertSafeCustomWorkspacePath(plan);
     let st;
     try {
-      st = fs3.statSync(plan.workspaceDir);
+      st = fs4.statSync(plan.workspaceDir);
     } catch (err) {
       if (isNodeError(err) && err.code === "ENOENT") {
         throw new Error(`workspace path does not exist: ${plan.workspaceDir}`);
@@ -2404,7 +2925,7 @@ async function ensureWorkspace(plan, log2) {
     if (!st.isDirectory()) {
       throw new Error(`workspace path is not a directory: ${plan.workspaceDir}`);
     }
-    assertSafeCustomWorkspacePath(plan, fs3.realpathSync(plan.workspaceDir));
+    assertSafeCustomWorkspacePath(plan, fs4.realpathSync(plan.workspaceDir));
     assertWritableWorkspaceDir(plan.workspaceDir);
     return;
   }
@@ -2415,17 +2936,17 @@ async function ensureWorkspace(plan, log2) {
     if (plan.customWorkspaceField) {
       assertSafeCustomWorkspacePath(plan);
     }
-    if (!fs3.existsSync(plan.workspaceDir)) {
-      fs3.mkdirSync(path4.dirname(plan.workspaceDir), { recursive: true });
+    if (!fs4.existsSync(plan.workspaceDir)) {
+      fs4.mkdirSync(path4.dirname(plan.workspaceDir), { recursive: true });
       assertWritableWorkspaceDir(path4.dirname(plan.workspaceDir));
       await runCommand("git", ["clone", remote, plan.workspaceDir], process.cwd());
     } else {
-      const st = fs3.statSync(plan.workspaceDir);
+      const st = fs4.statSync(plan.workspaceDir);
       if (!st.isDirectory()) {
         throw new Error(`workspace path is not a directory: ${plan.workspaceDir}`);
       }
       if (plan.customWorkspaceField) {
-        assertSafeCustomWorkspacePath(plan, fs3.realpathSync(plan.workspaceDir));
+        assertSafeCustomWorkspacePath(plan, fs4.realpathSync(plan.workspaceDir));
       }
       assertWritableWorkspaceDir(plan.workspaceDir);
       await ensureGitWorktree(plan.workspaceDir);
@@ -2449,13 +2970,13 @@ async function verifyExistingWorkspace(plan, log2) {
     if (plan.customWorkspaceField) {
       assertSafeCustomWorkspacePath(plan);
     }
-    const st = fs3.statSync(plan.workspaceDir);
+    const st = fs4.statSync(plan.workspaceDir);
     if (!st.isDirectory()) {
       log2.warn(`workspace ready state ignored: path is not a directory: ${plan.workspaceDir}`);
       return false;
     }
     if (plan.customWorkspaceField) {
-      assertSafeCustomWorkspacePath(plan, fs3.realpathSync(plan.workspaceDir));
+      assertSafeCustomWorkspacePath(plan, fs4.realpathSync(plan.workspaceDir));
     }
     assertWritableWorkspaceDir(plan.workspaceDir);
     if (plan.workspace.mode === "git") {
@@ -2618,11 +3139,11 @@ function assertSafeCustomWorkspacePath(plan, candidate = plan.workspaceDir) {
   }
 }
 function assertWritableWorkspaceDir(dir) {
-  fs3.accessSync(dir, fs3.constants.R_OK | fs3.constants.W_OK | fs3.constants.X_OK);
+  fs4.accessSync(dir, fs4.constants.R_OK | fs4.constants.W_OK | fs4.constants.X_OK);
   const probe = path4.join(dir, `.parall-workspace-check-${process.pid}-${Date.now()}`);
-  const fd = fs3.openSync(probe, "wx", 384);
-  fs3.closeSync(fd);
-  fs3.unlinkSync(probe);
+  const fd = fs4.openSync(probe, "wx", 384);
+  fs4.closeSync(fd);
+  fs4.unlinkSync(probe);
 }
 function workspacePathDenyReason(value) {
   if (value === "/")
@@ -2729,11 +3250,16 @@ var DaemonSupervisor = class {
   machineOrgId = null;
   machineLlmSource = "parall";
   stopResolve = null;
+  updater = null;
+  healthConfirmed = false;
   constructor(config, client, log2) {
     this.config = config;
     this.client = client;
     this.log = log2;
   }
+  setUpdater(updater) {
+    this.updater = updater;
+  }
   /** Start the supervisor. Returns a promise that resolves on `stop()`. */
   async run(signal) {
     if (this.running)
@@ -2755,6 +3281,10 @@ var DaemonSupervisor = class {
       throw err;
     }
     this.migrateFlatLayout();
+    const daemonVersion = this.updater?.getLocalVersion();
+    if (daemonVersion) {
+      this.client.postMachineHeartbeat(daemonVersion).catch((err) => this.log.warn(`daemon version report failed: ${String(err)}`));
+    }
     await this.fullReconcile();
     this.ws = new ParallWs({
       getTicket: () => this.client.getMachineWsTicket(),
@@ -2763,11 +3293,33 @@ var DaemonSupervisor = class {
     });
     this.ws.on("machine.hello", (_data) => {
       this.log.info("machine WS connected (machine.hello)");
+      if (!this.healthConfirmed && this.updater) {
+        try {
+          this.updater.confirmVersion();
+          this.healthConfirmed = true;
+        } catch (err) {
+          this.log.warn(`confirmVersion failed: ${String(err)}`);
+        }
+      }
       void (async () => {
         await this.refreshMachineConfig();
         await this.fullReconcile();
       })();
     });
+    this.ws.on("machine.update", (data) => {
+      this.log.info(`WS: daemon update available \u2014 version=${data.new_version} mandatory=${data.mandatory}`);
+      if (this.updater) {
+        void this.updater.triggerUpdate(data.new_version, data.mandatory).then(async (applied) => {
+          if (applied) {
+            this.log.info("daemon update applied \u2014 stopping supervisor before restart");
+            await this.stop();
+            process.exit(42);
+          }
+        }).catch((err) => {
+          this.log.warn(`daemon update failed: ${String(err)}`);
+        });
+      }
+    });
     this.ws.on("machine.agent.attached", (data) => {
       this.log.info(`WS: agent ${data.agent_id} attached`);
       void this.handleAgentAttached(data.agent_id);
@@ -2924,13 +3476,13 @@ var DaemonSupervisor = class {
     const root = this.config.rootStateDir;
     const agentsDir = path5.join(root, "agents");
     const flatWorkspace = path5.join(root, "workspace");
-    if (!fs4.existsSync(flatWorkspace) || fs4.existsSync(agentsDir))
+    if (!fs5.existsSync(flatWorkspace) || fs5.existsSync(agentsDir))
       return;
     let ownerAgentId;
     const sessionsDir = path5.join(root, "sessions");
-    if (fs4.existsSync(sessionsDir)) {
+    if (fs5.existsSync(sessionsDir)) {
       try {
-        for (const file of fs4.readdirSync(sessionsDir)) {
+        for (const file of fs5.readdirSync(sessionsDir)) {
           if (!file.endsWith(".json"))
             continue;
           const decoded = Buffer.from(file.replace(".json", ""), "base64url").toString();
@@ -2946,11 +3498,11 @@ var DaemonSupervisor = class {
     const targetId = ownerAgentId ?? "_orphan";
     const targetDir = path5.join(agentsDir, targetId);
     try {
-      fs4.mkdirSync(targetDir, { recursive: true });
+      fs5.mkdirSync(targetDir, { recursive: true });
       for (const sub of ["workspace", "sessions", "dispatch-context"]) {
         const src = path5.join(root, sub);
-        if (fs4.existsSync(src)) {
-          fs4.renameSync(src, path5.join(targetDir, sub));
+        if (fs5.existsSync(src)) {
+          fs5.renameSync(src, path5.join(targetDir, sub));
         }
       }
       this.log.info(`migrated legacy flat state \u2192 agents/${targetId}/`);
@@ -3157,9 +3709,9 @@ var DaemonSupervisor = class {
     const isK8s = !!process.env.KUBERNETES_SERVICE_HOST;
     const claudeHome = isK8s ? agentClaudeHomeFor(this.config.rootClaudeHome, agentId) : this.config.rootClaudeHome;
     try {
-      fs4.mkdirSync(stateDir, { recursive: true });
+      fs5.mkdirSync(stateDir, { recursive: true });
       if (isK8s) {
-        fs4.mkdirSync(claudeHome, { recursive: true });
+        fs5.mkdirSync(claudeHome, { recursive: true });
         this.ensureSharedCredentialLink(claudeHome, agentId);
       }
     } catch (err) {
@@ -3288,34 +3840,38 @@ var DaemonSupervisor = class {
     const sharedCredentials = path5.resolve(sharedClaudeCredentialsFileFor(this.config.rootClaudeHome));
     const agentCredentials = agentClaudeCredentialsFileFor(agentClaudeHome);
     const agentCredentialsDir = path5.dirname(agentCredentials);
-    fs4.mkdirSync(path5.dirname(sharedCredentials), { recursive: true });
-    fs4.mkdirSync(agentCredentialsDir, { recursive: true });
+    fs5.mkdirSync(path5.dirname(sharedCredentials), { recursive: true });
+    fs5.mkdirSync(agentCredentialsDir, { recursive: true });
     try {
-      const existing = fs4.lstatSync(agentCredentials);
+      const existing = fs5.lstatSync(agentCredentials);
       if (existing.isSymbolicLink()) {
-        const currentTarget = fs4.readlinkSync(agentCredentials);
+        const currentTarget = fs5.readlinkSync(agentCredentials);
         if (path5.resolve(agentCredentialsDir, currentTarget) === sharedCredentials) {
           return;
         }
-        fs4.unlinkSync(agentCredentials);
+        fs5.unlinkSync(agentCredentials);
       } else if (existing.isDirectory()) {
         this.log.warn(`agent ${agentId}: credential path is a directory, cannot link ${agentCredentials}`);
         return;
       } else {
-        fs4.unlinkSync(agentCredentials);
+        fs5.unlinkSync(agentCredentials);
       }
     } catch (err) {
       if (err.code !== "ENOENT") {
         throw err;
       }
     }
-    fs4.symlinkSync(sharedCredentials, agentCredentials);
+    fs5.symlinkSync(sharedCredentials, agentCredentials);
   }
 };
 
+// ts/daemon/dist/index.js
+init_updater();
+
 // ts/daemon/dist/cli.js
-import * as fs5 from "node:fs";
-import * as path6 from "node:path";
+init_config();
+import * as fs7 from "node:fs";
+import * as path7 from "node:path";
 import * as os3 from "node:os";
 import * as readline from "node:readline";
 import { spawn as spawn3, execSync } from "node:child_process";
@@ -3323,15 +3879,15 @@ var CONFIG_DIR = daemonConfigDir();
 var CONFIG_PATH = daemonConfigPath();
 function readConfig() {
   try {
-    return JSON.parse(fs5.readFileSync(CONFIG_PATH, "utf-8"));
+    return JSON.parse(fs7.readFileSync(CONFIG_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeConfig(config) {
-  fs5.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
-  fs5.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 384 });
-  fs5.chmodSync(CONFIG_PATH, 384);
+  fs7.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  fs7.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 384 });
+  fs7.chmodSync(CONFIG_PATH, 384);
 }
 function prompt(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -3350,10 +3906,10 @@ function isLinux() {
 }
 var PLIST_LABEL = "com.parall.daemon";
 function plistPath() {
-  return path6.join(os3.homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+  return path7.join(os3.homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
 }
 function systemdUnitPath() {
-  return path6.join(os3.homedir(), ".config", "systemd", "user", "parall-daemon.service");
+  return path7.join(os3.homedir(), ".config", "systemd", "user", "parall-daemon.service");
 }
 function getDaemonBin() {
   try {
@@ -3363,7 +3919,7 @@ function getDaemonBin() {
   }
 }
 function generatePlist(daemonBin) {
-  const logPath = path6.join(os3.homedir(), "Library", "Logs", "parall-daemon.log");
+  const logPath = path7.join(os3.homedir(), "Library", "Logs", "parall-daemon.log");
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -3372,7 +3928,9 @@ function generatePlist(daemonBin) {
     <string>${PLIST_LABEL}</string>
     <key>ProgramArguments</key>
     <array>
-        <string>${daemonBin}</string>
+        <string>/bin/sh</string>
+        <string>-c</string>
+        <string>OVERLAY="$HOME/.parall-daemon/bundle/current/parall-daemon.js"; if [ -f "$OVERLAY" ]; then exec node "$OVERLAY"; else exec ${daemonBin}; fi</string>
     </array>
     <key>RunAtLoad</key>
     <true/>
@@ -3395,7 +3953,7 @@ Wants=network-online.target
 
 [Service]
 Type=simple
-ExecStart=${daemonBin}
+ExecStart=/bin/sh -c 'OVERLAY="$HOME/.parall-daemon/bundle/current/parall-daemon.js"; if [ -f "$OVERLAY" ]; then exec node "$OVERLAY"; else exec ${daemonBin}; fi'
 Restart=always
 RestartSec=5
 
@@ -3410,16 +3968,16 @@ function installService() {
   }
   const bin = getDaemonBin();
   if (isMacOS()) {
-    const dir = path6.dirname(plistPath());
-    fs5.mkdirSync(dir, { recursive: true });
-    fs5.writeFileSync(plistPath(), generatePlist(bin));
+    const dir = path7.dirname(plistPath());
+    fs7.mkdirSync(dir, { recursive: true });
+    fs7.writeFileSync(plistPath(), generatePlist(bin));
     execSync(`launchctl bootout gui/$(id -u) ${plistPath()} 2>/dev/null || true`);
     execSync(`launchctl bootstrap gui/$(id -u) ${plistPath()}`);
     console.log(`launchd agent installed: ${plistPath()}`);
   } else if (isLinux()) {
-    const dir = path6.dirname(systemdUnitPath());
-    fs5.mkdirSync(dir, { recursive: true });
-    fs5.writeFileSync(systemdUnitPath(), generateSystemdUnit(bin));
+    const dir = path7.dirname(systemdUnitPath());
+    fs7.mkdirSync(dir, { recursive: true });
+    fs7.writeFileSync(systemdUnitPath(), generateSystemdUnit(bin));
     execSync("systemctl --user daemon-reload");
     execSync("systemctl --user enable --now parall-daemon");
     console.log(`systemd service installed: ${systemdUnitPath()}`);
@@ -3486,8 +4044,8 @@ function cmdLogs(lines) {
     child2.on("exit", (code) => process.exit(code ?? 0));
     return;
   }
-  const logPath = path6.join(os3.homedir(), "Library", "Logs", "parall-daemon.log");
-  if (!fs5.existsSync(logPath)) {
+  const logPath = path7.join(os3.homedir(), "Library", "Logs", "parall-daemon.log");
+  if (!fs7.existsSync(logPath)) {
     console.log("No log file found at", logPath);
     return;
   }
@@ -3497,20 +4055,56 @@ function cmdLogs(lines) {
 function cmdServiceUninstall() {
   if (isMacOS()) {
     execSync(`launchctl bootout gui/$(id -u) ${plistPath()} 2>/dev/null || true`);
-    if (fs5.existsSync(plistPath()))
-      fs5.unlinkSync(plistPath());
+    if (fs7.existsSync(plistPath()))
+      fs7.unlinkSync(plistPath());
     console.log("launchd agent uninstalled.");
   } else if (isLinux()) {
     execSync("systemctl --user stop parall-daemon 2>/dev/null || true");
     execSync("systemctl --user disable parall-daemon 2>/dev/null || true");
-    if (fs5.existsSync(systemdUnitPath()))
-      fs5.unlinkSync(systemdUnitPath());
+    if (fs7.existsSync(systemdUnitPath()))
+      fs7.unlinkSync(systemdUnitPath());
     execSync("systemctl --user daemon-reload");
     console.log("systemd service uninstalled.");
   } else {
     console.log("Unsupported platform.");
   }
 }
+async function cmdUpdate(checkOnly) {
+  const { resolveClaudeDaemonConfig: resolveClaudeDaemonConfig2, resolveBundleDir: resolveBundleDir2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { DaemonUpdater: DaemonUpdater2 } = await Promise.resolve().then(() => (init_updater(), updater_exports));
+  const config = resolveClaudeDaemonConfig2(process.env);
+  const bundleDir = resolveBundleDir2(process.env);
+  const signingEnabled = !!process.env.PRLL_DAEMON_SIGNING_PUBLIC_KEY;
+  const updater = new DaemonUpdater2(bundleDir, config.updateCdnUrl, {
+    info: (msg) => console.log(msg),
+    warn: (msg) => console.warn(msg),
+    error: (msg) => console.error(msg)
+  }, signingEnabled);
+  const local = updater.getLocalVersion();
+  console.log(`Current version: ${local ?? "unknown"}`);
+  console.log(`CDN: ${config.updateCdnUrl}`);
+  console.log(`Bundle dir: ${bundleDir}`);
+  if (checkOnly) {
+    console.log("\nChecking for updates...");
+    const result = await updater.checkAvailable();
+    if (result.available) {
+      console.log(`Update available: ${result.currentVersion ?? "unknown"} \u2192 ${result.remoteVersion}`);
+    } else if (result.remoteVersion) {
+      console.log(`Already up to date (${result.currentVersion}).`);
+    } else {
+      console.log("Could not check for updates.");
+    }
+    return;
+  } else {
+    console.log("\nChecking and applying updates...");
+  }
+  const applied = await updater.checkAndApply();
+  if (applied) {
+    console.log("Update applied. Restart the daemon to use the new version.");
+  } else {
+    console.log("Already up to date.");
+  }
+}
 function printUsage() {
   console.log(`
 parall-daemon \u2014 Parall local agent runtime
@@ -3520,6 +4114,7 @@ Usage:
   parall-daemon init               Configure the daemon (interactive)
   parall-daemon status             Show daemon service status
   parall-daemon stop               Stop the background service
+  parall-daemon update [--check]   Check for / apply daemon updates
   parall-daemon logs [-n LINES]    Tail daemon logs
   parall-daemon service install    Install as background service (launchd/systemd)
   parall-daemon service uninstall  Uninstall background service
@@ -3551,6 +4146,9 @@ async function runCLI(args) {
       cmdLogs(lines);
       return "handled";
     }
+    case "update":
+      await cmdUpdate(args.includes("--check"));
+      return "handled";
     case "service": {
       const sub = args[1];
       if (sub === "install") {
@@ -3580,6 +4178,7 @@ async function runCLI(args) {
 }
 
 // ts/daemon/dist/index.js
+var UPDATE_EXIT_CODE = 42;
 var log = createLogger("daemon");
 function formatError(reason) {
   if (reason instanceof Error) {
@@ -3587,10 +4186,12 @@ function formatError(reason) {
   }
   return String(reason);
 }
-async function runForever(config, client, log2, signal) {
+async function runForever(config, client, log2, signal, updater) {
   let attempt = 0;
   while (!signal.aborted) {
     const supervisor = new DaemonSupervisor(config, client, log2);
+    if (updater)
+      supervisor.setUpdater(updater);
     try {
       await supervisor.run(signal);
       await supervisor.stop();
@@ -3619,6 +4220,16 @@ async function main() {
   const config = resolveClaudeDaemonConfig(process.env);
   log.info(`boot: api=${config.apiUrl} pollMs=${config.pollIntervalMs} heartbeatMs=${config.heartbeatIntervalMs} agentBin=${config.agentBin}`);
   log.info(`keepalive: bootstrapBackoffMs=${config.bootstrapBackoffMs} supervisorRestartBackoffMs=${config.supervisorRestartBackoffMs}`);
+  let updater = null;
+  if (!config.updateDisabled) {
+    const bundleDir = resolveBundleDir(process.env);
+    updater = new DaemonUpdater(bundleDir, config.updateCdnUrl, log, true);
+    if (updater.checkRollback()) {
+      log.info("rollback applied \u2014 exiting for service manager restart");
+      process.exit(UPDATE_EXIT_CODE);
+    }
+    log.info(`update: bundleDir=${bundleDir} cdn=${config.updateCdnUrl} interval=${config.updateIntervalMs}ms`);
+  }
   const client = new ParallClient({
     baseUrl: config.apiUrl,
     token: config.apiKey,
@@ -3640,7 +4251,18 @@ async function main() {
     process.exit(1);
   });
   config.wsUrl = resolveWsUrl(config.apiUrl, config.wsUrl, config.swimlaneName);
-  await runForever(config, client, log, abortController.signal);
+  if (updater) {
+    const applied = await updater.checkAndApply().catch((err) => {
+      log.warn(`boot update check failed: ${String(err)}`);
+      return false;
+    });
+    if (applied) {
+      log.info("boot update applied \u2014 exiting for restart");
+      process.exit(UPDATE_EXIT_CODE);
+    }
+    updater.startPeriodicCheck(config.updateIntervalMs);
+  }
+  await runForever(config, client, log, abortController.signal, updater);
 }
 var cliArgs = process.argv.slice(2);
 runCLI(cliArgs).then((result) => {