@nowcrew/daemon 0.5.29 → 0.5.31

package/dist/remote/wrapper.js

@@ -0,0 +1,40 @@
+import { randomUUID } from "node:crypto";
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function optionValue(args, long, short) {
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (value.startsWith(`${long}=`))
+            return value.slice(long.length + 1);
+        if (value === long || (short && value === short)) {
+            const next = args[index + 1];
+            return next && !next.startsWith("-") ? next : null;
+        }
+    }
+    return null;
+}
+export function resolveClaudeWrapperSession(args, createId = randomUUID) {
+    if (args.includes("--continue") || args.includes("-c")) {
+        throw new Error("NowCrew remote requires an explicit session ID; use --resume <session-id> instead of --continue");
+    }
+    if (args.includes("--fork-session")) {
+        throw new Error("NowCrew remote cannot identify a fork chosen inside Claude; start a new session or resume without --fork-session");
+    }
+    const sessionId = optionValue(args, "--session-id") ?? optionValue(args, "--resume", "-r") ?? createId();
+    if (!UUID.test(sessionId)) {
+        throw new Error("Claude remote sessions require a UUID in --session-id or --resume");
+    }
+    const hasSessionSelector = args.some((value) => value === "--session-id" || value.startsWith("--session-id=")
+        || value === "--resume" || value.startsWith("--resume=") || value === "-r");
+    return {
+        sessionId,
+        args: hasSessionSelector ? [...args] : ["--session-id", sessionId, ...args],
+    };
+}
+export function buildCodexWrappedInvocation(userArgs, socketPath = "") {
+    const hasRemote = userArgs.some((value) => value === "--remote" || value.startsWith("--remote="));
+    return {
+        bin: "codex",
+        args: hasRemote ? [...userArgs] : ["--remote", socketPath ? `unix://${socketPath}` : "unix://", ...userArgs],
+        env: process.env,
+    };
+}

package/dist/runner.js

@@ -106,6 +106,10 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
     }, { onActivity, onConsole }, {
         launchRuntime: dependencies.launchRuntime ?? ((request) => launchSupervisedRuntime(request, dependencies.startSupervisor, dependencies.cancellation, dependencies.platform)),
         ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }),
+        ...(dependencies.startupGate === undefined ? {} : { startupGate: dependencies.startupGate }),
+        ...(dependencies.startupTimeoutMs === undefined
+            ? {}
+            : { startupTimeoutMs: dependencies.startupTimeoutMs }),
     });
     const activities = [...local.activities];
     if (!input.scheduled && (runtime === "codex" || runtime === "kimi")

package/dist/runtime-startup-gate.js

@@ -0,0 +1,91 @@
+export function createRuntimeStartupGate(limits, now = Date.now) {
+    const activeByRuntime = new Map();
+    const queue = [];
+    let activeTotal = 0;
+    let lastLaunchAt = Number.NEGATIVE_INFINITY;
+    const promote = () => {
+        while (activeTotal < limits.maxStartingTotal) {
+            const index = queue.findIndex((entry) => !entry.released
+                && (activeByRuntime.get(entry.runtime) ?? 0) < limits.maxStartingPerRuntime);
+            if (index < 0)
+                return;
+            const [next] = queue.splice(index, 1);
+            if (!next || next.released)
+                continue;
+            next.promoted = true;
+            activeTotal += 1;
+            activeByRuntime.set(next.runtime, (activeByRuntime.get(next.runtime) ?? 0) + 1);
+            const grant = () => {
+                next.timer = null;
+                if (next.released)
+                    return;
+                next.launchGranted = true;
+                lastLaunchAt = now();
+                next.resolve();
+            };
+            const delay = Math.max(0, lastLaunchAt + limits.startupGapMs - now());
+            if (delay === 0)
+                grant();
+            else
+                next.timer = setTimeout(grant, delay);
+        }
+    };
+    return {
+        reserve: (runtime) => {
+            let resolveReady;
+            const ready = new Promise((resolve) => { resolveReady = resolve; });
+            const entry = {
+                runtime,
+                released: false,
+                promoted: false,
+                launchGranted: false,
+                timer: null,
+                resolve: resolveReady,
+            };
+            queue.push(entry);
+            promote();
+            return {
+                ready,
+                isQueued: () => !entry.launchGranted && !entry.released,
+                release: () => {
+                    if (entry.released)
+                        return;
+                    entry.released = true;
+                    if (entry.timer !== null)
+                        clearTimeout(entry.timer);
+                    if (entry.promoted) {
+                        activeTotal = Math.max(0, activeTotal - 1);
+                        const nextForRuntime = Math.max(0, (activeByRuntime.get(runtime) ?? 1) - 1);
+                        if (nextForRuntime === 0)
+                            activeByRuntime.delete(runtime);
+                        else
+                            activeByRuntime.set(runtime, nextForRuntime);
+                    }
+                    else {
+                        const index = queue.indexOf(entry);
+                        if (index >= 0)
+                            queue.splice(index, 1);
+                    }
+                    promote();
+                },
+            };
+        },
+        snapshot: () => ({
+            startingTotal: activeTotal,
+            queuedTotal: queue.length,
+            startingByRuntime: {
+                claude: activeByRuntime.get("claude") ?? 0,
+                codex: activeByRuntime.get("codex") ?? 0,
+                kimi: activeByRuntime.get("kimi") ?? 0,
+            },
+        }),
+    };
+}
+export function isRuntimeReadyEvent(runtime, event) {
+    if (typeof event !== "object" || event === null)
+        return false;
+    const value = event;
+    if (runtime === "claude")
+        return value.type === "system" && value.subtype === "init";
+    return value.type === "thread.started";
+}

package/dist/runtimes/codex-app-server-runner.js

@@ -4,6 +4,7 @@ import { parseArgs } from "node:util";
 import { pathToFileURL } from "node:url";
 import spawn from "cross-spawn";
 import { z } from "zod";
+import { signalSupervisorTree } from "../execution-supervisor.js";
 import { startFirstProgressWatchdog } from "./progress-watchdog.js";
 const RunnerInputSchema = z.object({
     systemPrompt: z.string().min(1),
@@ -18,6 +19,22 @@ const RunnerInputSchema = z.object({
 const RPC_TIMEOUT_MS = 30_000;
 const INITIALIZE_RPC_TIMEOUT_MS = 60_000;
 const ERROR_MESSAGE_CAP = 2_000;
+// LocalExecutor retains the final 2,000 stderr characters; leave room for stage and error lines.
+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;
+const PROCESS_TREE_STOP_TIMEOUT_MS = 1_000;
+class CodexRpcTimeoutError extends Error {
+    method;
+    timeoutMs;
+    constructor(method, timeoutMs) {
+        super(`Codex app-server ${method} timed out after ${timeoutMs}ms`);
+        this.method = method;
+        this.timeoutMs = timeoutMs;
+        this.name = "CodexRpcTimeoutError";
+    }
+}
 export function codexRpcTimeoutMs(method) {
     return method === "initialize" ? INITIALIZE_RPC_TIMEOUT_MS : RPC_TIMEOUT_MS;
 }
@@ -29,6 +46,87 @@ function safeErrorMessage(error, secrets) {
     }
     return message.slice(0, ERROR_MESSAGE_CAP);
 }
+function sensitiveEnvironmentValues(env) {
+    return Object.entries(env)
+        .filter(([name, value]) => value !== undefined
+        && /(?:api.?key|token|secret|password|credential|authorization)/i.test(name))
+        .map(([, value]) => value);
+}
+function redactionSecrets(input, env) {
+    const values = [input.systemPrompt, input.wakePrompt, ...sensitiveEnvironmentValues(env)];
+    return [...new Set(values.flatMap((value) => [
+            value,
+            ...value.split(/\r?\n/).map((line) => line.trim()),
+        ]).filter(Boolean))];
+}
+export function redactCodexStderr(text, secrets) {
+    let redacted = text;
+    for (const secret of [...secrets].sort((left, right) => right.length - left.length)) {
+        if (secret)
+            redacted = redacted.replaceAll(secret, "[redacted]");
+    }
+    return redacted
+        .replace(/(Bearer\s+)[^\s"']+/gi, "$1[redacted]")
+        .replace(/\bsk-[A-Za-z0-9_-]{6,}\b/g, "[redacted]")
+        .replace(/((?:api[_-]?key|access[_-]?token|auth(?:orization)?|password|secret)\s*[=:]\s*)[^\s"']+/gi, "$1[redacted]");
+}
+class StderrCapture {
+    secrets;
+    tail = "";
+    pendingLine = "";
+    omittingLine = false;
+    constructor(child, secrets) {
+        this.secrets = secrets;
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk) => this.append(chunk));
+        child.stderr?.once("end", () => this.flush());
+    }
+    redactedTail() {
+        const pending = this.omittingLine
+            ? STDERR_LINE_OMITTED
+            : redactCodexStderr(this.pendingLine, this.secrets);
+        return `${this.tail}${pending}`.slice(-STDERR_TAIL_CAP).trim();
+    }
+    append(chunk) {
+        let remaining = chunk;
+        while (remaining.length > 0) {
+            const newline = remaining.indexOf("\n");
+            const segment = newline < 0 ? remaining : remaining.slice(0, newline);
+            if (!this.omittingLine) {
+                if (this.pendingLine.length + segment.length <= STDERR_LINE_CAPTURE_CAP) {
+                    this.pendingLine += segment;
+                }
+                else {
+                    this.pendingLine = "";
+                    this.omittingLine = true;
+                }
+            }
+            if (newline < 0)
+                return;
+            this.emit(this.omittingLine ? STDERR_LINE_OMITTED : `${this.pendingLine}\n`);
+            this.pendingLine = "";
+            this.omittingLine = false;
+            remaining = remaining.slice(newline + 1);
+        }
+    }
+    flush() {
+        if (this.pendingLine.length === 0 && !this.omittingLine)
+            return;
+        this.emit(this.omittingLine ? STDERR_LINE_OMITTED : this.pendingLine);
+        this.pendingLine = "";
+        this.omittingLine = false;
+    }
+    emit(text) {
+        const redacted = redactCodexStderr(text, this.secrets);
+        process.stderr.write(redacted);
+        this.tail = `${this.tail}${redacted}`.slice(-STDERR_TAIL_CAP);
+    }
+}
+function logStage(stage, status, attempt, startedAt, detail) {
+    const suffix = detail === undefined ? "" : ` ${detail}`;
+    process.stderr.write(`[codex-app-server] stage=${stage} status=${status} attempt=${attempt}`
+        + ` elapsed_ms=${Date.now() - startedAt}${suffix}\n`);
+}
 function jsonLine(event) {
     if (process.stdout.write(`${JSON.stringify(event)}\n`))
         return Promise.resolve();
@@ -117,7 +215,7 @@ class CodexRpcClient {
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 this.pending.delete(id);
-                reject(new Error(`Codex app-server ${method} timed out after ${timeoutMs}ms`));
+                reject(new CodexRpcTimeoutError(method, timeoutMs));
             }, timeoutMs);
             this.pending.set(id, { resolve, reject, timer });
             this.write({ jsonrpc: "2.0", id, method, params });
@@ -184,31 +282,70 @@ class CodexRpcClient {
         this.pending.clear();
     }
 }
-async function stopChild(child) {
-    if (child.exitCode !== null || child.signalCode !== null)
+function processTreeAlive(child) {
+    if (process.platform === "win32" || child.pid === undefined) {
+        return child.exitCode === null && child.signalCode === null;
+    }
+    try {
+        process.kill(-child.pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+async function signalProcessTree(child, signal) {
+    if (child.pid !== undefined) {
+        try {
+            await signalSupervisorTree(child.pid, signal);
+            return;
+        }
+        catch (error) {
+            if (error.code !== "ESRCH")
+                throw error;
+        }
+    }
+    if (child.exitCode === null && child.signalCode === null)
+        child.kill(signal);
+}
+async function waitForProcessTreeExit(child, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (processTreeAlive(child) && Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+    return !processTreeAlive(child);
+}
+async function stopChildTree(child) {
+    if (!processTreeAlive(child))
+        return;
+    await signalProcessTree(child, "SIGTERM");
+    if (await waitForProcessTreeExit(child, PROCESS_TREE_STOP_TIMEOUT_MS))
         return;
-    const closed = once(child, "close").then(() => undefined);
-    child.kill("SIGTERM");
-    let timer;
-    const graceful = await Promise.race([
-        closed.then(() => true),
-        new Promise((resolve) => { timer = setTimeout(() => resolve(false), 1_000); }),
-    ]);
-    if (timer !== undefined)
-        clearTimeout(timer);
-    if (!graceful && child.exitCode === null && child.signalCode === null) {
-        child.kill("SIGKILL");
-        await closed;
+    await signalProcessTree(child, "SIGKILL");
+    if (!await waitForProcessTreeExit(child, PROCESS_TREE_STOP_TIMEOUT_MS)) {
+        throw new Error(`Codex app-server process tree ${child.pid ?? "unknown"} did not exit`);
     }
 }
-export async function runCodexAppServer(bin) {
-    const input = await readRunnerInput();
+async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs) {
+    const attemptStartedAt = Date.now();
     const child = spawn(bin, ["app-server", "--listen", "stdio://"], {
         cwd: process.cwd(),
         env: process.env,
         stdio: ["pipe", "pipe", "pipe"],
+        detached: process.platform !== "win32",
+    });
+    const secrets = redactionSecrets(input, process.env);
+    const stderr = new StderrCapture(child, secrets);
+    logStage("spawn", "start", attempt, attemptStartedAt, `pid=${child.pid ?? "unknown"}`);
+    let didSpawn = false;
+    child.once("spawn", () => {
+        didSpawn = true;
+        logStage("spawn", "ok", attempt, attemptStartedAt, `pid=${child.pid ?? "unknown"}`);
+    });
+    child.once("error", () => {
+        if (!didSpawn)
+            logStage("spawn", "error", attempt, attemptStartedAt);
     });
-    child.stderr?.pipe(process.stderr, { end: false });
     let threadId = null;
     let announcedThreadId = null;
     let turnId = null;
@@ -246,6 +383,11 @@ export async function runCodexAppServer(bin) {
                 process.stderr.write(`Codex turn error: ${detail.slice(0, ERROR_MESSAGE_CAP)}\n`);
         }
     }, completionReject);
+    let treeStopPromise = null;
+    const ensureChildTreeStopped = () => {
+        treeStopPromise ??= stopChildTree(child);
+        return treeStopPromise;
+    };
     let cancelling = false;
     const cancel = async () => {
         if (cancelling)
@@ -254,17 +396,22 @@ export async function runCodexAppServer(bin) {
         if (threadId !== null && turnId !== null) {
             await rpc.request("turn/interrupt", { threadId, turnId }, 5_000).catch(() => undefined);
         }
-        await stopChild(child);
+        await ensureChildTreeStopped();
     };
     const onSignal = () => { void cancel().finally(() => process.exit(130)); };
     process.once("SIGTERM", onSignal);
     process.once("SIGINT", onSignal);
+    let activeStage = "initialize";
+    let stageStartedAt = Date.now();
     try {
         await rpc.request("initialize", {
             clientInfo: { name: "nowcrew-daemon", version: "1" },
             capabilities: { experimentalApi: true, requestAttestation: false },
-        });
+        }, initializeTimeoutMs);
+        logStage(activeStage, "ok", attempt, stageStartedAt);
         rpc.notify("initialized");
+        activeStage = input.resume ? "thread_resume" : "thread_start";
+        stageStartedAt = Date.now();
         const threadParams = {
             cwd: process.cwd(),
             approvalPolicy: "never",
@@ -275,6 +422,7 @@ export async function runCodexAppServer(bin) {
         const thread = input.resume && input.sessionId !== undefined
             ? await rpc.request("thread/resume", { threadId: input.sessionId, ...threadParams })
             : await rpc.request("thread/start", threadParams);
+        logStage(activeStage, "ok", attempt, stageStartedAt);
         threadId = thread.thread.id;
         if (announcedThreadId !== threadId) {
             announcedThreadId = threadId;
@@ -284,6 +432,8 @@ export async function runCodexAppServer(bin) {
             completionReject(new Error("Codex produced no semantic progress within the startup window"));
             void cancel();
         });
+        activeStage = "turn_start";
+        stageStartedAt = Date.now();
         const started = await rpc.request("turn/start", {
             threadId,
             input: [
@@ -294,8 +444,12 @@ export async function runCodexAppServer(bin) {
                 ? {}
                 : { effort: input.reasoning }),
         });
+        logStage(activeStage, "ok", attempt, stageStartedAt);
         turnId = started.turn.id;
+        activeStage = "turn_complete";
+        stageStartedAt = Date.now();
         const completed = await completion;
+        logStage(activeStage, "ok", attempt, stageStartedAt);
         firstProgress.stop();
         const usage = lastUsage?.last;
         await jsonLine({
@@ -309,33 +463,76 @@ export async function runCodexAppServer(bin) {
             }),
         });
         if (completed.turn?.status === "completed")
-            return 0;
+            return { code: 0, initializeTimedOut: false };
         const detail = completed.turn?.error?.message ?? `turn status ${completed.turn?.status ?? "unknown"}`;
         process.stderr.write(`Codex turn failed: ${detail.slice(0, ERROR_MESSAGE_CAP)}\n`);
-        return completed.turn?.status === "interrupted" ? 130 : 1;
+        return {
+            code: completed.turn?.status === "interrupted" ? 130 : 1,
+            initializeTimedOut: false,
+        };
     }
     catch (error) {
-        process.stderr.write(`Codex app-server execution failed: ${safeErrorMessage(error, [input.systemPrompt, input.wakePrompt])}\n`);
-        return 1;
+        const initializeTimedOut = error instanceof CodexRpcTimeoutError && error.method === "initialize";
+        if (initializeTimedOut) {
+            const tail = stderr.redactedTail();
+            logStage(activeStage, "timeout", attempt, stageStartedAt, `stderr_tail=${JSON.stringify(tail || "[empty]")}`);
+        }
+        else {
+            logStage(activeStage, "error", attempt, stageStartedAt);
+        }
+        process.stderr.write(`Codex app-server execution failed: ${safeErrorMessage(error, secrets)}\n`);
+        return { code: 1, initializeTimedOut };
     }
     finally {
         firstProgress.stop();
         process.off("SIGTERM", onSignal);
         process.off("SIGINT", onSignal);
-        await stopChild(child);
+        const cleanupStartedAt = Date.now();
+        try {
+            await ensureChildTreeStopped();
+            logStage("cleanup", "ok", attempt, cleanupStartedAt);
+        }
+        catch (error) {
+            logStage("cleanup", "error", attempt, cleanupStartedAt);
+            throw error;
+        }
+    }
+}
+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 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`);
     }
+    return 1;
 }
-function binFromArgv(argv) {
+function configFromArgv(argv) {
     const { values } = parseArgs({
         args: [...argv],
-        options: { bin: { type: "string" } },
+        options: {
+            bin: { type: "string" },
+            "initialize-timeout-ms": { type: "string" },
+        },
     });
     if (!values.bin)
         throw new Error("--bin is required");
-    return values.bin;
+    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 };
 }
 if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
-    runCodexAppServer(binFromArgv(process.argv.slice(2)))
+    const config = configFromArgv(process.argv.slice(2));
+    runCodexAppServer(config.bin, config.initializeTimeoutMs === undefined
+        ? {}
+        : { initializeTimeoutMs: config.initializeTimeoutMs })
         .then((code) => { process.exitCode = code; })
         .catch((error) => {
         process.stderr.write(`Codex app-server runner failed: ${safeErrorMessage(error, [])}\n`);

package/dist/serve.js

@@ -28,6 +28,8 @@ 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 { createRuntimeStartupGate } from "./runtime-startup-gate.js";
+import { createHostExecutionCoordinator, hostCoordinatedSlotManager, hostCoordinatedStartupGate, } from "./host-execution-coordinator.js";
 // normalize.ts 的活动种类 → activity 枚举
 const ACTIVITY_MAP = {
     init: "working", text: "thinking", reading: "reading", sending: "sending",
@@ -60,7 +62,9 @@ export function serve(config, opts = {}) {
     const executeProtocol = opts.execution?.runExecution ?? runExecution;
     let detectedExecutionRuntimes = [];
     let runtimeFacts = null;
-    const sharedSlots = createSharedSlotManager(config.executionLimits);
+    const hostCoordinator = opts.execution?.hostCoordinator ?? createHostExecutionCoordinator();
+    const sharedSlots = hostCoordinatedSlotManager(createSharedSlotManager(config.executionLimits), hostCoordinator);
+    const runtimeStartupGate = hostCoordinatedStartupGate(createRuntimeStartupGate(config.executionLimits), hostCoordinator);
     const knownExecutionHashes = new Map();
     const executionReservations = new Map();
     const executionRuns = new Map();
@@ -115,8 +119,11 @@ export function serve(config, opts = {}) {
         if ((entry.state === "completed" || entry.state === "interrupted") && entry.completion !== null) {
             return { executionId: entry.executionId, state: entry.state, completion: entry.completion, updatedAt: entry.updatedAt };
         }
+        if (entry.state === "running" && entry.runtimeReadyAt !== null) {
+            return { executionId: entry.executionId, state: "running", updatedAt: entry.runtimeReadyAt };
+        }
         if (entry.state === "accepted" || entry.state === "running") {
-            return { executionId: entry.executionId, state: entry.state, updatedAt: entry.updatedAt };
+            return { executionId: entry.executionId, state: "accepted", updatedAt: entry.acceptedAt };
         }
         return null;
     };
@@ -137,10 +144,10 @@ export function serve(config, opts = {}) {
                 state: acceptanceState, effectivePermission: entry.effectivePermission ?? "workspace_write",
                 at: entry.acceptedAt,
             });
-            if (entry.state === "running" && entry.processStartedAt !== null) {
+            if (entry.state === "running" && entry.runtimeReadyAt !== null) {
                 safeExecutionSend({
                     type: "execution:started", protocolVersion: 1,
-                    executionId: entry.executionId, at: entry.processStartedAt,
+                    executionId: entry.executionId, at: entry.runtimeReadyAt,
                 });
             }
         }
@@ -335,8 +342,30 @@ export function serve(config, opts = {}) {
                         }
                         return;
                     }
-                    knownExecutionHashes.set(spec.executionId, hash);
                     const reservation = sharedSlots.reserve(spec.agent.handle, "execution");
+                    if (!reservation.accepted) {
+                        dslog("execution.machine_queue_rejected", "机器执行队列已满", {
+                            level: "WARN",
+                            execution_id: spec.executionId,
+                            agent_handle: spec.agent.handle,
+                            ...reservation.facts,
+                        });
+                        safeExecutionSend(ExecutionRejectedSchema.parse({
+                            type: "execution:rejected", protocolVersion: 1, executionId: spec.executionId,
+                            reason: "resource_limit", message: "Local machine execution queue is full",
+                            at: new Date().toISOString(),
+                        }));
+                        return;
+                    }
+                    knownExecutionHashes.set(spec.executionId, hash);
+                    const machineQueueEnteredAt = Date.now();
+                    if (reservation.isQueued()) {
+                        dslog("execution.machine_queued", "execution 已进入机器队列", {
+                            execution_id: spec.executionId,
+                            agent_handle: spec.agent.handle,
+                            ...reservation.facts,
+                        });
+                    }
                     executionReservations.set(spec.executionId, reservation);
                     const cancellation = cancellationFor(spec.executionId);
                     const cleanupExecutionReservation = () => {
@@ -371,8 +400,22 @@ export function serve(config, opts = {}) {
                             ...reservation.facts,
                         },
                         report: reportExecutionFrame,
+                        startupGate: runtimeStartupGate,
+                        startupTimeoutMs: config.executionLimits.startupTimeoutMs,
                         ...(reservation.state === undefined ? {} : {
-                            slot: { state: reservation.state, ready: reservation.ready },
+                            slot: {
+                                state: reservation.state,
+                                ready: reservation.ready.then(() => {
+                                    const snapshot = sharedSlots.snapshot();
+                                    dslog("execution.machine_slot_ready", "execution 获得机器执行名额", {
+                                        execution_id: spec.executionId,
+                                        agent_handle: spec.agent.handle,
+                                        queue_ms: Date.now() - machineQueueEnteredAt,
+                                        active_total: snapshot.activeTotal,
+                                        queued_total: snapshot.queuedTotal,
+                                    });
+                                }),
+                            },
                         }),
                         cancellation,
                     }).finally(() => {
@@ -539,12 +582,26 @@ export function serve(config, opts = {}) {
                 }
                 running.add(key);
                 legacyReservation = sharedSlots.reserve(msg.agentHandle, "legacy");
+                if (legacyReservation.isQueued()) {
+                    const snapshot = sharedSlots.snapshot();
+                    dslog("run.machine_queued", "legacy run 已进入机器队列", {
+                        ...runKeys,
+                        active_total: snapshot.activeTotal,
+                        queued_total: snapshot.queuedTotal,
+                    });
+                }
                 await awaitWithCancellation(legacyReservation.ready, controller.cancellation);
                 const queueMs = Date.now() - queueWaitStart;
+                const machineSnapshot = sharedSlots.snapshot();
                 const threadLabel = threadId ?? null;
                 const from = msg.wake?.senderHandle ?? "?";
                 const incoming = msg.wake?.content ?? "";
-                dslog("run.start", `开始运行 ${msg.agentHandle}`, { ...runKeys, queue_ms: queueMs });
+                dslog("run.start", `开始运行 ${msg.agentHandle}`, {
+                    ...runKeys,
+                    queue_ms: queueMs,
+                    active_total: machineSnapshot.activeTotal,
+                    queued_total: machineSnapshot.queuedTotal,
+                });
                 log(`\n${"─".repeat(56)}`);
                 log(`🔔 唤醒 agent=${msg.agentHandle}  reason=${msg.reason ?? "?"}`);
                 log(`   channel = ${msg.channelId}`);
@@ -650,7 +707,11 @@ export function serve(config, opts = {}) {
                         ...(!scheduled && threadId ? { wakeMessageId: threadId } : {}),
                         ...(!scheduled && msg.wake?.seq !== undefined ? { wakeContextUpToSeq: msg.wake.seq } : {}),
                         ...(attemptWake ? { wake: attemptWake } : {}),
-                    }, reportActivity, reportConsole, { cancellation: controller.cancellation });
+                    }, reportActivity, reportConsole, {
+                        cancellation: controller.cancellation,
+                        startupGate: runtimeStartupGate,
+                        startupTimeoutMs: config.executionLimits.startupTimeoutMs,
+                    });
                 });
                 const result = mergeRunAgentResults(guarded.results);
                 // 本轮 token 用量上报:runner 已从 result 事件提取(含缓存读/写细分),
@@ -848,6 +909,7 @@ export function serve(config, opts = {}) {
                 for (const run of legacyRuns.values())
                     run.controller.request();
                 await deadline.waitFor(Promise.all(pending));
+                await deadline.waitFor(hostCoordinator.drain());
                 await executionJournal.close({ signal: deadline.signal });
             }
             finally {