@nowcrew/daemon 0.6.88-beta.17 → 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/machine-info.js

@@ -1,3 +1,4 @@
+import { retryHarnessProbe } from "./runtimes/harness-probe-retry.js";
 /**
  * 采集本机信息上报给控制面 (machine:hello):hostname / os / daemon 版本 / 已装 runtimes。
  * runtimes 探测靠 `which <bin>`(win32 用 `where`),只报真实可执行的 CLI(用于展示 Detected Runtimes)。
@@ -16,7 +17,7 @@ import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
 import { executableRuntimes } from "./runtime-capabilities.js";
 import { executionBackendCapability } from "./execution-backend.js";
-import { probeKimiAcp } from "./runtimes/kimi-acp-runner.js";
+import { probeKimiAcp, AcpProbeCleanupError } from "./runtimes/kimi-acp-runner.js";
 import { probeHermesAcp } from "./runtimes/hermes.js";
 import { probeOpenCodeRun } from "./runtimes/opencode.js";
 import { RUNTIME_HEALTH_PROBE_CAPABILITY } from "./runtime-health.js";
@@ -132,7 +133,9 @@ async function supportsDeepSeekHarnessAcp(signal, probeId) {
     try {
         return await probeDeepSeekHarnessAcp({ bin: deepSeekHarnessLauncher().bin, ...(probeId ? { probeId } : {}), ...(signal ? { signal } : {}) });
     }
-    catch {
+    catch (error) {
+        if (error instanceof AcpProbeCleanupError)
+            throw error;
         return false;
     }
 }
@@ -162,7 +165,9 @@ export async function detectExecutionRuntimes(installed = detectRuntimes(), kimi
         present.includes("kimi") ? probe("kimi", kimiAcpProbe) : false,
         present.includes("hermes") ? probe("hermes", hermesAcpProbe) : false,
         present.includes("opencode") ? probe("opencode", openCodeProbe) : false,
-        present.includes("deepseek-harness") ? probe("deepseek-harness", deepSeekHarnessProbe) : false,
+        present.includes("deepseek-harness")
+            ? retryHarnessProbe(() => probe("deepseek-harness", deepSeekHarnessProbe), signal, probeId)
+            : false,
     ]);
     return executableRuntimes(present).filter((runtime) => (runtime === "kimi" ? kimiReady
         : runtime === "hermes" ? hermesReady

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/runtimes/deepseek-harness.js

@@ -4,7 +4,7 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { prepareHarnessProfile } from "./deepseek-harness-profile.js";
-import { probeKimiAcp } from "./kimi-acp-runner.js";
+import { probeKimiAcp, AcpProbeCleanupError } from "./kimi-acp-runner.js";
 export const DEEPSEEK_HARNESS_CONFIG_ENV = "NOWCREW_DEEPSEEK_HARNESS_CONFIG";
 export const DEEPSEEK_HARNESS_PATCH_ENV = "NOWCREW_DEEPSEEK_HARNESS_PATCH";
 export function deepSeekHarnessLauncher(env = process.env) {
@@ -61,7 +61,9 @@ export async function probeDeepSeekHarnessAcp(options, spawnProcess = spawn) {
             launchCwd: root,
         }, spawnProcess);
     }
-    catch {
+    catch (error) {
+        if (error instanceof AcpProbeCleanupError)
+            throw error;
         return false;
     }
     finally {

package/dist/runtimes/harness-probe-retry.js

@@ -0,0 +1,42 @@
+import { dslog } from "../slog.js";
+const RETRY_DELAYS_MS = [1_000, 2_000];
+/** 只延迟当前启动探测,不设后台定时任务;stop 立即清除等待。 */
+function waitForRetry(ms, signal) {
+    if (signal?.aborted)
+        return Promise.resolve(false);
+    return new Promise((resolve) => {
+        const finish = (ready) => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            resolve(ready);
+        };
+        const onAbort = () => finish(false);
+        const timer = setTimeout(() => finish(true), ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+/** 成功才公布能力;每次 probe 返回前已完成进程清理,异常保持原有传播。 */
+export async function retryHarnessProbe(probe, signal, probeId) {
+    for (let attempt = 1; attempt <= RETRY_DELAYS_MS.length + 1; attempt++) {
+        if (signal?.aborted)
+            return false;
+        const ready = await probe();
+        dslog("runtime_probe.harness_attempt", "Harness 启动探测尝试结束", {
+            probe_id: probeId, runtime: "deepseek-harness", attempt, ready,
+            aborted: signal?.aborted ?? false,
+        });
+        if (signal?.aborted)
+            return false;
+        if (ready)
+            return true;
+        const delayMs = RETRY_DELAYS_MS[attempt - 1];
+        if (delayMs === undefined)
+            return false;
+        dslog("runtime_probe.harness_retry", "延迟重试 Harness 启动探测", {
+            probe_id: probeId, runtime: "deepseek-harness", next_attempt: attempt + 1, delay_ms: delayMs,
+        });
+        if (!await waitForRetry(delayMs, signal))
+            return false;
+    }
+    return false;
+}

package/dist/runtimes/kimi-acp-runner.js

@@ -196,6 +196,9 @@ async function stopChild(child) {
         await closed;
     }
 }
+export class AcpProbeCleanupError extends Error {
+    constructor() { super("ACP probe process cleanup unconfirmed"); this.name = "AcpProbeCleanupError"; }
+}
 /** Probe the ACP transport without starting a session or forcing an optional interactive login flow. */
 export async function probeKimiAcp(options, spawnProcess = spawn) {
     const provider = options.provider ?? "kimi";
@@ -280,6 +283,9 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
             await stopChild(child);
             cleanupFinished = true;
         }
+        catch {
+            throw new AcpProbeCleanupError();
+        }
         finally {
             dslog("execution.acp_probe_finished", "ACP 探测结束", { ...fields(),
                 cleanup_finished: cleanupFinished, exit_code: child.exitCode, exit_signal: child.signalCode,

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