@nowcrew/daemon 0.5.32 → 0.5.33

package/README.md

@@ -66,6 +66,62 @@ crew-daemon upgrade
 crew-daemon upgrade --profile work
 ```
 
+## Managed Self-Update
+
+An owner or admin can update an eligible outdated daemon from the computer detail view. The HTTP request
+returns immediately; the server records the exact registry release, dispatches it to the daemon, and the
+Web UI polls the durable `pending -> installing -> restarting -> completed` state. Completion is recorded
+only after the native service reconnects and reports that exact version.
+
+Existing installations need one manual bootstrap to a release containing managed self-update:
+
+```bash
+crew-daemon upgrade --profile work
+crew-daemon status --profile work
+```
+
+The daemon advertises `daemon_update_v1` only when all of these conditions hold:
+
+| Requirement | Supported shape |
+| --- | --- |
+| Platform | macOS LaunchAgent or Linux systemd user service |
+| Entrypoint | global `@nowcrew/daemon/dist/main.js`, not npx or source/tsx |
+| Startup | `crew-daemon serve --profile <name>` through the installed service |
+| Profiles | exactly one installed daemon service using the global package |
+| Service | the selected profile is currently running |
+| Install root | the current user can write the global npm modules root |
+
+Windows, npx/source runs, stopped or uninstalled services, multiple installed profiles, and read-only
+global package roots remain manually upgradeable. These shapes do not show an update button.
+
+Before replacing files, the daemon refuses new work, requires zero local active or queued work, and
+non-blockingly acquires every host execution slot. It then installs only the server-selected exact
+`x.y.z` version with npm, verifies the installed package version, and schedules the existing native
+service restart from a detached helper. No package name, registry, command, or free-form argument comes
+from the browser control message.
+
+Failures are recoverable and keep a bounded code in the machine record:
+
+| Code | Operator action |
+| --- | --- |
+| `runtime_busy` | let active/queued Agent work finish, then retry |
+| `dispatch_unavailable` | restore the daemon connection, then retry |
+| `ineligible` | re-run `status` and the eligibility checks above; upgrade manually if needed |
+| `install_failed` | fix npm/network/write access; the old process keeps serving, then retry |
+| `version_mismatch` | inspect the global npm installation and install the intended version manually |
+| `restart_failed` | run `crew-daemon restart --profile work`; the package may already be updated |
+| `update_in_progress` | wait for the active request to reach a terminal state |
+| `update_timeout` | inspect `crew-daemon status --profile work`, restart if needed, then retry |
+
+Remote downgrade is intentionally unsupported. To roll back, install a known exact release and restart
+the service manually:
+
+```bash
+npm install --global --ignore-scripts --no-audit --no-fund @nowcrew/daemon@<previous-x.y.z>
+crew-daemon restart --profile work
+crew-daemon status --profile work
+```
+
 ## Execution Boundary
 
 The server selects the machine and sends a validated `execution:start` containing:
@@ -215,6 +271,8 @@ failure matrix, rollout limits, and the server-native follow-up design.
 ## Code Map
 
 - `src/serve.ts`: connection, negotiation, routing, sync, and legacy boundary.
+- `src/daemon-update-eligibility.ts`, `src/daemon-updater.ts`, and `src/daemon-update-controller.ts`:
+  managed-update eligibility, exact npm replacement, host-wide admission barrier, and restart handoff.
 - `src/execution-runner.ts`: spec admission and lifecycle reporting.
 - `src/shared-execution-slots.ts` and `src/runtime-startup-gate.ts`: machine concurrency and startup FIFO.
 - `src/local-executor.ts` and `src/execution-supervisor.ts`: runtime process boundary.

package/dist/computer-service.js

@@ -1,6 +1,6 @@
 import { access, chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { constants } from "node:fs";
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { promisify } from "node:util";
 import { dirname, resolve } from "node:path";
@@ -273,6 +273,35 @@ export async function serviceAction(spec, action, runner = systemCommandRunner)
         }
     }
 }
+const RESTART_HELPER_SOURCE = String.raw `
+const { spawnSync } = require("node:child_process");
+const spec = JSON.parse(process.argv[1]);
+setTimeout(() => {
+  if (spec.platform === "darwin") {
+    spawnSync("launchctl", ["bootout", spec.target], { stdio: "ignore", shell: false });
+    const started = spawnSync("launchctl", ["bootstrap", spec.domain, spec.descriptorPath], { stdio: "ignore", shell: false });
+    process.exit(started.status === 0 ? 0 : 1);
+  }
+  const restarted = spawnSync("systemctl", ["--user", "restart", spec.id], { stdio: "ignore", shell: false });
+  process.exit(restarted.status === 0 ? 0 : 1);
+}, 250);
+`;
+export function scheduleServiceRestart(spec, spawnDetached = spawn) {
+    if (spec.platform === "win32")
+        throw new Error("Windows detached restart is not supported");
+    if (spec.descriptorPath === null)
+        throw new Error("service descriptor is required for restart");
+    const payload = spec.platform === "darwin"
+        ? {
+            platform: spec.platform,
+            target: `${spec.managerDomain}/${spec.id}`,
+            domain: spec.managerDomain,
+            descriptorPath: spec.descriptorPath,
+        }
+        : { platform: spec.platform, id: spec.id };
+    const child = spawnDetached(process.execPath, ["-e", RESTART_HELPER_SOURCE, JSON.stringify(payload)], { detached: true, stdio: "ignore", shell: false });
+    child.unref();
+}
 export async function serviceStatus(spec, runner = systemCommandRunner) {
     if (spec.platform === "win32") {
         const task = await windowsTaskState(spec, runner);

package/dist/daemon-update-controller.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+const DaemonUpdateMessageSchema = z.object({
+    type: z.literal("daemon:update"),
+    updateId: z.string().uuid(),
+    targetVersion: z.string().regex(/^\d+\.\d+\.\d+$/),
+}).strict();
+export function createDaemonUpdateController(deps) {
+    const handled = new Set();
+    let running = null;
+    const failed = (updateId, errorCode) => {
+        deps.sendStatus({ type: "daemon:update-status", updateId, status: "failed", errorCode });
+    };
+    const execute = async (message) => {
+        const eligibility = await deps.eligibility();
+        if (!eligibility.eligible) {
+            failed(message.updateId, "ineligible");
+            return;
+        }
+        const installed = await deps.install({
+            targetVersion: message.targetVersion,
+            packageRoot: eligibility.packageRoot,
+            onInstalling: () => {
+                deps.sendStatus({ type: "daemon:update-status", updateId: message.updateId, status: "installing" });
+            },
+        });
+        if (!installed.ok) {
+            failed(message.updateId, installed.errorCode);
+            return;
+        }
+        deps.sendStatus({ type: "daemon:update-status", updateId: message.updateId, status: "restarting" });
+        try {
+            deps.scheduleRestart(eligibility.serviceSpec);
+        }
+        catch {
+            await installed.release();
+            failed(message.updateId, "restart_failed");
+        }
+    };
+    return {
+        handle: async (input) => {
+            const parsed = DaemonUpdateMessageSchema.safeParse(input);
+            if (!parsed.success)
+                return false;
+            const message = parsed.data;
+            if (handled.has(message.updateId))
+                return true;
+            if (running !== null) {
+                if (running.id === message.updateId)
+                    await running.done;
+                else
+                    failed(message.updateId, "update_in_progress");
+                return true;
+            }
+            const done = execute(message).finally(() => {
+                handled.add(message.updateId);
+                if (running?.id === message.updateId)
+                    running = null;
+            });
+            running = { id: message.updateId, done };
+            await done;
+            return true;
+        },
+    };
+}

package/dist/daemon-update-eligibility.js

@@ -0,0 +1,80 @@
+import { access } from "node:fs/promises";
+import { constants } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { daemonHome, listProfiles } from "./computer-profile.js";
+import { builtDaemonEntry, isGlobalDaemonEntry } from "./computer-cli.js";
+import { buildServiceSpec, serviceStatus, systemCommandRunner, } from "./computer-service.js";
+function defaults() {
+    const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";
+    return {
+        platform: process.platform,
+        profileHome: daemonHome(),
+        userHome: homedir(),
+        uid: process.getuid?.(),
+        nodePath: process.execPath,
+        entryPath: builtDaemonEntry(),
+        resolveGlobalNodeModules: async () => {
+            const result = await systemCommandRunner(npmCommand, ["root", "--global"]);
+            if (result.exitCode !== 0 || !result.stdout.trim()) {
+                throw new Error(result.stderr.trim() || "global npm root unavailable");
+            }
+            return result.stdout.trim();
+        },
+        listProfiles,
+        serviceStatus,
+        assertWritable: (path) => access(path, constants.W_OK),
+    };
+}
+export async function detectDaemonUpdateEligibility(profileName, overrides = {}) {
+    const deps = { ...defaults(), ...overrides };
+    if (deps.platform !== "darwin" && deps.platform !== "linux") {
+        return { eligible: false, reason: "unsupported_platform" };
+    }
+    if (!profileName)
+        return { eligible: false, reason: "profile_required" };
+    let globalNodeModules;
+    try {
+        globalNodeModules = await deps.resolveGlobalNodeModules();
+    }
+    catch {
+        return { eligible: false, reason: "global_install_required" };
+    }
+    if (!isGlobalDaemonEntry(deps.entryPath, globalNodeModules)) {
+        return { eligible: false, reason: "global_install_required" };
+    }
+    const profiles = await deps.listProfiles(deps.profileHome);
+    const installed = [];
+    for (const profile of profiles) {
+        const spec = buildServiceSpec({
+            platform: deps.platform,
+            profile,
+            userHome: deps.userHome,
+            uid: deps.uid,
+            nodePath: deps.nodePath,
+            entryPath: deps.entryPath,
+            profileHome: deps.profileHome,
+        });
+        const status = await deps.serviceStatus(spec);
+        if (status.installed)
+            installed.push({ profile, spec, running: status.running });
+    }
+    const current = installed.find((entry) => entry.profile === profileName);
+    if (!current?.running)
+        return { eligible: false, reason: "service_not_running" };
+    if (installed.length !== 1)
+        return { eligible: false, reason: "multiple_managed_profiles" };
+    try {
+        await deps.assertWritable(globalNodeModules);
+    }
+    catch {
+        return { eligible: false, reason: "global_root_not_writable" };
+    }
+    return {
+        eligible: true,
+        profileName,
+        globalNodeModules,
+        packageRoot: resolve(globalNodeModules, "@nowcrew", "daemon"),
+        serviceSpec: current.spec,
+    };
+}

package/dist/daemon-updater.js

@@ -0,0 +1,61 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { systemCommandRunner } from "./computer-service.js";
+const RELEASED_VERSION_RE = /^\d+\.\d+\.\d+$/;
+async function readPackageVersion(packageRoot) {
+    const body = JSON.parse(await readFile(resolve(packageRoot, "package.json"), "utf8"));
+    return typeof body.version === "string" ? body.version : "";
+}
+export async function installExactDaemonUpdate(input) {
+    if (!RELEASED_VERSION_RE.test(input.targetVersion)) {
+        return { ok: false, errorCode: "ineligible" };
+    }
+    const local = input.localSlots.tryAcquireExclusive();
+    if (local === null)
+        return { ok: false, errorCode: "runtime_busy" };
+    const host = await input.hostCoordinator.tryAcquireExclusiveExecution();
+    if (host === null) {
+        local.release();
+        return { ok: false, errorCode: "runtime_busy" };
+    }
+    let released = false;
+    const release = async () => {
+        if (released)
+            return;
+        released = true;
+        await host.release();
+        local.release();
+    };
+    const runner = input.runner ?? systemCommandRunner;
+    try {
+        await input.onInstalling?.();
+    }
+    catch {
+        await release();
+        return { ok: false, errorCode: "install_failed" };
+    }
+    const result = await runner(process.platform === "win32" ? "npm.cmd" : "npm", [
+        "install",
+        "--global",
+        "--ignore-scripts",
+        "--no-audit",
+        "--no-fund",
+        `@nowcrew/daemon@${input.targetVersion}`,
+    ]).catch(() => null);
+    if (result === null || result.exitCode !== 0) {
+        await release();
+        return { ok: false, errorCode: "install_failed" };
+    }
+    let installedVersion = "";
+    try {
+        installedVersion = await (input.readInstalledVersion ?? readPackageVersion)(input.packageRoot);
+    }
+    catch {
+        // Version verification is authoritative; unreadable package metadata is a mismatch.
+    }
+    if (installedVersion !== input.targetVersion) {
+        await release();
+        return { ok: false, errorCode: "version_mismatch" };
+    }
+    return { ok: true, release };
+}

package/dist/host-execution-coordinator.js

@@ -185,6 +185,28 @@ export function createHostExecutionCoordinator(options = {}) {
     return {
         reserveExecution: (prerequisite) => tracked(reservation(prerequisite, acquireExecution)),
         reserveStartup: (prerequisite) => tracked(reservation(prerequisite, acquireStartup)),
+        tryAcquireExclusiveExecution: async () => {
+            const leases = [];
+            for (let slot = 0; slot < executionSlots; slot += 1) {
+                const lease = await leaseFor(join(root, "slots", String(slot)));
+                if (lease === null) {
+                    await Promise.all(leases.map((owned) => owned.close()));
+                    return null;
+                }
+                leases.push(lease);
+            }
+            let releasePromise = null;
+            return {
+                release: () => {
+                    if (releasePromise !== null)
+                        return releasePromise;
+                    releasePromise = Promise.all(leases.map((lease) => lease.close())).then(() => undefined);
+                    pendingReleases.add(releasePromise);
+                    void releasePromise.then(() => pendingReleases.delete(releasePromise), () => pendingReleases.delete(releasePromise));
+                    return releasePromise;
+                },
+            };
+        },
         drain: async () => {
             while (pendingReleases.size > 0)
                 await Promise.all([...pendingReleases]);
@@ -216,6 +238,7 @@ export function hostCoordinatedSlotManager(local, host) {
             };
         },
         snapshot: local.snapshot,
+        tryAcquireExclusive: local.tryAcquireExclusive,
     };
 }
 export function hostCoordinatedStartupGate(local, host) {

package/dist/machine-info.js

@@ -101,9 +101,10 @@ async function listAgentHandles(agentsRoot) {
     }
 }
 export async function collectMachineHello(agentsRoot, executionLimits, runtimePlatform = process.platform, dependencies = {}) {
-    const [runtimes, agentHandles] = await Promise.all([
+    const [runtimes, agentHandles, additionalCapabilities] = await Promise.all([
         (dependencies.detectInstalled ?? detectRuntimes)(),
         listAgentHandles(agentsRoot),
+        dependencies.additionalCapabilities?.() ?? Promise.resolve([]),
     ]);
     const backend = executionBackendCapability(runtimePlatform, dependencies.jobObjectProbe);
     const executionRuntimes = backend.supported
@@ -116,7 +117,7 @@ export async function collectMachineHello(agentsRoot, executionLimits, runtimePl
         daemonVersion: daemonVersion(),
         runtimes,
         executionRuntimes,
-        capabilities: DAEMON_CAPABILITIES,
+        capabilities: [...DAEMON_CAPABILITIES, ...additionalCapabilities],
         ...(backend.supported ? {
             executionProtocol: EXECUTION_PROTOCOL,
             executionLimits: Object.freeze({

package/dist/prompt.js

@@ -11,6 +11,14 @@ export const WORKLOG_INJECT_CAP = 8000;
 export const MEMORY_INJECT_CAP = 6000;
 const WORKLOG_HEAD = 4800;
 const WORKLOG_TAIL = 3000;
+const EXTERNAL_RESULT_READABILITY = `
+
+## 外部 IM 结果可读性(CRITICAL)
+- 本节只约束通过 reply-origin 或 notify-bound-im 外发的正文;NowWork 内部确认、进度和协作消息保持原有表达方式。
+- 前三行依次说清结论、影响和需要谁做什么;不要用背景铺垫或复述任务开场。
+- 除非用户明确要求完整明细,正文最多三个短小节、最多六个要点;总结日志、命令输出和长表格,不要整段粘贴。
+- 有足够重点时,只加粗三到五处真正决定性的数字、最终状态、风险、截止时间、负责人或行动项;不足三处时宁缺毋滥。加粗范围要短,不要整段加粗,不要把每个数字都加粗,不得强化未经验证的判断。
+- 使用标题、列表、引用和加粗形成无颜色也清楚的层级;不得输出 \`<font>\` 或其它未确认可用于企微流式消息的 HTML 标色标签。`;
 export function capWorkLogForInject(workLog, cap = WORKLOG_INJECT_CAP) {
     if (workLog.length <= cap)
         return workLog;
@@ -142,17 +150,17 @@ ${taskAndScheduleCommands}`;
     const externalReplyRule = scheduled
         ? ctx.scheduledExternalNotificationPolicy === "agent_decides"
             ? `
-- **绑定会话通知由你选择**:只有本轮完整结果确实值得打扰绑定会话时,运行 \`crew message notify-bound-im --channel ${ctx.channelId}\` 一次,然后仍只返回一个完整最终报告。该命令只记录本轮决策,不会自行发消息,也不能指定收件人。`
+- **绑定会话通知由你选择**:只有本轮完整结果确实值得打扰绑定会话时,运行 \`crew message notify-bound-im --channel ${ctx.channelId}\` 一次,然后仍只返回一个完整最终报告。该命令只记录本轮决策,不会自行发消息,也不能指定收件人。${EXTERNAL_RESULT_READABILITY}`
             : ""
         : ctx.wakeOrigin === "wecom"
             ? `
-- **本轮来自企微，结束本轮前必须给出一条完整回复**:确认、过程进展和内部协作仍用普通 \`crew message send\`，只写入 NowWork。最终只用一次 \`crew message send --reply-origin\`（同时带当前 channel/thread/content 参数）发送有实质内容的完整结果；不要把 \`--send-draft\` 当成草稿 ID 或外部回复开关。Server 仍会校验 thread 来源和机器人绑定，并在本轮未形成可交付内容时发送统一兜底回复。`
+- **本轮来自企微，结束本轮前必须给出一条完整回复**:确认、过程进展和内部协作仍用普通 \`crew message send\`，只写入 NowWork。最终只用一次 \`crew message send --reply-origin\`（同时带当前 channel/thread/content 参数）发送有实质内容的完整结果；不要把 \`--send-draft\` 当成草稿 ID 或外部回复开关。Server 仍会校验 thread 来源和机器人绑定，并在本轮未形成可交付内容时发送统一兜底回复。${EXTERNAL_RESULT_READABILITY}`
             : ctx.wakeOrigin
                 ? `
-- **本轮来自${ctx.wakeOrigin === "feishu" ? "飞书" : ctx.wakeOrigin}，结束本轮前必须明确选择外部回复决策**:确认、过程进展和内部协作仍用普通 \`crew message send\`，只写入 NowWork。完整结果确实要回复外部会话时，用 \`crew message send --reply-origin\`（同时带当前 channel/thread/content 参数）；判断无需回复时，用 \`crew message skip-origin --reason "简短原因"\`。两者必须选择一个；不要把 \`--send-draft\` 当成草稿 ID 或外部回复开关。Server 仍会校验 thread 来源和机器人绑定。`
+- **本轮来自${ctx.wakeOrigin === "feishu" ? "飞书" : ctx.wakeOrigin}，结束本轮前必须明确选择外部回复决策**:确认、过程进展和内部协作仍用普通 \`crew message send\`，只写入 NowWork。完整结果确实要回复外部会话时，用 \`crew message send --reply-origin\`（同时带当前 channel/thread/content 参数）；判断无需回复时，用 \`crew message skip-origin --reason "简短原因"\`。两者必须选择一个；不要把 \`--send-draft\` 当成草稿 ID 或外部回复开关。Server 仍会校验 thread 来源和机器人绑定。${EXTERNAL_RESULT_READABILITY}`
                 : `
 - **本轮是 NowWork 内部唤醒**:普通 \`crew message send\` 只写入 NowWork。内部唤醒不得使用 \`--reply-origin\`，该参数只回答直接触发本轮的企微原消息。
-- **绑定会话主动通知**:用户明确要求同步，或最终结果有实质结论、变更或需群用户行动的阻塞时，才用一次 \`crew message send --notify-bound-im\`（同时带当前 channel/thread/content 参数）请求通知当前频道绑定的外部会话。Server 会校验绑定 owner 授权、绑定 Agent 和单轮边界；不能指定收件人。确认、进度、中间结果、无变化和重复内容一律留在 NowWork。`;
+- **绑定会话主动通知**:用户明确要求同步，或最终结果有实质结论、变更或需群用户行动的阻塞时，才用一次 \`crew message send --notify-bound-im\`（同时带当前 channel/thread/content 参数）请求通知当前频道绑定的外部会话。Server 会校验绑定 owner 授权、绑定 Agent 和单轮边界；不能指定收件人。确认、进度、中间结果、无变化和重复内容一律留在 NowWork。${EXTERNAL_RESULT_READABILITY}`;
     const interactiveTaskRules = scheduled ? "" : `
 - **毫不相关的新任务才另起线程**:只有要处理的事**和当前线程毫不相关**(或用户明确要求新建)时,才用 \`crew task create --new-thread --title "…"\`——系统另起一个子线程(parent=当前线程)绑新 task;之后这件事的回复要发到**这个新子线程**里。能不拆就不拆。
 - 任务状态流:\`todo → in_progress → in_review → done\`。claim 后用 \`crew task update\` 推进:开工→in_progress、完成待验收→in_review、人类确认后→done。只有 assignee 能改自己任务的状态。

package/dist/serve.js

@@ -31,6 +31,10 @@ import { createCompletionRetransmitter } from "./completion-retransmitter.js";
 import { createAgentMemoryBridge } from "./agent-memory/bridge.js";
 import { createRuntimeStartupGate } from "./runtime-startup-gate.js";
 import { createHostExecutionCoordinator, hostCoordinatedSlotManager, hostCoordinatedStartupGate, } from "./host-execution-coordinator.js";
+import { detectDaemonUpdateEligibility, } from "./daemon-update-eligibility.js";
+import { createDaemonUpdateController } from "./daemon-update-controller.js";
+import { installExactDaemonUpdate } from "./daemon-updater.js";
+import { scheduleServiceRestart } from "./computer-service.js";
 // normalize.ts 的活动种类 → activity 枚举
 const ACTIVITY_MAP = {
     init: "working", text: "thinking", reading: "reading", sending: "sending",
@@ -66,7 +70,8 @@ export function serve(config, opts = {}) {
     let detectedExecutionRuntimes = [];
     let runtimeFacts = null;
     const hostCoordinator = opts.execution?.hostCoordinator ?? createHostExecutionCoordinator();
-    const sharedSlots = hostCoordinatedSlotManager(createSharedSlotManager(config.executionLimits), hostCoordinator);
+    const localSlots = createSharedSlotManager(config.executionLimits);
+    const sharedSlots = hostCoordinatedSlotManager(localSlots, hostCoordinator);
     const runtimeStartupGate = hostCoordinatedStartupGate(createRuntimeStartupGate(config.executionLimits), hostCoordinator);
     const knownExecutionHashes = new Map();
     const executionReservations = new Map();
@@ -74,6 +79,24 @@ export function serve(config, opts = {}) {
     let executionFrameQueue = Promise.resolve();
     const cancellations = new Map();
     const legacyRuns = new Map();
+    const updateEligibility = opts.update?.eligibility
+        ?? (() => detectDaemonUpdateEligibility(opts.profileName));
+    const updateController = createDaemonUpdateController({
+        eligibility: updateEligibility,
+        install: opts.update?.install ?? ((input) => installExactDaemonUpdate({
+            ...input,
+            localSlots,
+            hostCoordinator,
+        })),
+        scheduleRestart: opts.update?.scheduleRestart ?? scheduleServiceRestart,
+        sendStatus: (frame) => {
+            try {
+                if (ws?.readyState === WebSocket.OPEN)
+                    ws.send(JSON.stringify(frame));
+            }
+            catch { /* reconnect/timeout reconciliation handles a lost status frame */ }
+        },
+    });
     const safeExecutionSend = (frame) => {
         try {
             if (ws?.readyState !== WebSocket.OPEN)
@@ -192,7 +215,16 @@ export function serve(config, opts = {}) {
             // 连上了才有机会把离线期间(断连原因/退出前)落盘的日志补传上去
             void drainSpool();
             // 上报本机信息 (hostname/os/daemon 版本/已装 runtimes)
-            const helloPromise = collectMachineHello(config.agentsRoot, config.executionLimits);
+            const helloPromise = collectMachineHello(config.agentsRoot, config.executionLimits, process.platform, {
+                additionalCapabilities: async () => {
+                    try {
+                        return (await updateEligibility()).eligible ? ["daemon_update_v1"] : [];
+                    }
+                    catch {
+                        return [];
+                    }
+                },
+            });
             runtimeFacts = helloPromise.then((hello) => hello.executionRuntimes, (error) => {
                 dslog("execution.runtime_detection_failed", "runtime 探测失败", {
                     level: "ERROR", error_message: error.message,
@@ -250,6 +282,14 @@ export function serve(config, opts = {}) {
             if (typeof decoded !== "object" || decoded === null)
                 return;
             const rawType = "type" in decoded && typeof decoded.type === "string" ? decoded.type : "";
+            if (rawType === "daemon:update") {
+                void updateController.handle(decoded).catch((error) => {
+                    dslog("daemon.update_failed", "daemon 更新处理失败", {
+                        level: "ERROR", error_message: error.message,
+                    });
+                });
+                return;
+            }
             if (rawType.startsWith("execution:")) {
                 const parsedExecution = ServerToDaemonExecutionFrameSchema.safeParse(decoded);
                 if (!parsedExecution.success) {

package/dist/shared-execution-slots.js

@@ -2,6 +2,7 @@ export function createSharedSlotManager(limits) {
     const activeByHandle = new Map();
     const queue = [];
     let activeTotal = 0;
+    let exclusive = false;
     const queuedFor = (handle) => queue.filter((entry) => !entry.released && entry.handle === handle).length;
     const promote = () => {
         while (activeTotal < limits.maxParallelTotal) {
@@ -28,6 +29,15 @@ export function createSharedSlotManager(limits) {
                 activeTotal,
                 queuedTotal: queue.length,
             };
+            if (exclusive) {
+                return {
+                    accepted: false,
+                    facts,
+                    ready: Promise.resolve(),
+                    isQueued: () => false,
+                    release: () => { },
+                };
+            }
             const canStartImmediately = activeTotal < limits.maxParallelTotal
                 && activeForAgent < limits.maxParallelPerAgent
                 && queue.length === 0;
@@ -79,5 +89,20 @@ export function createSharedSlotManager(limits) {
             };
         },
         snapshot: () => ({ activeTotal, queuedTotal: queue.length }),
+        tryAcquireExclusive: () => {
+            if (exclusive || activeTotal !== 0 || queue.length !== 0)
+                return null;
+            exclusive = true;
+            let released = false;
+            return {
+                release: () => {
+                    if (released)
+                        return;
+                    released = true;
+                    exclusive = false;
+                    promote();
+                },
+            };
+        },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.5.32",
+  "version": "0.5.33",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",