@nowcrew/daemon 0.6.29 → 0.6.31

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,