@nowcrew/daemon 0.6.30 → 0.6.32

package/dist/agent-ability/materializer.js

@@ -8,7 +8,7 @@ import { abilityWorkspaceProjectionPath, DaemonAbilityLockSchema, DaemonAbilityM
 import { loadAgentAbilityRuntimeContext } from "./runtime-context.js";
 import { parseSkillFrontmatter } from "../skill-frontmatter.js";
 import { isProjectSkillName, MAX_PROJECT_SKILL_DESCRIPTION_LENGTH, MAX_PROJECT_SKILL_FILE_BYTES, } from "../project-skills/types.js";
-import { createAgentProjectionCoordinator, runtimeProjectionLifetime, } from "../project-skills/agent-projection-coordinator.js";
+import { createAgentProjectionCoordinator, } from "../project-skills/agent-projection-coordinator.js";
 const exists = (path) => lstat(path).then(() => true, () => false);
 const isRealDirectory = (path) => lstat(path)
     .then((info) => info.isDirectory() && !info.isSymbolicLink(), () => false);
@@ -135,7 +135,7 @@ const projectNativeSkills = async (agentRoot, trainingRoot, skills) => {
             const names = await copyExistingSkills(target, staging, managedRoots);
             for (const skill of nativeSkills) {
                 if (names.has(skill.name))
-                    throw new Error(`ability_skill_name_conflict:${skill.name}`);
+                    continue;
                 await symlink(skill.source, join(staging, skill.name), "dir");
             }
             await switchDirectory(target, staging, backup);
@@ -555,7 +555,7 @@ export function createAgentAbilityMaterializer(expectedAgentsRoot, coordinator =
         prepareAndLaunch(agentsRoot, handle, ability, launch) {
             if (agentsRoot !== expectedAgentsRoot)
                 return Promise.reject(new Error("ability_agents_root_mismatch"));
-            return coordinator.runExclusiveUntil(expectedAgentsRoot, handle, async () => {
+            return coordinator.runExclusive(expectedAgentsRoot, handle, async () => {
                 const started = Date.now();
                 try {
                     const trainingRoot = await ensureWorkspaceTraining(agentsRoot, handle, ability);
@@ -575,7 +575,7 @@ export function createAgentAbilityMaterializer(expectedAgentsRoot, coordinator =
                     });
                     throw error;
                 }
-            }, runtimeProjectionLifetime);
+            });
         },
     };
 }

package/dist/config.js

@@ -15,9 +15,9 @@ export const DEFAULT_EXECUTION_LIMITS = Object.freeze({
     maxQueuedPerAgent: 32,
     maxParallelTotal: 10,
     maxQueuedTotal: 128,
-    maxStartingTotal: 1,
-    maxStartingPerRuntime: 1,
-    startupGapMs: 3_000,
+    maxStartingTotal: 10,
+    maxStartingPerRuntime: 10,
+    startupGapMs: 500,
     startupTimeoutMs: 120_000,
 });
 // Fits the largest mandatory v1 lifecycle envelope (UUID + timestamps + outcome facts) with margin.

package/dist/execution-runner.js

@@ -497,22 +497,14 @@ export async function runExecution(config, input, dependencies) {
         let consoleSequence = 0;
         let externalOutputSequence = 0;
         const callbacks = {
-            onRuntimeReady: async () => {
+            onRuntimeStarting: () => {
+                dependencies.onRuntimePhase?.("starting");
+            },
+            onRuntimeRunning: async () => {
                 if (dependencies.cancellation?.isRequested())
                     return;
-                const ready = await dependencies.journal.markRuntimeReady(spec.executionId, now().toISOString());
-                if (ready.runtimeReadyAt === null) {
-                    throw new Error(`Execution ${spec.executionId} runtime readiness was not persisted`);
-                }
-                startedAt = ready.runtimeReadyAt;
-                await reportBestEffort(dependencies.report, boundExecutionFrame(DaemonToServerExecutionFrameSchema.parse({
-                    type: "execution:started",
-                    protocolVersion: 1,
-                    executionId: spec.executionId,
-                    at: startedAt,
-                }), config.executionLimits.maxEventBytes), bestEffortTimeoutMs);
                 const cancel = runtimeCancel;
-                if (cancel !== null && !dependencies.cancellation?.isRequested()) {
+                if (cancel !== null && timeout === undefined) {
                     timeout = setTimeout(() => {
                         timedOut = true;
                         try {
@@ -523,6 +515,18 @@ export async function runExecution(config, input, dependencies) {
                         }
                     }, effectiveTimeoutMs);
                 }
+                dependencies.onRuntimePhase?.("running");
+                const ready = await dependencies.journal.markRuntimeReady(spec.executionId, now().toISOString());
+                if (ready.runtimeReadyAt === null) {
+                    throw new Error(`Execution ${spec.executionId} runtime readiness was not persisted`);
+                }
+                startedAt = ready.runtimeReadyAt;
+                await reportBestEffort(dependencies.report, boundExecutionFrame(DaemonToServerExecutionFrameSchema.parse({
+                    type: "execution:started",
+                    protocolVersion: 1,
+                    executionId: spec.executionId,
+                    at: startedAt,
+                }), config.executionLimits.maxEventBytes), bestEffortTimeoutMs);
             },
             ...(spec.reporting.streamActivity ? {
                 onActivity: (activity) => {

package/dist/host-execution-coordinator.js

@@ -4,9 +4,12 @@ import { mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { defaultProcessController } from "./execution-journal.js";
 import { createJournalLease, createJournalLeaseRegistry, JournalLockedError, } from "./execution-journal-lock.js";
+import { dslog } from "./slog.js";
 const HOST_EXECUTION_SLOT_COUNT = 10;
-const HOST_STARTUP_GAP_MS = 3_000;
+const HOST_STARTUP_SLOT_COUNT = 10;
+const HOST_STARTUP_GAP_MS = 500;
 const RETRY_MS = 50;
+const RELEASE_RETRY_MAX_MS = 5_000;
 export function defaultHostExecutionCoordinatorRoot(userHome = homedir()) {
     // Deliberately independent of CREW_DAEMON_HOME and agentsRoot: every profile
     // owned by this OS user must share the same physical-compute safety boundary.
@@ -68,11 +71,12 @@ function reservation(prerequisite, acquire) {
         const lease = await acquire(() => released);
         if (lease === null)
             return null;
+        owned = lease;
         if (released) {
-            await lease.close();
+            // The release path owns cleanup so every close failure gets the same
+            // retry, diagnostics, and drain tracking as an already-granted slot.
             return null;
         }
-        owned = lease;
         granted = true;
         return lease;
     });
@@ -87,8 +91,23 @@ function reservation(prerequisite, acquire) {
                 return releasePromise;
             released = true;
             cancelPrerequisite();
-            releasePromise = acquisition.then(async () => { if (owned !== null)
-                await owned.close(); });
+            const closeOwned = async () => {
+                const lease = owned;
+                if (lease === null)
+                    return;
+                await lease.close();
+                if (owned === lease)
+                    owned = null;
+            };
+            releasePromise = acquisition.then(closeOwned, async () => {
+                // Acquisition errors are already exposed through ready. Release only
+                // owns cleanup; with no acquired lease there is nothing to retry.
+                if (owned !== null)
+                    await closeOwned();
+            }).catch((error) => {
+                releasePromise = null;
+                throw error;
+            });
             void releasePromise.catch(() => undefined);
             return releasePromise;
         },
@@ -107,90 +126,161 @@ async function writeLaunchTimestamp(path, value) {
 export function createHostExecutionCoordinator(options = {}) {
     const root = resolve(options.root ?? defaultHostExecutionCoordinatorRoot());
     const executionSlots = options.executionSlots ?? HOST_EXECUTION_SLOT_COUNT;
+    const startupSlots = options.startupSlots ?? HOST_STARTUP_SLOT_COUNT;
     const startupGapMs = options.startupGapMs ?? HOST_STARTUP_GAP_MS;
     const retryMs = options.retryMs ?? RETRY_MS;
     const now = options.now ?? Date.now;
     const wait = options.wait ?? ((milliseconds) => new Promise((resolveWait) => setTimeout(resolveWait, milliseconds)));
+    const acquireLease = options.acquireLease ?? leaseFor;
     const pendingReleases = new Set();
     if (!Number.isSafeInteger(executionSlots) || executionSlots <= 0) {
         throw new RangeError("executionSlots must be a positive safe integer");
     }
+    if (!Number.isSafeInteger(startupSlots) || startupSlots <= 0) {
+        throw new RangeError("startupSlots must be a positive safe integer");
+    }
     if (!Number.isFinite(startupGapMs) || startupGapMs < 0) {
         throw new RangeError("startupGapMs must be a nonnegative finite number");
     }
     if (!Number.isFinite(retryMs) || retryMs <= 0) {
         throw new RangeError("retryMs must be a positive finite number");
     }
-    const acquireExecution = async (released) => {
+    const reportReleaseError = options.onReleaseError ?? ((event) => {
+        dslog("execution.host_lease_release_retry", "Host execution lease 释放失败,准备重试", {
+            level: "ERROR",
+            resource: event.resource,
+            attempt: event.attempt,
+            retry_delay_ms: event.retryDelayMs,
+            error_message: event.error instanceof Error ? event.error.message.slice(0, 500) : String(event.error).slice(0, 500),
+        });
+    });
+    const retryRelease = async (resource, release) => {
+        let attempt = 0;
+        while (true) {
+            try {
+                await release();
+                return;
+            }
+            catch (error) {
+                attempt += 1;
+                const retryDelayMs = Math.min(RELEASE_RETRY_MAX_MS, retryMs * 2 ** Math.min(attempt - 1, 6));
+                try {
+                    reportReleaseError({ resource, attempt, retryDelayMs, error });
+                }
+                catch { /* diagnostics must never stop lease cleanup */ }
+                await wait(retryDelayMs);
+            }
+        }
+    };
+    const trackRelease = (release) => {
+        pendingReleases.add(release);
+        void release.finally(() => pendingReleases.delete(release)).catch(() => undefined);
+        return release;
+    };
+    const acquireExecution = async (released, lane) => {
         let offset = 0;
+        const slotCount = lane === "memory_prune" ? 1 : executionSlots;
+        const slotRoot = lane === "memory_prune" ? "memory-prune-slots" : "slots";
         while (!released()) {
-            for (let step = 0; step < executionSlots; step += 1) {
-                const slot = (offset + step) % executionSlots;
-                const lease = await leaseFor(join(root, "slots", String(slot)));
+            for (let step = 0; step < slotCount; step += 1) {
+                const slot = (offset + step) % slotCount;
+                const lease = await acquireLease(join(root, slotRoot, String(slot)));
                 if (lease !== null)
                     return lease;
             }
-            offset = (offset + 1) % executionSlots;
+            offset = (offset + 1) % slotCount;
             await wait(retryMs);
         }
         return null;
     };
-    const acquireStartup = async (released) => {
+    const acquireStartup = async (released, lane) => {
+        const slotCount = lane === "memory_prune" ? 1 : startupSlots;
+        const slotRoot = lane === "memory_prune" ? "memory-prune-startup-slots" : "startup-slots";
+        // Keep the legacy directory as the short-lived launch-gap mutex. During a rolling upgrade,
+        // older daemons still hold this same lease for their full startup lifetime, so old and new
+        // versions remain mutually coordinated instead of producing an unbounded spawn burst.
+        const gapDirectory = join(root, lane === "memory_prune" ? "memory-prune-startup" : "startup");
+        let offset = 0;
         while (!released()) {
-            const directory = join(root, "startup");
-            const lease = await leaseFor(directory);
-            if (lease === null) {
+            let startupSlot = null;
+            for (let step = 0; step < slotCount; step += 1) {
+                const slot = (offset + step) % slotCount;
+                startupSlot = await acquireLease(join(root, slotRoot, String(slot)));
+                if (startupSlot !== null)
+                    break;
+            }
+            if (startupSlot === null) {
+                offset = (offset + 1) % slotCount;
                 await wait(retryMs);
                 continue;
             }
-            const timestampPath = join(directory, "last-launch-at");
-            let previous = Number.NEGATIVE_INFINITY;
+            let granted = false;
             try {
-                previous = Number.parseInt(await readFile(timestampPath, "utf8"), 10);
-                if (!Number.isFinite(previous))
-                    previous = Number.NEGATIVE_INFINITY;
-            }
-            catch (error) {
-                if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
-                    await lease.close();
-                    throw error;
+                while (!released()) {
+                    const gapLease = await acquireLease(gapDirectory);
+                    if (gapLease === null) {
+                        await wait(retryMs);
+                        continue;
+                    }
+                    try {
+                        const timestampPath = join(gapDirectory, "last-launch-at");
+                        let previous = Number.NEGATIVE_INFINITY;
+                        try {
+                            previous = Number.parseInt(await readFile(timestampPath, "utf8"), 10);
+                            if (!Number.isFinite(previous))
+                                previous = Number.NEGATIVE_INFINITY;
+                        }
+                        catch (error) {
+                            if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+                                throw error;
+                        }
+                        const delay = Math.max(0, previous + startupGapMs - now());
+                        if (delay > 0)
+                            await wait(delay);
+                        if (released())
+                            return null;
+                        await writeLaunchTimestamp(timestampPath, now());
+                    }
+                    finally {
+                        await retryRelease(`${lane}:startup_gap`, () => gapLease.close());
+                    }
+                    granted = true;
+                    return startupSlot;
                 }
-            }
-            const delay = Math.max(0, previous + startupGapMs - now());
-            if (delay > 0)
-                await wait(delay);
-            if (released()) {
-                await lease.close();
                 return null;
             }
-            await writeLaunchTimestamp(timestampPath, now());
-            return lease;
+            finally {
+                if (!granted)
+                    await retryRelease(`${lane}:startup_slot`, () => startupSlot.close());
+            }
         }
         return null;
     };
-    const tracked = (entry) => {
+    const tracked = (entry, resource) => {
         let trackedRelease = null;
         return {
             ...entry,
             release: () => {
                 if (trackedRelease !== null)
                     return trackedRelease;
-                trackedRelease = entry.release();
-                pendingReleases.add(trackedRelease);
-                void trackedRelease.then(() => pendingReleases.delete(trackedRelease), () => pendingReleases.delete(trackedRelease));
+                trackedRelease = trackRelease(retryRelease(resource, entry.release));
                 return trackedRelease;
             },
         };
     };
     return {
-        reserveExecution: (prerequisite) => tracked(reservation(prerequisite, acquireExecution)),
-        reserveStartup: (prerequisite) => tracked(reservation(prerequisite, acquireStartup)),
+        reserveExecution: (prerequisite, lane = "foreground") => tracked(reservation(prerequisite, (released) => acquireExecution(released, lane)), `${lane}:execution_slot`),
+        reserveStartup: (prerequisite, lane = "foreground") => tracked(reservation(prerequisite, (released) => acquireStartup(released, lane)), `${lane}:startup_slot`),
         tryAcquireExclusiveExecution: async () => {
             const leases = [];
-            for (let slot = 0; slot < executionSlots; slot += 1) {
-                const lease = await leaseFor(join(root, "slots", String(slot)));
+            const targets = [
+                ...Array.from({ length: executionSlots }, (_, slot) => join(root, "slots", String(slot))),
+                join(root, "memory-prune-slots", "0"),
+            ];
+            for (const target of targets) {
+                const lease = await acquireLease(target);
                 if (lease === null) {
-                    await Promise.all(leases.map((owned) => owned.close()));
+                    await retryRelease("exclusive_execution_partial", () => Promise.all(leases.map((owned) => owned.close())).then(() => undefined));
                     return null;
                 }
                 leases.push(lease);
@@ -200,9 +290,7 @@ export function createHostExecutionCoordinator(options = {}) {
                 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));
+                    releasePromise = trackRelease(retryRelease("exclusive_execution", () => Promise.all(leases.map((lease) => lease.close())).then(() => undefined)));
                     return releasePromise;
                 },
             };
@@ -214,13 +302,20 @@ export function createHostExecutionCoordinator(options = {}) {
     };
 }
 export function hostCoordinatedSlotManager(local, host) {
+    const coordinated = new Set();
     return {
         reserve: (handle, kind, executionClass) => {
             const localReservation = local.reserve(handle, kind, executionClass);
             if (!localReservation.accepted)
                 return localReservation;
-            const hostReservation = host.reserveExecution(localReservation.ready);
-            let released = false;
+            const hostReservation = host.reserveExecution(localReservation.ready, executionClass === "memory_prune" ? "memory_prune" : "foreground");
+            const entry = {
+                local: localReservation,
+                host: hostReservation,
+                memoryPrune: executionClass === "memory_prune",
+                released: false,
+            };
+            coordinated.add(entry);
             return {
                 ...localReservation,
                 // File ownership is asynchronous, so accepted work is conservatively
@@ -229,23 +324,45 @@ export function hostCoordinatedSlotManager(local, host) {
                 ready: hostReservation.ready,
                 isQueued: hostReservation.isQueued,
                 release: () => {
-                    if (released)
+                    if (entry.released)
                         return;
-                    released = true;
+                    entry.released = true;
+                    coordinated.delete(entry);
                     void hostReservation.release();
                     localReservation.release();
                 },
             };
         },
-        snapshot: local.snapshot,
+        snapshot: () => {
+            const snapshot = local.snapshot();
+            let foregroundHostWaiting = 0;
+            let memoryPruneHostWaiting = 0;
+            for (const entry of coordinated) {
+                if (entry.released || entry.local.isQueued() || !entry.host.isQueued())
+                    continue;
+                if (entry.memoryPrune)
+                    memoryPruneHostWaiting += 1;
+                else
+                    foregroundHostWaiting += 1;
+            }
+            return {
+                ...snapshot,
+                queuedTotal: snapshot.queuedTotal + foregroundHostWaiting,
+                admittedTotal: Math.max(0, snapshot.admittedTotal - foregroundHostWaiting),
+                preparingTotal: Math.max(0, snapshot.preparingTotal - foregroundHostWaiting),
+                memoryPruneQueuedTotal: snapshot.memoryPruneQueuedTotal + memoryPruneHostWaiting,
+                memoryPruneAdmittedTotal: Math.max(0, snapshot.memoryPruneAdmittedTotal - memoryPruneHostWaiting),
+                memoryPrunePreparingTotal: Math.max(0, snapshot.memoryPrunePreparingTotal - memoryPruneHostWaiting),
+            };
+        },
         tryAcquireExclusive: local.tryAcquireExclusive,
     };
 }
 export function hostCoordinatedStartupGate(local, host) {
     return {
-        reserve: (runtime) => {
-            const localReservation = local.reserve(runtime);
-            const hostReservation = host.reserveStartup(localReservation.ready);
+        reserve: (runtime, lane = "foreground") => {
+            const localReservation = local.reserve(runtime, lane);
+            const hostReservation = host.reserveStartup(localReservation.ready, lane);
             let released = false;
             return {
                 ready: hostReservation.ready,

package/dist/local-executor.js

@@ -19,7 +19,7 @@ import { decodeExternalOutputEvent, extractExternalAnswer, ExternalAnswerDecoder
 import { cleanupMaterializedAttachments as cleanupAttachments, executionAttachmentDirectory, materializeAttachments, } from "./attachments.js";
 import { routeRuntimeAttachments, runtimeCapability, } from "./runtime-capabilities.js";
 import { awaitWithCancellation, RuntimeCancelledError, } from "./runtime-cancellation.js";
-import { isRuntimeReadyEvent, } from "./runtime-startup-gate.js";
+import { isRuntimeReadyEvent, isRuntimeRunningEvent, } from "./runtime-startup-gate.js";
 import { dslog } from "./slog.js";
 import { boundedDiagnosticJsonArray } from "./diagnostic-json.js";
 import { ProjectProjectionError, } from "./project-skills/reconciler.js";
@@ -61,6 +61,7 @@ function logMemoryPruneDiagnosticsFailure(input, traceId, phase, error) {
     });
 }
 const STDERR_TAIL_CAP = 2_000;
+const RUNTIME_RUNNING_CALLBACK_TIMEOUT_MS = 10_000;
 const MEMORY_PRUNE_DIAGNOSTICS_TIMEOUT_MS = 2_000;
 const LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS = 250;
 const CLAUDE_INSTRUCTION_WARNING = "claude_additional_directory_instructions_unverified";
@@ -266,7 +267,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     }
     let materialized = null;
     let knownAttachmentDirectory = null;
-    let startupReservation = null;
+    const startupReservationState = { current: null };
     let memoryPruneTraceId = null;
     let memoryPruneRuntimeExitCode;
     let memoryPruneExecutorCompleted = false;
@@ -479,31 +480,11 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const launchRuntime = dependencies.launchRuntime ?? launchLegacyRuntime;
         if (dependencies.cancellation?.isRequested())
             throw new RuntimeCancelledError();
-        startupReservation = dependencies.startupGate?.reserve(runtime.name) ?? null;
-        if (startupReservation !== null) {
-            const startupQueueEnteredAt = Date.now();
-            dslog("runtime.start_queued", "runtime 等待启动许可", {
-                execution_id: input.executionId,
-                runtime: runtime.name,
-                queued: startupReservation.isQueued(),
-            });
-            try {
-                await awaitWithCancellation(startupReservation.ready, dependencies.cancellation);
-                dslog("runtime.start_granted", "runtime 获得启动许可", {
-                    execution_id: input.executionId,
-                    runtime: runtime.name,
-                    startup_queue_ms: Date.now() - startupQueueEnteredAt,
-                });
-            }
-            catch (error) {
-                startupReservation.release();
-                throw error;
-            }
-        }
-        const runtimeLaunchAt = Date.now();
-        memoryPruneFailurePhase = "runtime_launch";
         let activeProjectSkillRuntimeRoot;
-        const launchPreparedRuntime = async (runtimeRoot, abilityContext) => {
+        const abilityContext = input.abilityRelease !== undefined && dependencies.abilityRelease !== undefined
+            ? await dependencies.abilityRelease.prepareAndLaunch(input.launch.agentsRoot, input.handle, input.abilityRelease, async (context) => context)
+            : undefined;
+        const prepareRuntimeLaunch = async (runtimeRoot) => {
             activeProjectSkillRuntimeRoot = runtimeRoot;
             const effectiveSystemPrompt = abilityContext === undefined
                 ? systemPrompt
@@ -602,24 +583,55 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                     projectContext: input.projectContext,
                 }),
             };
+            return launchRequest;
+        };
+        let runtimeLaunchAt = Date.now();
+        const launchPreparedRuntime = async (runtimeRoot) => {
+            const launchRequest = await prepareRuntimeLaunch(runtimeRoot);
+            if (dependencies.cancellation?.isRequested())
+                throw new RuntimeCancelledError();
+            const startupLane = memoryPruneTraceId === null ? "foreground" : "memory_prune";
+            startupReservationState.current = dependencies.startupGate?.reserve(runtime.name, startupLane) ?? null;
+            const startupReservation = startupReservationState.current;
+            if (startupReservation !== null) {
+                const startupQueueEnteredAt = Date.now();
+                dslog("runtime.start_queued", "runtime 等待启动许可", {
+                    execution_id: input.executionId,
+                    runtime: runtime.name,
+                    startup_lane: startupLane,
+                    queued: startupReservation.isQueued(),
+                });
+                try {
+                    await awaitWithCancellation(startupReservation.ready, dependencies.cancellation);
+                    dslog("runtime.start_granted", "runtime 获得启动许可", {
+                        execution_id: input.executionId,
+                        runtime: runtime.name,
+                        startup_lane: startupLane,
+                        startup_queue_ms: Date.now() - startupQueueEnteredAt,
+                    });
+                }
+                catch (error) {
+                    startupReservation.release();
+                    throw error;
+                }
+            }
+            await callbacks.onRuntimeStarting?.(runtime.name);
+            runtimeLaunchAt = Date.now();
             memoryPruneFailurePhase = "runtime_launch";
             return launchRuntime(launchRequest);
         };
-        const launchWithAbility = (runtimeRoot) => input.abilityRelease !== undefined && dependencies.abilityRelease !== undefined
-            ? dependencies.abilityRelease.prepareAndLaunch(input.launch.agentsRoot, input.handle, input.abilityRelease, (abilityContext) => launchPreparedRuntime(runtimeRoot, abilityContext))
-            : launchPreparedRuntime(runtimeRoot);
         let child;
         if (input.projectSkills !== undefined && dependencies.projectSkills !== undefined) {
             const launchOwner = dependencies.projectSkillLeaseSafeLaunchOwner;
             if (launchOwner === undefined)
                 throw new ProjectProjectionError("skill_projection_failed");
-            child = await dependencies.projectSkills.prepareAndLaunch(input.launch.agentsRoot, input.executionId, input.handle, input.projectSkills, launchOwner.claim(launchWithAbility), (warning) => callbacks.onConsole?.({
+            child = await dependencies.projectSkills.prepareAndLaunch(input.launch.agentsRoot, input.executionId, input.handle, input.projectSkills, launchOwner.claim(launchPreparedRuntime), (warning) => callbacks.onConsole?.({
                 stream: "system",
                 text: formatProjectSkillRuntimeWarning(warning),
             }));
         }
         else {
-            child = await launchWithAbility();
+            child = await launchPreparedRuntime();
         }
         localMemoryTelemetry?.markRuntimeStarted();
         memoryPruneFailurePhase = "runtime_execution";
@@ -640,15 +652,24 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         // 每轮独立:tool_use/result 关联状态不能跨 execution 泄漏。
         const consoleFormatter = createConsoleFormatter();
         let runtimeReady = false;
+        let runtimeRunning = false;
         let resolveRuntimeReady;
         const runtimeReadySignal = new Promise((resolve) => { resolveRuntimeReady = resolve; });
         let runtimeReadyNotification = Promise.resolve();
+        let runtimeRunningNotification = Promise.resolve();
+        let rejectRuntimeRunningFailure;
+        const runtimeRunningFailure = new Promise((_resolve, reject) => {
+            rejectRuntimeRunningFailure = reject;
+        });
+        // The failure can arrive in the same stdout turn before the exit race is installed.
+        // Attach a handler immediately while retaining the original rejection for that race.
+        void runtimeRunningFailure.catch(() => undefined);
         const markRuntimeReady = () => {
             if (runtimeReady)
                 return;
             runtimeReady = true;
             localMemoryTelemetry?.markRuntimeReady();
-            startupReservation?.release();
+            startupReservationState.current?.release();
             dslog("runtime.start_ready", "runtime 已完成初始化", {
                 execution_id: input.executionId,
                 runtime: runtime.name,
@@ -657,6 +678,51 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             runtimeReadyNotification = Promise.resolve(callbacks.onRuntimeReady?.(runtime.name));
             resolveRuntimeReady();
         };
+        const markRuntimeRunning = () => {
+            if (runtimeRunning)
+                return;
+            runtimeRunning = true;
+            let callbackTimer;
+            runtimeRunningNotification = Promise.race([
+                Promise.resolve().then(() => callbacks.onRuntimeRunning?.(runtime.name)),
+                new Promise((_resolve, reject) => {
+                    const callbackTimeoutMs = dependencies.runtimeRunningCallbackTimeoutMs
+                        ?? RUNTIME_RUNNING_CALLBACK_TIMEOUT_MS;
+                    callbackTimer = setTimeout(() => reject(new Error(`${runtime.name} runtime-running callback timed out after ${callbackTimeoutMs}ms`)), callbackTimeoutMs);
+                }),
+            ]).finally(() => {
+                if (callbackTimer !== undefined)
+                    clearTimeout(callbackTimer);
+            });
+            void runtimeRunningNotification.catch((error) => {
+                // Persisting the running phase is part of execution liveness. Propagate
+                // its failure immediately: cancellation is best-effort and must not be
+                // allowed to keep the execution or its slots alive indefinitely.
+                rejectRuntimeRunningFailure(error);
+                try {
+                    void child.cancel?.().catch((cancelError) => {
+                        dslog("runtime.running_callback_cancel_failed", "runtime-running 回调失败后的取消也失败", {
+                            level: "ERROR",
+                            execution_id: input.executionId,
+                            runtime: runtime.name,
+                            error_message: cancelError instanceof Error
+                                ? cancelError.message.slice(0, 500)
+                                : String(cancelError).slice(0, 500),
+                        });
+                    });
+                }
+                catch (cancelError) {
+                    dslog("runtime.running_callback_cancel_failed", "runtime-running 回调失败后的取消也失败", {
+                        level: "ERROR",
+                        execution_id: input.executionId,
+                        runtime: runtime.name,
+                        error_message: cancelError instanceof Error
+                            ? cancelError.message.slice(0, 500)
+                            : String(cancelError).slice(0, 500),
+                    });
+                }
+            });
+        };
         const readline = createInterface({ input: child.stdout });
         readline.on("line", (line) => {
             const event = parseLine(line);
@@ -665,6 +731,11 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             localMemoryTelemetry?.observe(event);
             if (isRuntimeReadyEvent(runtime.name, event))
                 markRuntimeReady();
+            if (isRuntimeRunningEvent(runtime.name, event)) {
+                if (!runtimeReady)
+                    markRuntimeReady();
+                markRuntimeRunning();
+            }
             const meta = extractRunMeta(event);
             if (meta.sessionId)
                 sessionId = meta.sessionId;
@@ -723,6 +794,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         child.stderr.on("end", () => codexStartupStageParser?.finish());
         let runtimeExit;
         try {
+            const startupReservation = startupReservationState.current;
             if (startupReservation !== null) {
                 let startupTimer;
                 let startupOutcome;
@@ -761,7 +833,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 }
                 await runtimeReadyNotification;
             }
-            runtimeExit = await awaitWithCancellation(child.exit, dependencies.cancellation);
+            runtimeExit = await awaitWithCancellation(Promise.race([child.exit, runtimeRunningFailure]), dependencies.cancellation);
+            await runtimeRunningNotification;
         }
         catch (error) {
             if (error instanceof RuntimeCancelledError) {
@@ -831,7 +904,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         };
     }
     finally {
-        startupReservation?.release();
+        startupReservationState.current?.release();
         try {
             await localMemoryTelemetry?.finish();
         }

package/dist/project-skills/reconciler.js

@@ -105,7 +105,7 @@ export const canonicalTrainingSkillLinkTarget = (source, link, trainingSkillsRoo
         : null;
 };
 export const isTrainingSkillLink = (source, link, trainingSkillsRoot, platform) => canonicalTrainingSkillLinkTarget(source, link, trainingSkillsRoot, platform) !== null;
-const preserveNonProjectSkills = async (projectionTarget, trainingSkillsRoot, platform) => {
+const preserveNonProjectSkills = async (projectionTarget, trainingSkillsRoot, platform, projectSkillNames) => {
     const names = new Set();
     if (!await exists(projectionTarget.target))
         return names;
@@ -130,6 +130,8 @@ const preserveNonProjectSkills = async (projectionTarget, trainingSkillsRoot, pl
             const canonicalTarget = canonicalTrainingSkillLinkTarget(source, link, trainingSkillsRoot, platform);
             if (canonicalTarget === null)
                 continue;
+            if (projectSkillNames.has(entry.name))
+                continue;
             await symlink(platform === "win32" ? canonicalTarget : link, destination, platform === "win32" ? "junction" : "dir");
         }
         else {
@@ -194,6 +196,7 @@ export function createProjectSkillsReconciler(deps) {
                 resolutionRecords.push(Object.freeze({ ...binding, sourcePath: null, mode: "missing" }));
             }
         }
+        const linkedNames = new Set(linked.map((item) => item.binding.skillName));
         const id = randomUUID();
         const targets = projectionTargets(agentRoot, id);
         const nextProjectionDiagnostics = [];
@@ -202,7 +205,7 @@ export function createProjectSkillsReconciler(deps) {
                 await mkdir(dirname(target.target), { recursive: true });
                 await mkdir(target.staging, { mode: 0o700 });
                 await markProjectionStaging(target, id);
-                const preservedNames = await preserveNonProjectSkills(target, join(agentRoot, "training", "skills"), platform);
+                const preservedNames = await preserveNonProjectSkills(target, join(agentRoot, "training", "skills"), platform, linkedNames);
                 for (const item of linked) {
                     if (preservedNames.has(item.binding.skillName)) {
                         throw new ProjectProjectionError("skill_name_conflict");

package/dist/runner.js

@@ -105,7 +105,12 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             softTokens: config.sessionSoftTokens,
             maxTurns: config.sessionMaxTurns,
         },
-    }, { onActivity, onConsole }, {
+    }, {
+        onActivity,
+        onConsole,
+        onRuntimeStarting: () => dependencies.onRuntimePhase?.("starting"),
+        onRuntimeRunning: () => dependencies.onRuntimePhase?.("running"),
+    }, {
         launchRuntime: dependencies.launchRuntime ?? ((request) => launchSupervisedRuntime(request, dependencies.startSupervisor, dependencies.cancellation, dependencies.platform)),
         ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }),
         ...(dependencies.startupGate === undefined ? {} : { startupGate: dependencies.startupGate }),

package/dist/runtime-startup-gate.js

@@ -1,41 +1,54 @@
 export function createRuntimeStartupGate(limits, now = Date.now) {
-    const activeByRuntime = new Map();
+    const activeByRuntimeAndLane = new Map();
     const queue = [];
-    let activeTotal = 0;
-    let lastLaunchAt = Number.NEGATIVE_INFINITY;
-    const promote = () => {
-        while (activeTotal < limits.maxStartingTotal) {
+    const activeByLane = { foreground: 0, memory_prune: 0 };
+    const lastLaunchAt = {
+        foreground: Number.NEGATIVE_INFINITY,
+        memory_prune: Number.NEGATIVE_INFINITY,
+    };
+    const activeKey = (runtime, lane) => `${lane}:${runtime}`;
+    const maxTotalFor = (lane) => lane === "memory_prune" ? 1 : limits.maxStartingTotal;
+    const maxPerRuntimeFor = (lane) => lane === "memory_prune" ? 1 : limits.maxStartingPerRuntime;
+    const promoteLane = (lane) => {
+        while (activeByLane[lane] < maxTotalFor(lane)) {
             const index = queue.findIndex((entry) => !entry.released
-                && (activeByRuntime.get(entry.runtime) ?? 0) < limits.maxStartingPerRuntime);
+                && entry.lane === lane
+                && (activeByRuntimeAndLane.get(activeKey(entry.runtime, lane)) ?? 0) < maxPerRuntimeFor(lane));
             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);
+            activeByLane[lane] += 1;
+            const key = activeKey(next.runtime, lane);
+            activeByRuntimeAndLane.set(key, (activeByRuntimeAndLane.get(key) ?? 0) + 1);
             const grant = () => {
                 next.timer = null;
                 if (next.released)
                     return;
                 next.launchGranted = true;
-                lastLaunchAt = now();
+                lastLaunchAt[lane] = now();
                 next.resolve();
             };
-            const delay = Math.max(0, lastLaunchAt + limits.startupGapMs - now());
+            const delay = Math.max(0, lastLaunchAt[lane] + limits.startupGapMs - now());
             if (delay === 0)
                 grant();
             else
                 next.timer = setTimeout(grant, delay);
         }
     };
+    const promote = () => {
+        promoteLane("foreground");
+        promoteLane("memory_prune");
+    };
     return {
-        reserve: (runtime) => {
+        reserve: (runtime, lane = "foreground") => {
             let resolveReady;
             const ready = new Promise((resolve) => { resolveReady = resolve; });
             const entry = {
                 runtime,
+                lane,
                 released: false,
                 promoted: false,
                 launchGranted: false,
@@ -54,12 +67,13 @@ export function createRuntimeStartupGate(limits, now = Date.now) {
                     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);
+                        activeByLane[lane] = Math.max(0, activeByLane[lane] - 1);
+                        const key = activeKey(runtime, lane);
+                        const nextForRuntime = Math.max(0, (activeByRuntimeAndLane.get(key) ?? 1) - 1);
                         if (nextForRuntime === 0)
-                            activeByRuntime.delete(runtime);
+                            activeByRuntimeAndLane.delete(key);
                         else
-                            activeByRuntime.set(runtime, nextForRuntime);
+                            activeByRuntimeAndLane.set(key, nextForRuntime);
                     }
                     else {
                         const index = queue.indexOf(entry);
@@ -71,15 +85,17 @@ export function createRuntimeStartupGate(limits, now = Date.now) {
             };
         },
         snapshot: () => ({
-            startingTotal: activeTotal,
-            queuedTotal: queue.length,
+            startingTotal: activeByLane.foreground,
+            queuedTotal: queue.filter((entry) => entry.lane === "foreground").length,
+            memoryPruneStartingTotal: activeByLane.memory_prune,
+            memoryPruneQueuedTotal: queue.filter((entry) => entry.lane === "memory_prune").length,
             startingByRuntime: {
-                claude: activeByRuntime.get("claude") ?? 0,
-                codex: activeByRuntime.get("codex") ?? 0,
-                kimi: activeByRuntime.get("kimi") ?? 0,
-                hermes: activeByRuntime.get("hermes") ?? 0,
-                opencode: activeByRuntime.get("opencode") ?? 0,
-                "deepseek-harness": activeByRuntime.get("deepseek-harness") ?? 0,
+                claude: activeByRuntimeAndLane.get(activeKey("claude", "foreground")) ?? 0,
+                codex: activeByRuntimeAndLane.get(activeKey("codex", "foreground")) ?? 0,
+                kimi: activeByRuntimeAndLane.get(activeKey("kimi", "foreground")) ?? 0,
+                hermes: activeByRuntimeAndLane.get(activeKey("hermes", "foreground")) ?? 0,
+                opencode: activeByRuntimeAndLane.get(activeKey("opencode", "foreground")) ?? 0,
+                "deepseek-harness": activeByRuntimeAndLane.get(activeKey("deepseek-harness", "foreground")) ?? 0,
             },
         }),
     };
@@ -92,3 +108,11 @@ export function isRuntimeReadyEvent(runtime, event) {
         return value.type === "system" && value.subtype === "init";
     return value.type === "thread.started";
 }
+export function isRuntimeRunningEvent(runtime, event) {
+    if (typeof event !== "object" || event === null)
+        return false;
+    const value = event;
+    if (runtime === "codex")
+        return value.type === "turn.started";
+    return isRuntimeReadyEvent(runtime, event);
+}

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

@@ -209,6 +209,12 @@ export function mapCodexNotification(method, params) {
     if (method === "thread/started" && value.thread?.id) {
         return [{ type: "thread.started", thread_id: value.thread.id }];
     }
+    if (method === "turn/started") {
+        return [{
+                type: "turn.started",
+                ...(value.turn?.id === undefined ? {} : { turn_id: value.turn.id }),
+            }];
+    }
     const plan = method === "turn/plan/updated" ? boundedCodexPlan(value.plan) : null;
     if (plan !== null && typeof value.threadId === "string" && typeof value.turnId === "string") {
         return [{

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