@nowcrew/daemon 0.5.19 → 0.5.21

package/dist/serve.js

@@ -22,15 +22,20 @@ import { createExecutionTelemetryJournal } from "./execution-telemetry-journal.j
 import { ExecutionRejectedSchema, ExecutionSnapshotSchema, LegacyAgentStartSchema, ServerToDaemonExecutionFrameSchema, } from "./execution-protocol.js";
 import { hashExecutionSpec, runExecution, } from "./execution-runner.js";
 import { executionBackendCapability } from "./execution-backend.js";
+import { awaitWithCancellation, createRuntimeCancellation, RuntimeCancelledError, } from "./runtime-cancellation.js";
+import { createShutdownDeadline, readTestShutdownConfiguration } from "./shutdown-deadline.js";
+import { closeWebSocketWithinDeadline } from "./websocket-shutdown.js";
+import { reconcileExecutionJournal } from "./execution-recovery.js";
+import { createSharedSlotManager } from "./shared-execution-slots.js";
 // normalize.ts 的活动种类 → activity 枚举
 const ACTIVITY_MAP = {
     init: "working", text: "thinking", reading: "reading", sending: "sending",
     checking: "checking", claiming: "claiming", crew: "working", tool: "working",
     tool_result: "working", done: "done", error: "error",
 };
-export function buildControlPlaneUrl(serverUrl, machineToken, runtimePlatform = process.platform) {
+export function buildControlPlaneUrl(serverUrl, machineToken, runtimePlatform = process.platform, jobObjectProbe) {
     const query = new URLSearchParams({ key: machineToken });
-    if (executionBackendCapability(runtimePlatform).supported) {
+    if (executionBackendCapability(runtimePlatform, jobObjectProbe).supported) {
         query.set("execution_min", String(EXECUTION_PROTOCOL.min));
         query.set("execution_max", String(EXECUTION_PROTOCOL.max));
     }
@@ -44,24 +49,23 @@ export function serve(config, opts = {}) {
     let ws = null;
     let backoff = 1000;
     const maxBackoff = opts.maxBackoffMs ?? 30_000;
+    const testShutdown = readTestShutdownConfiguration(process.env);
+    const shutdownTimeoutMs = opts.shutdownTimeoutMs ?? testShutdown.timeoutMs ?? 30_000;
+    const createWebSocket = opts.createWebSocket ?? ((url) => new WebSocket(url));
+    let reconnectTimer = null;
+    let stopPromise = null;
     const executionJournal = opts.execution?.journal ?? createExecutionJournal(config.agentsRoot);
     const executionTelemetry = createExecutionTelemetryJournal(config.agentsRoot);
     const executeProtocol = opts.execution?.runExecution ?? runExecution;
     let detectedExecutionRuntimes = [];
     let runtimeFacts = null;
-    const executionReady = executionJournal.reconcileAfterRestart().then(() => true, (error) => {
-        dslog("execution.recovery_failed", "execution journal 恢复失败", {
-            level: "ERROR", error_message: error.message,
-        });
-        return false;
-    });
-    const sharedActive = new Map();
-    const sharedQueues = new Map();
+    const sharedSlots = createSharedSlotManager(config.executionLimits);
     const knownExecutionHashes = new Map();
     const executionReservations = new Map();
     const executionRuns = new Map();
     let executionFrameQueue = Promise.resolve();
     const cancellations = new Map();
+    const legacyRuns = new Map();
     const safeExecutionSend = (frame) => {
         try {
             if (ws?.readyState === WebSocket.OPEN)
@@ -124,114 +128,19 @@ export function serve(config, opts = {}) {
         }
     };
     const cancellationFor = (executionId) => {
-        const startStop = (state) => {
-            if (!state.requested || state.cancel === null)
-                return Promise.resolve();
-            state.stopPromise ??= Promise.resolve().then(state.cancel);
-            return state.stopPromise;
-        };
         const existing = cancellations.get(executionId);
-        if (existing !== undefined) {
-            return {
-                isRequested: () => existing.requested,
-                requested: existing.promise,
-                register: (cancel) => {
-                    existing.cancel = cancel;
-                    void startStop(existing).catch(() => { });
-                },
-                waitForStop: () => startStop(existing),
-            };
-        }
-        let resolve;
-        const promise = new Promise((done) => { resolve = done; });
-        const state = {
-            requested: false, resolve, promise,
-            cancel: null,
-            stopPromise: null,
-        };
-        cancellations.set(executionId, state);
-        return {
-            isRequested: () => state.requested,
-            requested: promise,
-            register: (cancel) => {
-                state.cancel = cancel;
-                void startStop(state).catch(() => { });
-            },
-            waitForStop: () => startStop(state),
-        };
+        if (existing !== undefined)
+            return existing.cancellation;
+        const controller = createRuntimeCancellation();
+        cancellations.set(executionId, controller);
+        return controller.cancellation;
     };
     const requestCancellation = (executionId) => {
         cancellationFor(executionId);
-        const state = cancellations.get(executionId);
-        if (state.requested)
-            return;
-        state.requested = true;
-        state.resolve();
+        cancellations.get(executionId).request();
         const reservation = executionReservations.get(executionId);
-        if (reservation?.isQueued()) {
+        if (reservation?.isQueued())
             reservation.release();
-        }
-        if (state.cancel !== null && state.stopPromise === null) {
-            state.stopPromise = Promise.resolve().then(state.cancel);
-            void state.stopPromise.catch(() => { });
-        }
-    };
-    const promoteNext = (handle) => {
-        const queue = sharedQueues.get(handle) ?? [];
-        while ((sharedActive.get(handle) ?? 0) < config.executionLimits.maxParallelPerAgent && queue.length > 0) {
-            const next = queue.shift();
-            if (next.released)
-                continue;
-            next.promoted = true;
-            sharedActive.set(handle, (sharedActive.get(handle) ?? 0) + 1);
-            next.resolve();
-        }
-        if (queue.length === 0)
-            sharedQueues.delete(handle);
-    };
-    const reserveSharedSlot = (handle, kind) => {
-        const active = sharedActive.get(handle) ?? 0;
-        const queued = sharedQueues.get(handle)?.length ?? 0;
-        const facts = { activeForAgent: active, queuedForAgent: queued };
-        if (kind === "execution" && active >= config.executionLimits.maxParallelPerAgent
-            && queued >= config.executionLimits.maxQueuedPerAgent) {
-            return { facts, ready: Promise.resolve(), isQueued: () => false, release: () => { } };
-        }
-        let resolve;
-        const ready = new Promise((done) => { resolve = done; });
-        const entry = { kind, released: false, promoted: active < config.executionLimits.maxParallelPerAgent, resolve };
-        if (entry.promoted) {
-            sharedActive.set(handle, active + 1);
-            resolve();
-        }
-        else {
-            const queue = sharedQueues.get(handle) ?? [];
-            queue.push(entry);
-            sharedQueues.set(handle, queue);
-        }
-        return {
-            facts,
-            state: entry.promoted ? "ready" : "queued",
-            ready,
-            isQueued: () => !entry.promoted && !entry.released,
-            release: () => {
-                if (entry.released)
-                    return;
-                entry.released = true;
-                if (entry.promoted) {
-                    sharedActive.set(handle, Math.max(0, (sharedActive.get(handle) ?? 1) - 1));
-                }
-                else {
-                    const queue = sharedQueues.get(handle);
-                    const index = queue?.indexOf(entry) ?? -1;
-                    if (queue !== undefined && index >= 0)
-                        queue.splice(index, 1);
-                    if (queue?.length === 0)
-                        sharedQueues.delete(handle);
-                }
-                promoteNext(handle);
-            },
-        };
     };
     let connectedAt = 0; // 本次 WS 连接建立时刻(断开日志算在线时长用)
     initSlog(config.serverUrl, config.machineToken);
@@ -241,18 +150,11 @@ export function serve(config, opts = {}) {
     // 每 agent 超过并行上限的任务继续进入 sharedQueues(不丢)。
     const running = new Set();
     const legacyTaskTails = new Map();
-    const acquireSlot = async (handle) => {
-        await reserveSharedSlot(handle, "legacy").ready;
-    };
-    const releaseSlot = (handle) => {
-        sharedActive.set(handle, Math.max(0, (sharedActive.get(handle) ?? 1) - 1));
-        promoteNext(handle);
-    };
     const log = (s) => process.stdout.write(formatDaemonLogLine(s) + "\n");
     function connect() {
         if (stopped)
             return;
-        ws = new WebSocket(wsUrl);
+        ws = createWebSocket(wsUrl);
         ws.on("open", () => {
             backoff = 1000;
             connectedAt = Date.now();
@@ -279,7 +181,7 @@ export function serve(config, opts = {}) {
             })
                 .catch(() => { });
             opts.onOpen?.(ws);
-            void executionReady.then((ready) => ready ? sendSnapshot(`reconnect-${randomUUID()}`) : undefined);
+            void sendSnapshot(`reconnect-${randomUUID()}`);
             void replayExecutionTelemetry().catch((error) => {
                 dslog("execution.telemetry_replay_failed", "execution telemetry 重放失败", {
                     level: "ERROR", error_message: error.message,
@@ -287,6 +189,8 @@ export function serve(config, opts = {}) {
             });
         });
         ws.on("message", async (data) => {
+            if (stopped)
+                return;
             let decoded;
             try {
                 decoded = JSON.parse(data.toString());
@@ -316,7 +220,8 @@ export function serve(config, opts = {}) {
                 }
                 const frame = parsedExecution.data;
                 executionFrameQueue = executionFrameQueue.then(async () => {
-                    const recovered = await executionReady;
+                    if (stopped)
+                        return;
                     if (frame.type === "execution:completion-ack") {
                         await executionJournal.acknowledgeCompletion(frame.executionId).catch(() => { });
                         return;
@@ -343,14 +248,6 @@ export function serve(config, opts = {}) {
                         return;
                     }
                     const spec = frame;
-                    if (!recovered) {
-                        safeExecutionSend(ExecutionRejectedSchema.parse({
-                            type: "execution:rejected", protocolVersion: 1, executionId: spec.executionId,
-                            reason: "resource_limit", message: "Local execution journal recovery failed",
-                            at: new Date().toISOString(),
-                        }));
-                        return;
-                    }
                     const hash = hashExecutionSpec(spec);
                     const knownHash = knownExecutionHashes.get(spec.executionId);
                     if (knownHash !== undefined) {
@@ -370,6 +267,8 @@ export function serve(config, opts = {}) {
                         return;
                     }
                     const durableExisting = await executionJournal.get(spec.executionId);
+                    if (stopped)
+                        return;
                     if (durableExisting !== null) {
                         if (durableExisting.specHash !== hash) {
                             safeExecutionSend(ExecutionRejectedSchema.parse({
@@ -384,19 +283,22 @@ export function serve(config, opts = {}) {
                         return;
                     }
                     knownExecutionHashes.set(spec.executionId, hash);
-                    const reservation = reserveSharedSlot(spec.agent.handle, "execution");
+                    const reservation = sharedSlots.reserve(spec.agent.handle, "execution");
                     executionReservations.set(spec.executionId, reservation);
                     const cancellation = cancellationFor(spec.executionId);
+                    const cleanupExecutionReservation = () => {
+                        reservation.release();
+                        cancellations.delete(spec.executionId);
+                        executionReservations.delete(spec.executionId);
+                        knownExecutionHashes.delete(spec.executionId);
+                    };
                     let availableRuntimes;
                     try {
                         availableRuntimes = opts.execution?.availableRuntimes?.()
                             ?? await (runtimeFacts ?? Promise.resolve(detectedExecutionRuntimes));
                     }
                     catch (error) {
-                        reservation.release();
-                        cancellations.delete(spec.executionId);
-                        executionReservations.delete(spec.executionId);
-                        knownExecutionHashes.delete(spec.executionId);
+                        cleanupExecutionReservation();
                         safeExecutionSend(ExecutionRejectedSchema.parse({
                             type: "execution:rejected", protocolVersion: 1, executionId: spec.executionId,
                             reason: "resource_limit", message: `Runtime detection failed: ${error.message}`,
@@ -404,6 +306,10 @@ export function serve(config, opts = {}) {
                         }));
                         return;
                     }
+                    if (stopped) {
+                        cleanupExecutionReservation();
+                        return;
+                    }
                     const execution = executeProtocol(config, spec, {
                         ...opts.execution?.dependencies,
                         journal: executionJournal,
@@ -417,11 +323,8 @@ export function serve(config, opts = {}) {
                         }),
                         cancellation,
                     }).finally(() => {
-                        reservation.release();
-                        cancellations.delete(spec.executionId);
-                        executionReservations.delete(spec.executionId);
+                        cleanupExecutionReservation();
                         executionRuns.delete(spec.executionId);
-                        knownExecutionHashes.delete(spec.executionId);
                     });
                     executionRuns.set(spec.executionId, execution);
                     void execution.catch(() => { });
@@ -556,75 +459,88 @@ export function serve(config, opts = {}) {
                 return;
             }
             const queueWaitStart = Date.now();
+            const runStartedAt = Date.now();
+            const controller = createRuntimeCancellation();
+            let finishLegacyRun;
+            let failLegacyRun;
+            const legacyDone = new Promise((resolveDone, rejectDone) => {
+                finishLegacyRun = resolveDone;
+                failLegacyRun = rejectDone;
+            });
+            void legacyDone.catch(() => undefined);
+            legacyRuns.set(runId, { controller, done: legacyDone });
+            let legacyStopError;
+            let legacyReservation = null;
             let legacyQueueDone = null;
             let finishLegacyQueue = () => { };
-            if (!scheduled) {
-                const previous = legacyTaskTails.get(key);
-                legacyQueueDone = new Promise((resolve) => { finishLegacyQueue = resolve; });
-                legacyTaskTails.set(key, legacyQueueDone);
-                if (previous) {
-                    log(`⏳ 排队(该任务已在运行): ${key}`);
-                    dslog("run.wake_queued", "唤醒已排队:该任务正在运行", { ...runKeys });
-                    await previous;
-                }
-            }
-            running.add(key);
-            // 并行槽:同 agent 超过配置上限的任务在此排队(不丢),有空位再跑。
-            await acquireSlot(msg.agentHandle);
-            const queueMs = Date.now() - queueWaitStart;
-            const threadLabel = threadId ?? null;
-            const from = msg.wake?.senderHandle ?? "?";
-            const incoming = msg.wake?.content ?? "";
-            dslog("run.start", `开始运行 ${msg.agentHandle}`, { ...runKeys, queue_ms: queueMs });
-            const runStartedAt = Date.now();
-            log(`\n${"─".repeat(56)}`);
-            log(`🔔 唤醒 agent=${msg.agentHandle}  reason=${msg.reason ?? "?"}`);
-            log(`   channel = ${msg.channelId}`);
-            log(`   thread  = ${threadLabel ? `${threadLabel} (要求线程内回复)` : "(无,顶层回复)"}`);
-            if (incoming)
-                log(`📥 来信 @${from}: ${incoming.replace(/\s+/g, " ").slice(0, 200)}`);
-            let actSeq = 0;
-            const reportActivity = (a) => {
-                const det = a.detail ? a.detail.replace(/\s+/g, " ").trim() : "";
-                // 发消息时尽量打印回复正文/目标(--content "..." 或 heredoc 首行)
-                let line = `  · ${a.label}`;
-                if (a.kind === "sending") {
-                    const m = det.match(/--content\s+"([^"]*)"/) || det.match(/<<'?\w+'?\s*(.*)/);
-                    line = `  💬 回复${threadLabel ? `(thread ${threadLabel})` : ""}: ${m ? m[1].slice(0, 160) : det.slice(0, 120)}`;
-                }
-                else if (det) {
-                    line += ` ${det.slice(0, 80)}`;
-                }
-                log(line);
-                try {
-                    ws?.send(JSON.stringify({
-                        type: "agent:activity",
-                        agentHandle: msg.agentHandle,
-                        channelId: msg.channelId,
-                        activity: ACTIVITY_MAP[a.kind] ?? "working",
-                        detail: a.detail || a.label,
-                        seq: actSeq++,
-                    }));
-                }
-                catch { /* ws 非 OPEN,忽略 */ }
-            };
-            // 终端透传:把底层 claude 的每条 console 行按线程上送给 server(独立 seq,落库+广播给 web 终端窗口)。
-            let conSeq = 0;
-            const reportConsole = (c) => {
-                try {
-                    ws?.send(JSON.stringify({
-                        type: "agent:console",
-                        agentHandle: msg.agentHandle,
-                        channelId: msg.channelId,
-                        threadId: threadId ?? null,
-                        stream: c.stream,
-                        text: c.text,
-                        seq: conSeq++,
-                    }));
-                }
-                catch { /* ws 非 OPEN,忽略 */ }
-            };
             try {
+                if (!scheduled) {
+                    const previous = legacyTaskTails.get(key);
+                    legacyQueueDone = new Promise((resolve) => { finishLegacyQueue = resolve; });
+                    legacyTaskTails.set(key, legacyQueueDone);
+                    if (previous) {
+                        log(`⏳ 排队(该任务已在运行): ${key}`);
+                        dslog("run.wake_queued", "唤醒已排队:该任务正在运行", { ...runKeys });
+                        await awaitWithCancellation(previous, controller.cancellation);
+                    }
+                }
+                running.add(key);
+                legacyReservation = sharedSlots.reserve(msg.agentHandle, "legacy");
+                await awaitWithCancellation(legacyReservation.ready, controller.cancellation);
+                const queueMs = Date.now() - queueWaitStart;
+                const threadLabel = threadId ?? null;
+                const from = msg.wake?.senderHandle ?? "?";
+                const incoming = msg.wake?.content ?? "";
+                dslog("run.start", `开始运行 ${msg.agentHandle}`, { ...runKeys, queue_ms: queueMs });
+                log(`\n${"─".repeat(56)}`);
+                log(`🔔 唤醒 agent=${msg.agentHandle}  reason=${msg.reason ?? "?"}`);
+                log(`   channel = ${msg.channelId}`);
+                log(`   thread  = ${threadLabel ? `${threadLabel} (要求线程内回复)` : "(无,顶层回复)"}`);
+                if (incoming)
+                    log(`📥 来信 @${from}: ${incoming.replace(/\s+/g, " ").slice(0, 200)}`);
+                let actSeq = 0;
+                const reportActivity = (a) => {
+                    const det = a.detail ? a.detail.replace(/\s+/g, " ").trim() : "";
+                    // 发消息时尽量打印回复正文/目标(--content "..." 或 heredoc 首行)
+                    let line = `  · ${a.label}`;
+                    if (a.kind === "sending") {
+                        const m = det.match(/--content\s+"([^"]*)"/) || det.match(/<<'?\w+'?\s*(.*)/);
+                        line = `  💬 回复${threadLabel ? `(thread ${threadLabel})` : ""}: ${m ? m[1].slice(0, 160) : det.slice(0, 120)}`;
+                    }
+                    else if (det) {
+                        line += ` ${det.slice(0, 80)}`;
+                    }
+                    log(line);
+                    try {
+                        ws?.send(JSON.stringify({
+                            type: "agent:activity",
+                            agentHandle: msg.agentHandle,
+                            channelId: msg.channelId,
+                            activity: ACTIVITY_MAP[a.kind] ?? "working",
+                            detail: a.detail || a.label,
+                            seq: actSeq++,
+                        }));
+                    }
+                    catch { /* ws 非 OPEN,忽略 */ }
+                };
+                // 终端透传:把底层 claude 的每条 console 行按线程上送给 server(独立 seq,落库+广播给 web 终端窗口)。
+                let conSeq = 0;
+                const reportConsole = (c) => {
+                    try {
+                        ws?.send(JSON.stringify({
+                            type: "agent:console",
+                            agentHandle: msg.agentHandle,
+                            channelId: msg.channelId,
+                            threadId: threadId ?? null,
+                            stream: c.stream,
+                            text: c.text,
+                            // 结构化负载(diff/命令/todo…):前端富渲染用;缺省 = 纯文本行
+                            ...(c.payload !== undefined ? { payload: c.payload } : {}),
+                            seq: conSeq++,
+                        }));
+                    }
+                    catch { /* ws 非 OPEN,忽略 */ }
+                };
                 // 线程聚合:触发消息即任务线程根,你的确认+后续所有回复都要发到它的线程里,
                 // 不要发顶层——这样 task 讨论全部聚合在该 thread 下。
                 const threadHint = threadId
@@ -681,7 +597,7 @@ export function serve(config, opts = {}) {
                         ...(!scheduled && threadId ? { wakeMessageId: threadId } : {}),
                         ...(!scheduled && msg.wake?.seq !== undefined ? { wakeContextUpToSeq: msg.wake.seq } : {}),
                         ...(attemptWake ? { wake: attemptWake } : {}),
-                    }, reportActivity, reportConsole);
+                    }, reportActivity, reportConsole, { cancellation: controller.cancellation });
                 });
                 const result = mergeRunAgentResults(guarded.results);
                 // 本轮 token 用量上报:runner 已从 result 事件提取(含缓存读/写细分),
@@ -762,6 +678,9 @@ export function serve(config, opts = {}) {
                 }
             }
             catch (e) {
+                if (controller.cancellation.isRequested() && !(e instanceof RuntimeCancelledError)) {
+                    legacyStopError = e;
+                }
                 log(`❌ runAgent 失败: ${e.message}`);
                 dslog("run.error", `runAgent 失败: ${e.message}`, {
                     level: "ERROR", ...runKeys, duration_ms: Date.now() - runStartedAt,
@@ -796,11 +715,16 @@ export function serve(config, opts = {}) {
             }
             finally {
                 running.delete(key);
-                releaseSlot(msg.agentHandle);
+                legacyReservation?.release();
                 finishLegacyQueue();
                 if (legacyQueueDone && legacyTaskTails.get(key) === legacyQueueDone) {
                     legacyTaskTails.delete(key);
                 }
+                legacyRuns.delete(runId);
+                if (legacyStopError === undefined)
+                    finishLegacyRun();
+                else
+                    failLegacyRun(legacyStopError);
                 void flushSlog(); // 每轮收尾冲一次,保证 run.end 尽快可查
             }
         });
@@ -823,22 +747,67 @@ export function serve(config, opts = {}) {
                 running_tasks: [...running].join(","),
             });
             void flushSlog();
-            setTimeout(connect, backoff);
+            reconnectTimer = setTimeout(() => {
+                reconnectTimer = null;
+                connect();
+            }, backoff);
             backoff = Math.min(backoff * 2, maxBackoff);
         });
-        ws.on("error", () => ws?.close());
+        ws.on("error", () => {
+            if (!stopped)
+                ws?.close();
+        });
     }
-    connect();
-    return {
-        stop: () => {
+    const ready = (async () => {
+        await reconcileExecutionJournal(executionJournal, {
+            agentsRoot: config.agentsRoot,
+            serverUrl: config.serverUrl,
+            ...(opts.profileName === undefined ? {} : { profileName: opts.profileName }),
+            log: dslog,
+            flush: flushSlog,
+            writeStderr: (line) => process.stderr.write(line),
+        });
+        connect();
+    })();
+    const stop = () => {
+        if (stopPromise !== null)
+            return stopPromise;
+        stopPromise = (async () => {
             stopped = true;
-            ws?.close();
-            for (const executionId of executionRuns.keys())
-                requestCancellation(executionId);
-            void Promise.race([
-                Promise.allSettled([...executionRuns.values()]).then(() => true),
-                new Promise((resolve) => setTimeout(() => resolve(false), 10_000)),
-            ]).then((settled) => settled ? executionJournal.close() : undefined);
-        },
+            const deadline = createShutdownDeadline(shutdownTimeoutMs);
+            if (reconnectTimer !== null) {
+                clearTimeout(reconnectTimer);
+                reconnectTimer = null;
+            }
+            const webSocketClosed = closeWebSocketWithinDeadline(ws, deadline.signal);
+            const pending = [
+                webSocketClosed,
+                executionFrameQueue,
+                ...executionRuns.values(),
+                ...[...legacyRuns.values()].map((run) => run.done),
+                ...(testShutdown.barrier === null ? [] : [testShutdown.barrier]),
+            ];
+            try {
+                for (const executionId of executionRuns.keys())
+                    requestCancellation(executionId);
+                for (const run of legacyRuns.values())
+                    run.controller.request();
+                await deadline.waitFor(Promise.all(pending));
+                await executionJournal.close({ signal: deadline.signal });
+            }
+            finally {
+                deadline.dispose();
+            }
+        })();
+        return stopPromise;
+    };
+    return {
+        ready,
+        stop,
+        shutdownSnapshot: () => ({
+            activeExecutionCount: executionRuns.size,
+            activeLegacyCount: legacyRuns.size,
+            deadlineMs: shutdownTimeoutMs,
+        }),
     };
 }

package/dist/shared-execution-slots.js

@@ -0,0 +1,68 @@
+export function createSharedSlotManager(limits) {
+    const activeByHandle = new Map();
+    const queuesByHandle = new Map();
+    const promoteNext = (handle) => {
+        const queue = queuesByHandle.get(handle) ?? [];
+        while ((activeByHandle.get(handle) ?? 0) < limits.maxParallelPerAgent && queue.length > 0) {
+            const next = queue.shift();
+            if (next.released)
+                continue;
+            next.promoted = true;
+            activeByHandle.set(handle, (activeByHandle.get(handle) ?? 0) + 1);
+            next.resolve();
+        }
+        if (queue.length === 0)
+            queuesByHandle.delete(handle);
+    };
+    return {
+        reserve: (handle, kind) => {
+            const active = activeByHandle.get(handle) ?? 0;
+            const queued = queuesByHandle.get(handle)?.length ?? 0;
+            const facts = { activeForAgent: active, queuedForAgent: queued };
+            if (kind === "execution" && active >= limits.maxParallelPerAgent
+                && queued >= limits.maxQueuedPerAgent) {
+                return { facts, ready: Promise.resolve(), isQueued: () => false, release: () => { } };
+            }
+            let resolveReady;
+            const ready = new Promise((resolve) => { resolveReady = resolve; });
+            const entry = {
+                kind,
+                released: false,
+                promoted: active < limits.maxParallelPerAgent,
+                resolve: resolveReady,
+            };
+            if (entry.promoted) {
+                activeByHandle.set(handle, active + 1);
+                resolveReady();
+            }
+            else {
+                const queue = queuesByHandle.get(handle) ?? [];
+                queue.push(entry);
+                queuesByHandle.set(handle, queue);
+            }
+            return {
+                facts,
+                state: entry.promoted ? "ready" : "queued",
+                ready,
+                isQueued: () => !entry.promoted && !entry.released,
+                release: () => {
+                    if (entry.released)
+                        return;
+                    entry.released = true;
+                    if (entry.promoted) {
+                        activeByHandle.set(handle, Math.max(0, (activeByHandle.get(handle) ?? 1) - 1));
+                    }
+                    else {
+                        const queue = queuesByHandle.get(handle);
+                        const index = queue?.indexOf(entry) ?? -1;
+                        if (queue !== undefined && index >= 0)
+                            queue.splice(index, 1);
+                        if (queue?.length === 0)
+                            queuesByHandle.delete(handle);
+                    }
+                    promoteNext(handle);
+                },
+            };
+        },
+    };
+}

package/dist/shutdown-deadline.js

@@ -0,0 +1,32 @@
+export function readTestShutdownConfiguration(env) {
+    if (env.NODE_ENV !== "test")
+        return { barrier: null };
+    const timeoutMs = env.CREW_DAEMON_TEST_SHUTDOWN_TIMEOUT_MS === undefined
+        ? undefined
+        : Number(env.CREW_DAEMON_TEST_SHUTDOWN_TIMEOUT_MS);
+    if (timeoutMs !== undefined && (!Number.isFinite(timeoutMs) || timeoutMs <= 0)) {
+        throw new RangeError("CREW_DAEMON_TEST_SHUTDOWN_TIMEOUT_MS must be a positive number");
+    }
+    return {
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        barrier: env.CREW_DAEMON_TEST_SHUTDOWN_BARRIER === "1" ? new Promise(() => { }) : null,
+    };
+}
+export function createShutdownDeadline(timeoutMs) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        throw new RangeError("shutdown timeout must be a positive finite number");
+    }
+    const controller = new AbortController();
+    const timeoutError = new Error(`Timed out waiting for daemon shutdown after ${timeoutMs}ms`);
+    let rejectExpired;
+    const expired = new Promise((_resolve, reject) => { rejectExpired = reject; });
+    const timer = setTimeout(() => {
+        controller.abort(timeoutError);
+        rejectExpired(timeoutError);
+    }, timeoutMs);
+    return {
+        signal: controller.signal,
+        waitFor: async (operation) => Promise.race([operation, expired]),
+        dispose: () => clearTimeout(timer),
+    };
+}