@nowcrew/daemon 0.6.29 → 0.6.31

package/dist/serve.js

@@ -80,7 +80,11 @@ export function serve(config, opts = {}) {
     let runtimeFacts = null;
     const runtimeProbe = createRuntimeProbeCoordinator();
     const hostCoordinator = opts.execution?.hostCoordinator
-        ?? createHostExecutionCoordinator({ executionSlots: config.executionLimits.maxParallelTotal });
+        ?? createHostExecutionCoordinator({
+            executionSlots: config.executionLimits.maxParallelTotal,
+            startupSlots: config.executionLimits.maxStartingTotal,
+            startupGapMs: config.executionLimits.startupGapMs,
+        });
     const localSlots = createSharedSlotManager(config.executionLimits);
     const sharedSlots = hostCoordinatedSlotManager(localSlots, hostCoordinator);
     const runtimeStartupGate = hostCoordinatedStartupGate(createRuntimeStartupGate(config.executionLimits), hostCoordinator);
@@ -502,7 +506,9 @@ export function serve(config, opts = {}) {
                             task_key: spec.workspace.taskKey,
                         });
                     }
-                    const executionClass = spec.context.scheduledRunId === undefined ? "normal" : "scheduled";
+                    const executionClass = pruneTraceId !== null
+                        ? "memory_prune"
+                        : spec.context.scheduledRunId === undefined ? "normal" : "scheduled";
                     const reservation = sharedSlots.reserve(spec.agent.handle, "execution", executionClass);
                     if (!reservation.accepted) {
                         dslog("execution.machine_queue_rejected", "机器执行队列已满", {
@@ -604,19 +610,49 @@ export function serve(config, opts = {}) {
                         report: reportExecutionFrame,
                         startupGate: runtimeStartupGate,
                         startupTimeoutMs: config.executionLimits.startupTimeoutMs,
+                        onRuntimePhase: (phase) => {
+                            if (phase === "starting")
+                                reservation.markStarting();
+                            else
+                                reservation.markRunning();
+                            const snapshot = sharedSlots.snapshot();
+                            dslog(`execution.runtime_${phase}`, `execution runtime ${phase}`, {
+                                execution_id: spec.executionId,
+                                agent_handle: spec.agent.handle,
+                                execution_class: executionClass,
+                                admitted_total: snapshot.admittedTotal,
+                                preparing_total: snapshot.preparingTotal,
+                                starting_total: snapshot.startingTotal,
+                                running_total: snapshot.runningTotal,
+                                queued_total: snapshot.queuedTotal,
+                                memory_prune_preparing_total: snapshot.memoryPrunePreparingTotal,
+                                memory_prune_starting_total: snapshot.memoryPruneStartingTotal,
+                                memory_prune_running_total: snapshot.memoryPruneRunningTotal,
+                            });
+                        },
                         ...(reservation.state === undefined ? {} : {
                             slot: {
                                 state: reservation.state,
                                 ready: reservation.ready.then(() => {
                                     markExecutionTaskKeyActive();
+                                    reservation.markPreparing();
                                     const snapshot = sharedSlots.snapshot();
                                     dslog("execution.machine_slot_ready", "execution 获得机器执行名额", {
                                         execution_id: spec.executionId,
                                         agent_handle: spec.agent.handle,
                                         execution_class: executionClass,
                                         queue_ms: Date.now() - machineQueueEnteredAt,
-                                        active_total: snapshot.activeTotal,
+                                        active_total: snapshot.runningTotal,
+                                        admitted_total: snapshot.admittedTotal,
+                                        preparing_total: snapshot.preparingTotal,
+                                        starting_total: snapshot.startingTotal,
+                                        running_total: snapshot.runningTotal,
                                         queued_total: snapshot.queuedTotal,
+                                        memory_prune_admitted_total: snapshot.memoryPruneAdmittedTotal,
+                                        memory_prune_queued_total: snapshot.memoryPruneQueuedTotal,
+                                        memory_prune_preparing_total: snapshot.memoryPrunePreparingTotal,
+                                        memory_prune_starting_total: snapshot.memoryPruneStartingTotal,
+                                        memory_prune_running_total: snapshot.memoryPruneRunningTotal,
                                     });
                                 }),
                             },
@@ -846,6 +882,7 @@ export function serve(config, opts = {}) {
                     });
                 }
                 await awaitWithCancellation(legacyReservation.ready, controller.cancellation);
+                legacyReservation.markPreparing();
                 const queueMs = Date.now() - queueWaitStart;
                 const machineSnapshot = sharedSlots.snapshot();
                 const threadLabel = threadId ?? null;
@@ -967,6 +1004,21 @@ export function serve(config, opts = {}) {
                         cancellation: controller.cancellation,
                         startupGate: runtimeStartupGate,
                         startupTimeoutMs: config.executionLimits.startupTimeoutMs,
+                        onRuntimePhase: (phase) => {
+                            if (phase === "starting")
+                                legacyReservation?.markStarting();
+                            else
+                                legacyReservation?.markRunning();
+                            const snapshot = sharedSlots.snapshot();
+                            dslog(`run.runtime_${phase}`, `legacy runtime ${phase}`, {
+                                ...runKeys,
+                                admitted_total: snapshot.admittedTotal,
+                                preparing_total: snapshot.preparingTotal,
+                                starting_total: snapshot.startingTotal,
+                                running_total: snapshot.runningTotal,
+                                queued_total: snapshot.queuedTotal,
+                            });
+                        },
                     });
                 });
                 const result = mergeRunAgentResults(guarded.results);

package/dist/shared-execution-slots.js

@@ -1,25 +1,44 @@
 export function createSharedSlotManager(limits) {
     const activeByHandleAndClass = new Map();
     const queue = [];
+    const entries = new Set();
     let activeTotal = 0;
+    let activeMemoryPruneTotal = 0;
     let exclusive = false;
-    const queuedFor = (handle) => queue.filter((entry) => !entry.released && entry.handle === handle).length;
+    const queuedFor = (handle, executionClass) => queue.filter((entry) => !entry.released
+        && entry.handle === handle
+        && (entry.executionClass === "memory_prune") === (executionClass === "memory_prune")).length;
     const activeKey = (handle, executionClass) => `${handle}:${executionClass}`;
     const maxParallelFor = (executionClass) => executionClass === "scheduled"
         ? limits.maxParallelScheduledPerAgent
-        : limits.maxParallelPerAgent;
+        : executionClass === "memory_prune"
+            ? 1
+            : limits.maxParallelPerAgent;
     const promote = () => {
-        while (activeTotal < limits.maxParallelTotal) {
-            const index = queue.findIndex((entry) => !entry.released
-                && (activeByHandleAndClass.get(activeKey(entry.handle, entry.executionClass)) ?? 0)
-                    < maxParallelFor(entry.executionClass));
+        while (true) {
+            const foregroundIndex = activeTotal < limits.maxParallelTotal
+                ? queue.findIndex((entry) => !entry.released
+                    && entry.executionClass !== "memory_prune"
+                    && (activeByHandleAndClass.get(activeKey(entry.handle, entry.executionClass)) ?? 0)
+                        < maxParallelFor(entry.executionClass))
+                : -1;
+            const memoryPruneIndex = activeMemoryPruneTotal < 1
+                ? queue.findIndex((entry) => !entry.released
+                    && entry.executionClass === "memory_prune"
+                    && (activeByHandleAndClass.get(activeKey(entry.handle, entry.executionClass)) ?? 0) < 1)
+                : -1;
+            const index = foregroundIndex >= 0 ? foregroundIndex : memoryPruneIndex;
             if (index < 0)
                 return;
             const [next] = queue.splice(index, 1);
             if (!next || next.released)
                 continue;
             next.promoted = true;
-            activeTotal += 1;
+            next.phase = "admitted";
+            if (next.executionClass === "memory_prune")
+                activeMemoryPruneTotal += 1;
+            else
+                activeTotal += 1;
             const key = activeKey(next.handle, next.executionClass);
             activeByHandleAndClass.set(key, (activeByHandleAndClass.get(key) ?? 0) + 1);
             next.resolve();
@@ -29,12 +48,13 @@ export function createSharedSlotManager(limits) {
         reserve: (handle, kind, executionClass = "normal") => {
             const key = activeKey(handle, executionClass);
             const activeForAgent = activeByHandleAndClass.get(key) ?? 0;
-            const queuedForAgent = queuedFor(handle);
+            const queuedForAgent = queuedFor(handle, executionClass);
+            const laneQueuedTotal = queue.filter((entry) => (entry.executionClass === "memory_prune") === (executionClass === "memory_prune")).length;
             const facts = {
                 activeForAgent,
                 queuedForAgent,
-                activeTotal,
-                queuedTotal: queue.length,
+                activeTotal: executionClass === "memory_prune" ? activeMemoryPruneTotal : activeTotal,
+                queuedTotal: laneQueuedTotal,
             };
             if (exclusive) {
                 return {
@@ -42,19 +62,27 @@ export function createSharedSlotManager(limits) {
                     facts,
                     ready: Promise.resolve(),
                     isQueued: () => false,
+                    markPreparing: () => { },
+                    markStarting: () => { },
+                    markRunning: () => { },
                     release: () => { },
                 };
             }
-            const canStartImmediately = activeTotal < limits.maxParallelTotal
+            const canStartImmediately = (executionClass === "memory_prune"
+                ? activeMemoryPruneTotal < 1
+                : activeTotal < limits.maxParallelTotal)
                 && activeForAgent < maxParallelFor(executionClass)
-                && queue.length === 0;
+                && laneQueuedTotal === 0;
             if (kind === "execution" && !canStartImmediately && (queuedForAgent >= limits.maxQueuedPerAgent
-                || queue.length >= limits.maxQueuedTotal)) {
+                || laneQueuedTotal >= limits.maxQueuedTotal)) {
                 return {
                     accepted: false,
                     facts,
                     ready: Promise.resolve(),
                     isQueued: () => false,
+                    markPreparing: () => { },
+                    markStarting: () => { },
+                    markRunning: () => { },
                     release: () => { },
                 };
             }
@@ -65,22 +93,36 @@ export function createSharedSlotManager(limits) {
                 executionClass,
                 released: false,
                 promoted: false,
+                phase: "queued",
                 resolve: resolveReady,
             };
             queue.push(entry);
+            entries.add(entry);
             promote();
+            const markPhase = (phase) => {
+                if (!entry.released && entry.promoted)
+                    entry.phase = phase;
+            };
             return {
                 accepted: true,
                 facts,
                 state: entry.promoted ? "ready" : "queued",
                 ready,
                 isQueued: () => !entry.promoted && !entry.released,
+                markPreparing: () => markPhase("preparing"),
+                markStarting: () => markPhase("starting"),
+                markRunning: () => markPhase("running"),
                 release: () => {
                     if (entry.released)
                         return;
                     entry.released = true;
+                    entries.delete(entry);
                     if (entry.promoted) {
-                        activeTotal = Math.max(0, activeTotal - 1);
+                        if (entry.executionClass === "memory_prune") {
+                            activeMemoryPruneTotal = Math.max(0, activeMemoryPruneTotal - 1);
+                        }
+                        else
+                            activeTotal = Math.max(0, activeTotal - 1);
                         const nextForAgent = Math.max(0, (activeByHandleAndClass.get(key) ?? 1) - 1);
                         if (nextForAgent === 0)
                             activeByHandleAndClass.delete(key);
@@ -96,9 +138,26 @@ export function createSharedSlotManager(limits) {
                 },
             };
         },
-        snapshot: () => ({ activeTotal, queuedTotal: queue.length }),
+        snapshot: () => {
+            const foreground = [...entries].filter((entry) => entry.executionClass !== "memory_prune");
+            const memoryPrune = [...entries].filter((entry) => entry.executionClass === "memory_prune");
+            const runningTotal = foreground.filter((entry) => entry.phase === "running").length;
+            return {
+                activeTotal: runningTotal,
+                queuedTotal: foreground.filter((entry) => entry.phase === "queued").length,
+                admittedTotal: foreground.filter((entry) => entry.promoted).length,
+                preparingTotal: foreground.filter((entry) => entry.phase === "preparing" || entry.phase === "admitted").length,
+                startingTotal: foreground.filter((entry) => entry.phase === "starting").length,
+                runningTotal,
+                memoryPruneAdmittedTotal: memoryPrune.filter((entry) => entry.promoted).length,
+                memoryPruneQueuedTotal: memoryPrune.filter((entry) => entry.phase === "queued").length,
+                memoryPrunePreparingTotal: memoryPrune.filter((entry) => entry.phase === "preparing" || entry.phase === "admitted").length,
+                memoryPruneStartingTotal: memoryPrune.filter((entry) => entry.phase === "starting").length,
+                memoryPruneRunningTotal: memoryPrune.filter((entry) => entry.phase === "running").length,
+            };
+        },
         tryAcquireExclusive: () => {
-            if (exclusive || activeTotal !== 0 || queue.length !== 0)
+            if (exclusive || activeTotal !== 0 || activeMemoryPruneTotal !== 0 || queue.length !== 0)
                 return null;
             exclusive = true;
             let released = false;

package/package.json

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