@nowcrew/daemon 0.6.30 → 0.6.31

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");