@nowcrew/daemon 0.5.31 → 0.5.33

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/execution-journal-lock.js

@@ -52,6 +52,8 @@ export function createJournalLeaseRegistry() {
     return { leases: new Map() };
 }
 const codeOf = (error) => error instanceof Error && "code" in error ? error.code : undefined;
+const missingDuringOwnerRead = (error) => codeOf(error) === "ENOENT"
+    || (error instanceof Error && codeOf(error.cause) === "ENOENT");
 const ownerFileName = (token) => `owner.${token}.json`;
 const releasedLockName = (token) => `.journal.released.${token}.lock`;
 const RELEASED_LOCK_PATTERN = /^\.journal\.released\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.lock$/i;
@@ -99,8 +101,6 @@ export async function inspectJournalLock(options) {
     const lockDirectory = join(options.directory, ".journal.lock");
     const orphanGraceMs = options.orphanGraceMs ?? 30_000;
     const now = options.now ?? (() => new Date());
-    const missingDuringOwnerRead = (error) => codeOf(error) === "ENOENT"
-        || (error instanceof Error && codeOf(error.cause) === "ENOENT");
     for (let attempt = 0; attempt < 2; attempt += 1) {
         let names;
         try {
@@ -230,7 +230,15 @@ export function createJournalLease(options) {
             throw error;
         }
         if (names.length === 0) {
-            const lockStat = await fileSystem.stat(lockDirectory);
+            let lockStat;
+            try {
+                lockStat = await fileSystem.stat(lockDirectory);
+            }
+            catch (error) {
+                if (codeOf(error) === "ENOENT")
+                    return null;
+                throw error;
+            }
             if (now().valueOf() - lockStat.mtimeMs < orphanGraceMs) {
                 throw new JournalLockedError("Execution journal lock owner installation is in progress", { journalPath });
             }
@@ -247,7 +255,16 @@ export function createJournalLease(options) {
         if (names.length !== 1 || !/^owner\.[0-9a-f-]+\.json$/i.test(names[0])) {
             throw new JournalLockCorruptionError(lockDirectory, new Error("lock directory must contain one owner"));
         }
-        return { owner: await parseLockOwner(lockDirectory, names[0], fileSystem), fileName: names[0] };
+        try {
+            return { owner: await parseLockOwner(lockDirectory, names[0], fileSystem), fileName: names[0] };
+        }
+        catch (error) {
+            // The current owner commits release by renaming the entire lock directory.
+            // A contender may therefore observe its filename just before it disappears.
+            if (missingDuringOwnerRead(error))
+                return null;
+            throw error;
+        }
     };
     const validateInstalledOwner = async (lease) => {
         const observed = await readOwner();

package/dist/execution-protocol.js

@@ -98,6 +98,7 @@ export const ExecutionStartSchema = z.object({
     agent: z.object({
         id: z.string().min(1),
         handle: AgentHandleSchema,
+        memoryEnabled: z.boolean().optional(),
     }).strict(),
     workspace: z.object({
         taskKey: z.string().min(1).max(200),

package/dist/execution-runner.js

@@ -13,6 +13,7 @@ import { executionBackendCapability } from "./execution-backend.js";
 import { readBoundImDecisionFile, resetBoundImDecisionFile } from "./bound-im-decision.js";
 import { RuntimeCancelledError } from "./runtime-cancellation.js";
 import { supervisorLaunch } from "./supervised-runtime.js";
+import { appendAgentMemoryContext } from "./agent-memory/policy.js";
 export { supervisorLaunch } from "./supervised-runtime.js";
 const ACTIVITY_KIND = {
     init: "working",
@@ -388,6 +389,7 @@ export async function runExecution(config, input, dependencies) {
     let timeout;
     let timedOut = false;
     let completion;
+    let memoryCaptureFinalText = null;
     let boundImDecision = spec.reporting.allowBoundImDecision
         ? "silent"
         : undefined;
@@ -399,6 +401,16 @@ export async function runExecution(config, input, dependencies) {
         if (dependencies.slot !== undefined) {
             await cancellable(dependencies.slot.ready, dependencies.cancellation);
         }
+        let recalledMemory = "";
+        if (spec.agent.memoryEnabled === true && dependencies.agentMemory !== undefined) {
+            try {
+                recalledMemory = await cancellable(dependencies.agentMemory.recall(spec.agent.handle, spec.instructions.wakePrompt), dependencies.cancellation);
+            }
+            catch (error) {
+                if (error instanceof ExecutionCancelledError)
+                    throw error;
+            }
+        }
         const credential = await cancellable(mint(config.serverUrl, config.machineToken, spec.agent.handle, undefined, { executionId: spec.executionId, agentRunId: spec.executionId }), dependencies.cancellation);
         const providerConfig = launchProviderConfig(credential.config);
         let activitySequence = 0;
@@ -545,6 +557,12 @@ export async function runExecution(config, input, dependencies) {
                 }
             },
         };
+        const systemPromptBudget = config.executionLimits.maxPromptBytes
+            - Buffer.byteLength(spec.instructions.wakePrompt, "utf8");
+        const systemPromptWithLocalFacts = withLocalExecutionFacts(spec.instructions.systemPrompt, systemPromptBudget);
+        const boundedSystemPrompt = (context) => appendAgentMemoryContext(typeof systemPromptWithLocalFacts === "string"
+            ? systemPromptWithLocalFacts
+            : systemPromptWithLocalFacts(context), recalledMemory, systemPromptBudget);
         const localInput = {
             executionId: spec.executionId,
             handle: spec.agent.handle,
@@ -554,8 +572,7 @@ export async function runExecution(config, input, dependencies) {
             ...(spec.workspace.resumeKey === undefined ? {} : { resumeKey: spec.workspace.resumeKey }),
             ...(spec.context.wakeMessageId === undefined ? {} : { wakeMessageId: spec.context.wakeMessageId }),
             ...(spec.context.attachments === undefined ? {} : { attachments: spec.context.attachments }),
-            systemPrompt: withLocalExecutionFacts(spec.instructions.systemPrompt, config.executionLimits.maxPromptBytes
-                - Buffer.byteLength(spec.instructions.wakePrompt, "utf8")),
+            systemPrompt: boundedSystemPrompt,
             wakePrompt: spec.instructions.wakePrompt,
             runtime: {
                 name: spec.runtime.name,
@@ -593,6 +610,8 @@ export async function runExecution(config, input, dependencies) {
         if (timeout !== undefined)
             clearTimeout(timeout);
         const finishedAt = now().toISOString();
+        if (result.exitCode === 0 && result.finalText?.trim())
+            memoryCaptureFinalText = result.finalText;
         if (spec.reporting.allowBoundImDecision) {
             const path = join(result.workspaceRunDir, `.bound-im-decision-${spec.executionId}.json`);
             const selected = await readBoundImDecision(path);
@@ -677,6 +696,17 @@ export async function runExecution(config, input, dependencies) {
     completion = boundExecutionFrame(completion, config.executionLimits.maxEventBytes);
     await telemetry.closeAndDrain();
     await dependencies.journal.complete(spec.executionId, completion);
+    if (completion.outcome === "succeeded"
+        && spec.agent.memoryEnabled === true
+        && memoryCaptureFinalText !== null
+        && dependencies.agentMemory !== undefined) {
+        try {
+            await dependencies.agentMemory.capture(spec.agent.handle, spec.executionId, spec.instructions.wakePrompt, memoryCaptureFinalText);
+        }
+        catch {
+            // External memory is optional and must never alter the durable execution outcome.
+        }
+    }
     await dependencies.report(completion);
     return { kind: "completed", frame: completion };
 }

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/local-executor.js

@@ -266,8 +266,13 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const attachmentPlan = routeRuntimeAttachments(runtime.name, materialized?.attachments ?? []);
         const wakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
         await awaitWithCancellation(writeFile(workspace.systemPromptPath, systemPrompt, "utf8"), dependencies.cancellation);
+        const inheritedEnv = { ...process.env };
+        for (const key of Object.keys(inheritedEnv)) {
+            if (key.startsWith("CREW_AGENT_MEMORY_"))
+                delete inheritedEnv[key];
+        }
         const baseEnv = {
-            ...process.env,
+            ...inheritedEnv,
             ...sanitizeEnvVars(providerConfig.envVars),
             ...input.launch.systemEnv,
             PATH: `${workspace.crewDir}${delimiter}${augmentedPath()}`,

package/dist/machine-info.js

@@ -26,6 +26,7 @@ export const DAEMON_CAPABILITIES = [
     "execution_attachments_v1",
     "execution_answer_stream_v1",
     "execution_machine_queue_v1",
+    "execution_agent_memory_policy_v1",
 ];
 export const EXECUTION_PROTOCOL = Object.freeze({ min: 1, max: 1 });
 /** 候选 runtime CLI:展示名 → 可执行文件名。 */
@@ -100,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
@@ -115,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/runtimes/codex-app-server-runner.js

@@ -24,7 +24,24 @@ const STDERR_TAIL_CAP = 1_200;
 const STDERR_LINE_CAPTURE_CAP = 1_200;
 const STDERR_LINE_OMITTED = "[stderr line omitted: exceeded capture limit]\n";
 const MAX_INITIALIZE_ATTEMPTS = 2;
+// 模型网关瞬态故障(过载/限流)导致 turn 失败时,整轮重试(15s→45s 递进退避):codex 自身
+// 的重试窗口只有 ~10-30s,网关过载往往持续数分钟,这里再兜一层,否则 agent 直接失败
+// 不回复(2026-08-10 事故,普通会话与定时任务都中招)。
+const MAX_TRANSIENT_TURN_RETRIES = 2;
+const TRANSIENT_TURN_RETRY_DELAY_MS = 15_000;
+const TRANSIENT_TURN_RETRY_BACKOFF_FACTOR = 3;
 const PROCESS_TREE_STOP_TIMEOUT_MS = 1_000;
+const TRANSIENT_TURN_ERROR_PATTERNS = [
+    /at capacity/i,
+    /overloaded/i,
+    /rate.?limit/i,
+    /too many requests/i,
+];
+/** 模型侧瞬态失败(网关过载/限流)→ 换个时间整轮重试大概率成功。
+ *  interrupted 不算:那是取消信号或 codex collab 连带中断,重跑语义不明确。 */
+export function isTransientTurnFailure(detail) {
+    return TRANSIENT_TURN_ERROR_PATTERNS.some((pattern) => pattern.test(detail));
+}
 class CodexRpcTimeoutError extends Error {
     method;
     timeoutMs;
@@ -469,6 +486,9 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
         return {
             code: completed.turn?.status === "interrupted" ? 130 : 1,
             initializeTimedOut: false,
+            transientTurnFailure: !cancelling
+                && completed.turn?.status === "failed"
+                && isTransientTurnFailure(detail),
         };
     }
     catch (error) {
@@ -501,13 +521,27 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
 export async function runCodexAppServer(bin, options = {}) {
     const input = await readRunnerInput();
     const initializeTimeoutMs = Math.min(options.initializeTimeoutMs ?? INITIALIZE_RPC_TIMEOUT_MS, INITIALIZE_RPC_TIMEOUT_MS);
-    for (let attempt = 1; attempt <= MAX_INITIALIZE_ATTEMPTS; attempt += 1) {
+    const turnRetryDelayMs = options.turnRetryDelayMs ?? TRANSIENT_TURN_RETRY_DELAY_MS;
+    let initializeTimeouts = 0;
+    let turnRetries = 0;
+    for (let attempt = 1;; attempt += 1) {
         const result = await runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs);
-        if (!result.initializeTimedOut || attempt === MAX_INITIALIZE_ATTEMPTS)
-            return result.code;
-        process.stderr.write(`[codex-app-server] stage=retry status=start attempt=${attempt + 1} elapsed_ms=0 reason=initialize_timeout\n`);
+        if (result.initializeTimedOut) {
+            initializeTimeouts += 1;
+            if (initializeTimeouts >= MAX_INITIALIZE_ATTEMPTS)
+                return result.code;
+            process.stderr.write(`[codex-app-server] stage=retry status=start attempt=${attempt + 1} elapsed_ms=0 reason=initialize_timeout\n`);
+            continue;
+        }
+        if (result.transientTurnFailure && turnRetries < MAX_TRANSIENT_TURN_RETRIES) {
+            const delayMs = turnRetryDelayMs * TRANSIENT_TURN_RETRY_BACKOFF_FACTOR ** turnRetries;
+            turnRetries += 1;
+            process.stderr.write(`[codex-app-server] stage=retry status=start attempt=${attempt + 1} elapsed_ms=0 reason=transient_turn_failure\n`);
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+            continue;
+        }
+        return result.code;
     }
-    return 1;
 }
 function configFromArgv(argv) {
     const { values } = parseArgs({
@@ -515,24 +549,34 @@ function configFromArgv(argv) {
         options: {
             bin: { type: "string" },
             "initialize-timeout-ms": { type: "string" },
+            "turn-retry-delay-ms": { type: "string" },
         },
     });
     if (!values.bin)
         throw new Error("--bin is required");
-    const rawTimeout = values["initialize-timeout-ms"];
-    if (rawTimeout === undefined)
-        return { bin: values.bin };
-    const initializeTimeoutMs = Number(rawTimeout);
-    if (!Number.isInteger(initializeTimeoutMs) || initializeTimeoutMs <= 0) {
-        throw new Error("--initialize-timeout-ms must be a positive integer");
-    }
-    return { bin: values.bin, initializeTimeoutMs };
+    const positiveInteger = (raw, flag) => {
+        if (raw === undefined)
+            return undefined;
+        const value = Number(raw);
+        if (!Number.isInteger(value) || value <= 0) {
+            throw new Error(`${flag} must be a positive integer`);
+        }
+        return value;
+    };
+    const initializeTimeoutMs = positiveInteger(values["initialize-timeout-ms"], "--initialize-timeout-ms");
+    const turnRetryDelayMs = positiveInteger(values["turn-retry-delay-ms"], "--turn-retry-delay-ms");
+    return {
+        bin: values.bin,
+        ...(initializeTimeoutMs === undefined ? {} : { initializeTimeoutMs }),
+        ...(turnRetryDelayMs === undefined ? {} : { turnRetryDelayMs }),
+    };
 }
 if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
     const config = configFromArgv(process.argv.slice(2));
-    runCodexAppServer(config.bin, config.initializeTimeoutMs === undefined
-        ? {}
-        : { initializeTimeoutMs: config.initializeTimeoutMs })
+    runCodexAppServer(config.bin, {
+        ...(config.initializeTimeoutMs === undefined ? {} : { initializeTimeoutMs: config.initializeTimeoutMs }),
+        ...(config.turnRetryDelayMs === undefined ? {} : { turnRetryDelayMs: config.turnRetryDelayMs }),
+    })
         .then((code) => { process.exitCode = code; })
         .catch((error) => {
         process.stderr.write(`Codex app-server runner failed: ${safeErrorMessage(error, [])}\n`);

package/dist/serve.js

@@ -28,8 +28,13 @@ import { closeWebSocketWithinDeadline } from "./websocket-shutdown.js";
 import { reconcileExecutionJournal } from "./execution-recovery.js";
 import { createSharedSlotManager } from "./shared-execution-slots.js";
 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",
@@ -58,12 +63,15 @@ export function serve(config, opts = {}) {
     let reconnectTimer = null;
     let stopPromise = null;
     const executionJournal = opts.execution?.journal ?? createExecutionJournal(config.agentsRoot);
+    const agentMemory = opts.execution?.dependencies?.agentMemory
+        ?? (config.agentMemory === null ? undefined : createAgentMemoryBridge(config.agentMemory));
     const executionTelemetry = createExecutionTelemetryJournal(config.agentsRoot);
     const executeProtocol = opts.execution?.runExecution ?? runExecution;
     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();
@@ -71,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)
@@ -189,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,
@@ -247,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) {
@@ -394,6 +437,7 @@ export function serve(config, opts = {}) {
                     }
                     const execution = executeProtocol(config, spec, {
                         ...opts.execution?.dependencies,
+                        ...(agentMemory === undefined ? {} : { agentMemory }),
                         journal: executionJournal,
                         facts: {
                             availableRuntimes,

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.31",
+  "version": "0.5.33",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",