@nowcrew/daemon 0.6.88-beta.18 → 0.6.88-beta.19

package/dist/execution-protocol.js

@@ -264,6 +264,7 @@ export const ExecutionRejectedSchema = z.object({
     reason: RejectionReasonSchema,
     message: z.string().optional(),
     at: TimestampSchema,
+    preAdmissionProof: z.object({ specHash: z.string().regex(/^[a-f0-9]{64}$/u) }).strict().optional(),
 }).strict();
 export const ExecutionStartedSchema = z.object({
     type: z.literal("execution:started"),

package/dist/execution-runner.js

@@ -408,7 +408,8 @@ export async function runExecution(config, input, dependencies) {
         ? { permission: effectivePermission(spec, config) }
         : admission(spec, config, dependencies, initialAt);
     if ("rejected" in checked) {
-        const frame = ExecutionRejectedSchema.parse(boundExecutionFrame(checked.rejected, config.executionLimits.maxEventBytes));
+        const proof = await dependencies.confirmPreAdmission?.(checked.rejected).catch(() => false);
+        const frame = ExecutionRejectedSchema.parse(boundExecutionFrame({ ...checked.rejected, ...(proof ? { preAdmissionProof: { specHash } } : {}) }, config.executionLimits.maxEventBytes));
         await dependencies.report(frame);
         return { kind: "rejected", frame };
     }

package/dist/pre-admission-rejection.js

@@ -0,0 +1,64 @@
+import { ExecutionCompletedSchema, ExecutionRejectedSchema } from "./execution-protocol.js";
+import { hashExecutionSpec } from "./execution-runner.js";
+import { dslog } from "./slog.js";
+/** Queue rejection is admission work too: own the ID before any asynchronous journal write. */
+export async function rejectQueuedAdmission(context, spec, executionClass, facts) {
+    const id = spec.executionId;
+    const hash = hashExecutionSpec(spec);
+    if (context.knownExecutionHashes.has(id) || context.executionRuns.has(id)) {
+        // A same-ID request won while the caller awaited journal.get. Its journal may
+        // still be pending; silence lets its real result arrive instead of rejecting it.
+        const existing = await context.journal.get(id);
+        if (existing?.specHash === hash)
+            context.replay(existing);
+        return;
+    }
+    context.knownExecutionHashes.set(id, hash);
+    const rejected = ExecutionRejectedSchema.parse({
+        type: "execution:rejected", protocolVersion: 1, executionId: id,
+        reason: "resource_limit", message: "Local machine execution queue is full", at: new Date().toISOString(),
+    });
+    dslog("execution.machine_queue_rejected", "机器执行队列已满", {
+        level: "WARN", execution_id: id, agent_handle: spec.agent.handle, execution_class: executionClass, ...facts,
+    });
+    const rejecting = persistPreAdmissionRejection(context.journal, spec, rejected)
+        .then(async (entry) => {
+        if (entry)
+            await context.report({ ...rejected, preAdmissionProof: { specHash: hash } });
+        else {
+            const existing = await context.journal.get(id);
+            if (existing?.specHash === hash)
+                context.replay(existing);
+        }
+    })
+        .catch(error => {
+        // A failed durable write has no safe rejection proof; a restart/sync will
+        // reconcile an accepted tombstone if this admission created one.
+        dslog("execution.admission_rejection_failed", "准入拒绝未取得持久停止证明", {
+            level: "ERROR", execution_id: id, error_message: String(error),
+        });
+    })
+        .finally(() => {
+        if (context.executionRuns.get(id) === rejecting) {
+            context.executionRuns.delete(id);
+            context.knownExecutionHashes.delete(id);
+        }
+    });
+    context.executionRuns.set(id, rejecting);
+    await rejecting;
+}
+/** The caller synchronously owns this admission ID. Never complete somebody else's record. */
+export async function persistPreAdmissionRejection(journal, spec, rejection) {
+    const accepted = await journal.accept(spec.executionId, hashExecutionSpec(spec), {
+        runtime: spec.runtime.name, ...(spec.runtime.model ? { model: spec.runtime.model } : {}), resumed: false,
+    });
+    if (accepted.kind !== "created")
+        return null;
+    return journal.complete(spec.executionId, ExecutionCompletedSchema.parse({
+        type: "execution:completed", protocolVersion: 1, executionId: spec.executionId,
+        outcome: "failed", errorCode: rejection.reason, errorMessage: rejection.message ?? "Admission rejected before runtime start",
+        runtime: spec.runtime.name, ...(spec.runtime.model ? { model: spec.runtime.model } : {}), resumed: false,
+        startedAt: accepted.acceptedAt,
+        finishedAt: new Date(Math.max(Date.now(), Date.parse(accepted.acceptedAt))).toISOString(),
+    }));
+}

package/dist/serve.js

@@ -3,6 +3,7 @@
  * 断线指数退避重连。一个 agent:start 进来就跑一次现有的 runAgent。
  */
 import { WebSocket } from "ws";
+import { persistPreAdmissionRejection, rejectQueuedAdmission } from "./pre-admission-rejection.js";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { dslog, setSlogDefaults, drainSpool, flushSlog } from "./slog.js";
@@ -210,6 +211,11 @@ export function serve(config, opts = {}) {
             return;
         }
         safeExecutionSend(frame);
+        if (frame.type === "execution:rejected" && frame.preAdmissionProof) {
+            const entry = await executionJournal.get(frame.executionId);
+            if (entry?.completion)
+                completionRetransmitter.track(entry.completion);
+        }
     };
     const replayExecutionTelemetry = async () => {
         const frames = await executionTelemetry.replay();
@@ -530,18 +536,8 @@ export function serve(config, opts = {}) {
                         : spec.context.scheduledRunId === undefined ? "normal" : "scheduled";
                     let reservation = sharedSlots.reserve(spec.agent.handle, "execution", executionClass);
                     if (!reservation.accepted) {
-                        dslog("execution.machine_queue_rejected", "机器执行队列已满", {
-                            level: "WARN",
-                            execution_id: spec.executionId,
-                            agent_handle: spec.agent.handle,
-                            execution_class: executionClass,
-                            ...reservation.facts,
-                        });
-                        safeExecutionSend(ExecutionRejectedSchema.parse({
-                            type: "execution:rejected", protocolVersion: 1, executionId: spec.executionId,
-                            reason: "resource_limit", message: "Local machine execution queue is full",
-                            at: new Date().toISOString(),
-                        }));
+                        await rejectQueuedAdmission({ journal: executionJournal, knownExecutionHashes, executionRuns,
+                            report: reportExecutionFrame, replay: sendJournalStatus }, spec, executionClass, reservation.facts);
                         return;
                     }
                     knownExecutionHashes.set(spec.executionId, hash);
@@ -711,6 +707,13 @@ export function serve(config, opts = {}) {
                             ...reservation.facts,
                         },
                         report: reportExecutionFrame,
+                        confirmPreAdmission: async (rejection) => {
+                            const prior = await executionJournal.get(spec.executionId);
+                            if (prior !== null || stopped || knownExecutionHashes.get(spec.executionId) !== hash
+                                || executionRuns.get(spec.executionId) !== execution)
+                                return false;
+                            return await persistPreAdmissionRejection(executionJournal, spec, rejection) !== null;
+                        },
                         startupGate: runtimeStartupGate,
                         startupTimeoutMs: config.executionLimits.startupTimeoutMs,
                         onRuntimePhase: (phase, runtime) => {

package/package.json

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