@nowcrew/daemon 0.5.30 → 0.5.32

package/dist/execution-protocol.js

@@ -98,6 +98,7 @@ export const ExecutionStartSchema = z.object({
     agent: z.object({
         id: z.string().min(1),
         handle: AgentHandleSchema,
+        memoryEnabled: z.boolean().optional(),
     }).strict(),
     workspace: z.object({
         taskKey: z.string().min(1).max(200),
@@ -121,6 +122,7 @@ export const ExecutionStartSchema = z.object({
         channelId: z.string().min(1),
         threadId: z.string().min(1).optional(),
         wakeMessageId: z.string().min(1).optional(),
+        scheduledRunId: ExecutionIdSchema.optional(),
         externalResponseSessionId: ExecutionIdSchema.optional(),
         answerStream: z.boolean().optional(),
         attachments: z.array(ExecutionAttachmentSchema).max(20).optional(),

package/dist/execution-runner.js

@@ -13,6 +13,7 @@ import { executionBackendCapability } from "./execution-backend.js";
 import { readBoundImDecisionFile, resetBoundImDecisionFile } from "./bound-im-decision.js";
 import { RuntimeCancelledError } from "./runtime-cancellation.js";
 import { supervisorLaunch } from "./supervised-runtime.js";
+import { appendAgentMemoryContext } from "./agent-memory/policy.js";
 export { supervisorLaunch } from "./supervised-runtime.js";
 const ACTIVITY_KIND = {
     init: "working",
@@ -217,18 +218,26 @@ function admission(spec, config, dependencies, at) {
     }
     if (!Number.isInteger(dependencies.facts.activeForAgent)
         || !Number.isInteger(dependencies.facts.queuedForAgent)
+        || !Number.isInteger(dependencies.facts.activeTotal)
+        || !Number.isInteger(dependencies.facts.queuedTotal)
         || dependencies.facts.activeForAgent < 0
-        || dependencies.facts.queuedForAgent < 0) {
+        || dependencies.facts.queuedForAgent < 0
+        || dependencies.facts.activeTotal < 0
+        || dependencies.facts.queuedTotal < 0) {
         return { rejected: rejection(spec.executionId, "invalid_spec", "Invalid local resource facts", at) };
     }
+    const agentAtCapacity = dependencies.facts.activeForAgent >= config.executionLimits.maxParallelPerAgent;
+    const machineAtCapacity = dependencies.facts.activeTotal >= config.executionLimits.maxParallelTotal;
     const slotInvalid = dependencies.slot?.state === "ready"
-        ? dependencies.facts.activeForAgent >= config.executionLimits.maxParallelPerAgent
+        ? agentAtCapacity || machineAtCapacity
         : dependencies.slot?.state === "queued"
-            ? dependencies.facts.activeForAgent < config.executionLimits.maxParallelPerAgent
-                || dependencies.facts.queuedForAgent >= config.executionLimits.maxQueuedPerAgent
+            ? dependencies.facts.queuedForAgent >= config.executionLimits.maxQueuedPerAgent
+                || dependencies.facts.queuedTotal >= config.executionLimits.maxQueuedTotal
             : false;
-    if (slotInvalid || (dependencies.slot === undefined && (dependencies.facts.activeForAgent >= config.executionLimits.maxParallelPerAgent
-        || dependencies.facts.queuedForAgent >= config.executionLimits.maxQueuedPerAgent))) {
+    if (slotInvalid || (dependencies.slot === undefined && (agentAtCapacity
+        || machineAtCapacity
+        || dependencies.facts.queuedForAgent >= config.executionLimits.maxQueuedPerAgent
+        || dependencies.facts.queuedTotal >= config.executionLimits.maxQueuedTotal))) {
         return { rejected: rejection(spec.executionId, "resource_limit", "Local execution capacity is exhausted", at) };
     }
     const permission = effectivePermission(spec, config);
@@ -306,12 +315,12 @@ export async function runExecution(config, input, dependencies) {
             effectivePermission: replayPermission,
             at: replay.acceptedAt,
         }), config.executionLimits.maxEventBytes), bestEffortTimeoutMs);
-        if (replay.state === "running" && replay.processStartedAt !== null) {
+        if (replay.state === "running" && replay.runtimeReadyAt !== null) {
             await reportBestEffort(dependencies.report, boundExecutionFrame(DaemonToServerExecutionFrameSchema.parse({
                 type: "execution:started",
                 protocolVersion: 1,
                 executionId: spec.executionId,
-                at: replay.processStartedAt,
+                at: replay.runtimeReadyAt,
             }), config.executionLimits.maxEventBytes), bestEffortTimeoutMs);
         }
         return { kind: "existing", entry: replay };
@@ -344,12 +353,12 @@ export async function runExecution(config, input, dependencies) {
             effectivePermission: accepted.effectivePermission ?? permission,
             at: accepted.acceptedAt,
         }), config.executionLimits.maxEventBytes), bestEffortTimeoutMs);
-        if (accepted.state === "running" && accepted.processStartedAt !== null) {
+        if (accepted.state === "running" && accepted.runtimeReadyAt !== null) {
             await reportBestEffort(dependencies.report, boundExecutionFrame(DaemonToServerExecutionFrameSchema.parse({
                 type: "execution:started",
                 protocolVersion: 1,
                 executionId: spec.executionId,
-                at: accepted.processStartedAt,
+                at: accepted.runtimeReadyAt,
             }), config.executionLimits.maxEventBytes), bestEffortTimeoutMs);
         }
         return { kind: "existing", entry: accepted };
@@ -376,9 +385,11 @@ export async function runExecution(config, input, dependencies) {
         await Promise.all([...launchAttempts]);
     };
     let startedAt = accepted.acceptedAt;
+    let runtimeCancel = null;
     let timeout;
     let timedOut = false;
     let completion;
+    let memoryCaptureFinalText = null;
     let boundImDecision = spec.reporting.allowBoundImDecision
         ? "silent"
         : undefined;
@@ -390,12 +401,49 @@ export async function runExecution(config, input, dependencies) {
         if (dependencies.slot !== undefined) {
             await cancellable(dependencies.slot.ready, dependencies.cancellation);
         }
+        let recalledMemory = "";
+        if (spec.agent.memoryEnabled === true && dependencies.agentMemory !== undefined) {
+            try {
+                recalledMemory = await cancellable(dependencies.agentMemory.recall(spec.agent.handle, spec.instructions.wakePrompt), dependencies.cancellation);
+            }
+            catch (error) {
+                if (error instanceof ExecutionCancelledError)
+                    throw error;
+            }
+        }
         const credential = await cancellable(mint(config.serverUrl, config.machineToken, spec.agent.handle, undefined, { executionId: spec.executionId, agentRunId: spec.executionId }), dependencies.cancellation);
         const providerConfig = launchProviderConfig(credential.config);
         let activitySequence = 0;
         let consoleSequence = 0;
         let externalOutputSequence = 0;
         const callbacks = {
+            onRuntimeReady: 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()) {
+                    timeout = setTimeout(() => {
+                        timedOut = true;
+                        try {
+                            void cancel().catch(rejectCancellationFailure);
+                        }
+                        catch (error) {
+                            rejectCancellationFailure(error);
+                        }
+                    }, effectiveTimeoutMs);
+                }
+            },
             ...(spec.reporting.streamActivity ? {
                 onActivity: (activity) => {
                     const frame = DaemonToServerExecutionFrameSchema.parse({
@@ -453,6 +501,10 @@ export async function runExecution(config, input, dependencies) {
         };
         const localDependencies = {
             ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }),
+            ...(dependencies.startupGate === undefined ? {} : { startupGate: dependencies.startupGate }),
+            ...(dependencies.startupTimeoutMs === undefined
+                ? {}
+                : { startupTimeoutMs: dependencies.startupTimeoutMs }),
             launchRuntime: async (request) => {
                 if (launchClosed || dependencies.cancellation?.isRequested())
                     throw new ExecutionCancelledError();
@@ -463,7 +515,7 @@ export async function runExecution(config, input, dependencies) {
                     const processStartedAt = now().toISOString();
                     const launchControl = { cancel: null };
                     const guarded = await dependencies.journal.startGuarded(spec.executionId, processStartedAt, () => startSupervisor(supervisorLaunch(request)), {
-                        beforeRelease: ({ entry, handle, abort }) => {
+                        beforeRelease: ({ handle, abort }) => {
                             supervisorState.active = handle;
                             let stopPromise = null;
                             let releaseStarted = false;
@@ -481,7 +533,6 @@ export async function runExecution(config, input, dependencies) {
                             launchControl.cancel = () => stopOnce(releaseStarted ? handle.cancel : abort);
                             supervisorState.abortOnce = () => stopOnce(abort);
                             dependencies.cancellation?.register(launchControl.cancel);
-                            startedAt = entry.processStartedAt ?? processStartedAt;
                             if (dependencies.cancellation?.isRequested()) {
                                 return dependencies.cancellation.waitForStop().then(() => {
                                     throw new ExecutionCancelledError();
@@ -497,23 +548,7 @@ export async function runExecution(config, input, dependencies) {
                         throw new Error("Execution launch cancellation gate was not installed");
                     }
                     const installedCancel = launchControl.cancel;
-                    await reportBestEffort(dependencies.report, boundExecutionFrame(DaemonToServerExecutionFrameSchema.parse({
-                        type: "execution:started",
-                        protocolVersion: 1,
-                        executionId: spec.executionId,
-                        at: startedAt,
-                    }), config.executionLimits.maxEventBytes), bestEffortTimeoutMs);
-                    if (!dependencies.cancellation?.isRequested()) {
-                        timeout = setTimeout(() => {
-                            timedOut = true;
-                            try {
-                                void installedCancel().catch(rejectCancellationFailure);
-                            }
-                            catch (error) {
-                                rejectCancellationFailure(error);
-                            }
-                        }, effectiveTimeoutMs);
-                    }
+                    runtimeCancel = installedCancel;
                     return { ...guarded.handle, cancel: installedCancel };
                 }
                 finally {
@@ -522,6 +557,12 @@ export async function runExecution(config, input, dependencies) {
                 }
             },
         };
+        const systemPromptBudget = config.executionLimits.maxPromptBytes
+            - Buffer.byteLength(spec.instructions.wakePrompt, "utf8");
+        const systemPromptWithLocalFacts = withLocalExecutionFacts(spec.instructions.systemPrompt, systemPromptBudget);
+        const boundedSystemPrompt = (context) => appendAgentMemoryContext(typeof systemPromptWithLocalFacts === "string"
+            ? systemPromptWithLocalFacts
+            : systemPromptWithLocalFacts(context), recalledMemory, systemPromptBudget);
         const localInput = {
             executionId: spec.executionId,
             handle: spec.agent.handle,
@@ -531,8 +572,7 @@ export async function runExecution(config, input, dependencies) {
             ...(spec.workspace.resumeKey === undefined ? {} : { resumeKey: spec.workspace.resumeKey }),
             ...(spec.context.wakeMessageId === undefined ? {} : { wakeMessageId: spec.context.wakeMessageId }),
             ...(spec.context.attachments === undefined ? {} : { attachments: spec.context.attachments }),
-            systemPrompt: withLocalExecutionFacts(spec.instructions.systemPrompt, config.executionLimits.maxPromptBytes
-                - Buffer.byteLength(spec.instructions.wakePrompt, "utf8")),
+            systemPrompt: boundedSystemPrompt,
             wakePrompt: spec.instructions.wakePrompt,
             runtime: {
                 name: spec.runtime.name,
@@ -570,6 +610,8 @@ export async function runExecution(config, input, dependencies) {
         if (timeout !== undefined)
             clearTimeout(timeout);
         const finishedAt = now().toISOString();
+        if (result.exitCode === 0 && result.finalText?.trim())
+            memoryCaptureFinalText = result.finalText;
         if (spec.reporting.allowBoundImDecision) {
             const path = join(result.workspaceRunDir, `.bound-im-decision-${spec.executionId}.json`);
             const selected = await readBoundImDecision(path);
@@ -654,6 +696,17 @@ export async function runExecution(config, input, dependencies) {
     completion = boundExecutionFrame(completion, config.executionLimits.maxEventBytes);
     await telemetry.closeAndDrain();
     await dependencies.journal.complete(spec.executionId, completion);
+    if (completion.outcome === "succeeded"
+        && spec.agent.memoryEnabled === true
+        && memoryCaptureFinalText !== null
+        && dependencies.agentMemory !== undefined) {
+        try {
+            await dependencies.agentMemory.capture(spec.agent.handle, spec.executionId, spec.instructions.wakePrompt, memoryCaptureFinalText);
+        }
+        catch {
+            // External memory is optional and must never alter the durable execution outcome.
+        }
+    }
     await dependencies.report(completion);
     return { kind: "completed", frame: completion };
 }

package/dist/host-execution-coordinator.js

@@ -0,0 +1,241 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+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";
+const HOST_EXECUTION_SLOT_COUNT = 4;
+const HOST_STARTUP_GAP_MS = 3_000;
+const RETRY_MS = 50;
+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.
+    return resolve(userHome, ".crew", "daemon", "compute-execution");
+}
+async function syncDirectory(path) {
+    if (process.platform === "win32")
+        return;
+    const handle = await open(path, "r");
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function leaseFor(directory) {
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const lease = createJournalLease({
+        directory,
+        currentPid: process.pid,
+        captureCurrentIdentity: async () => {
+            const identity = await defaultProcessController.inspectIdentity(process.pid);
+            if (identity === null)
+                throw new Error("current process identity is absent");
+            return identity;
+        },
+        inspectIdentity: (pid) => defaultProcessController.inspectIdentity(pid),
+        syncDirectory,
+        // A separate registry is intentional: reservations in one process must
+        // compete for the same slot instead of attaching to one re-entrant lease.
+        registry: createJournalLeaseRegistry(),
+    });
+    try {
+        await lease.acquire();
+        return lease;
+    }
+    catch (error) {
+        if (error instanceof JournalLockedError)
+            return null;
+        throw error;
+    }
+}
+function reservation(prerequisite, acquire) {
+    let released = false;
+    let granted = false;
+    let owned = null;
+    let releasePromise = null;
+    let cancelPrerequisite;
+    const prerequisiteCancelled = new Promise((resolveCancelled) => {
+        cancelPrerequisite = () => resolveCancelled(false);
+    });
+    const acquisition = Promise.race([
+        prerequisite.then(() => true),
+        prerequisiteCancelled,
+    ]).then(async (shouldAcquire) => {
+        if (!shouldAcquire)
+            return null;
+        const lease = await acquire(() => released);
+        if (lease === null)
+            return null;
+        if (released) {
+            await lease.close();
+            return null;
+        }
+        owned = lease;
+        granted = true;
+        return lease;
+    });
+    const neverReady = new Promise(() => { });
+    const ready = acquisition.then((lease) => lease === null ? neverReady : undefined);
+    void ready.catch(() => undefined);
+    return {
+        ready,
+        isQueued: () => !granted && !released,
+        release: () => {
+            if (releasePromise !== null)
+                return releasePromise;
+            released = true;
+            cancelPrerequisite();
+            releasePromise = acquisition.then(async () => { if (owned !== null)
+                await owned.close(); });
+            void releasePromise.catch(() => undefined);
+            return releasePromise;
+        },
+    };
+}
+async function writeLaunchTimestamp(path, value) {
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, `${value}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        await rename(temporary, path);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+export function createHostExecutionCoordinator(options = {}) {
+    const root = resolve(options.root ?? defaultHostExecutionCoordinatorRoot());
+    const executionSlots = options.executionSlots ?? HOST_EXECUTION_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 pendingReleases = new Set();
+    if (!Number.isSafeInteger(executionSlots) || executionSlots <= 0) {
+        throw new RangeError("executionSlots 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) => {
+        let offset = 0;
+        while (!released()) {
+            for (let step = 0; step < executionSlots; step += 1) {
+                const slot = (offset + step) % executionSlots;
+                const lease = await leaseFor(join(root, "slots", String(slot)));
+                if (lease !== null)
+                    return lease;
+            }
+            offset = (offset + 1) % executionSlots;
+            await wait(retryMs);
+        }
+        return null;
+    };
+    const acquireStartup = async (released) => {
+        while (!released()) {
+            const directory = join(root, "startup");
+            const lease = await leaseFor(directory);
+            if (lease === null) {
+                await wait(retryMs);
+                continue;
+            }
+            const timestampPath = join(directory, "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")) {
+                    await lease.close();
+                    throw error;
+                }
+            }
+            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;
+        }
+        return null;
+    };
+    const tracked = (entry) => {
+        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));
+                return trackedRelease;
+            },
+        };
+    };
+    return {
+        reserveExecution: (prerequisite) => tracked(reservation(prerequisite, acquireExecution)),
+        reserveStartup: (prerequisite) => tracked(reservation(prerequisite, acquireStartup)),
+        drain: async () => {
+            while (pendingReleases.size > 0)
+                await Promise.all([...pendingReleases]);
+        },
+    };
+}
+export function hostCoordinatedSlotManager(local, host) {
+    return {
+        reserve: (handle, kind) => {
+            const localReservation = local.reserve(handle, kind);
+            if (!localReservation.accepted)
+                return localReservation;
+            const hostReservation = host.reserveExecution(localReservation.ready);
+            let released = false;
+            return {
+                ...localReservation,
+                // File ownership is asynchronous, so accepted work is conservatively
+                // reported queued until it owns both its local and host-wide slot.
+                state: "queued",
+                ready: hostReservation.ready,
+                isQueued: hostReservation.isQueued,
+                release: () => {
+                    if (released)
+                        return;
+                    released = true;
+                    void hostReservation.release();
+                    localReservation.release();
+                },
+            };
+        },
+        snapshot: local.snapshot,
+    };
+}
+export function hostCoordinatedStartupGate(local, host) {
+    return {
+        reserve: (runtime) => {
+            const localReservation = local.reserve(runtime);
+            const hostReservation = host.reserveStartup(localReservation.ready);
+            let released = false;
+            return {
+                ready: hostReservation.ready,
+                isQueued: hostReservation.isQueued,
+                release: () => {
+                    if (released)
+                        return;
+                    released = true;
+                    void hostReservation.release();
+                    localReservation.release();
+                },
+            };
+        },
+        snapshot: local.snapshot,
+    };
+}

package/dist/local-executor.js

@@ -16,6 +16,8 @@ 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 { dslog } from "./slog.js";
 function truncateUtf8(value, maxBytes) {
     if (maxBytes <= 0)
         return "";
@@ -198,6 +200,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     }), dependencies.cancellation);
     let materialized = null;
     let knownAttachmentDirectory = null;
+    let startupReservation = null;
     try {
         if (isDeepSeekCodex && !providerConfig.providerApiKey) {
             throw new Error("DeepSeek API key is not configured for this Agent");
@@ -263,8 +266,13 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const attachmentPlan = routeRuntimeAttachments(runtime.name, materialized?.attachments ?? []);
         const wakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
         await awaitWithCancellation(writeFile(workspace.systemPromptPath, systemPrompt, "utf8"), dependencies.cancellation);
+        const inheritedEnv = { ...process.env };
+        for (const key of Object.keys(inheritedEnv)) {
+            if (key.startsWith("CREW_AGENT_MEMORY_"))
+                delete inheritedEnv[key];
+        }
         const baseEnv = {
-            ...process.env,
+            ...inheritedEnv,
             ...sanitizeEnvVars(providerConfig.envVars),
             ...input.launch.systemEnv,
             PATH: `${workspace.crewDir}${delimiter}${augmentedPath()}`,
@@ -288,6 +296,28 @@ 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();
         const child = await launchRuntime({
             runtime: runtime.name,
             bin: runtime.name,
@@ -321,11 +351,30 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const externalOutput = new ExternalAnswerDecoder();
         // 每轮独立:tool_use/result 关联状态不能跨 execution 泄漏。
         const consoleFormatter = createConsoleFormatter();
+        let runtimeReady = false;
+        let resolveRuntimeReady;
+        const runtimeReadySignal = new Promise((resolve) => { resolveRuntimeReady = resolve; });
+        let runtimeReadyNotification = Promise.resolve();
+        const markRuntimeReady = () => {
+            if (runtimeReady)
+                return;
+            runtimeReady = true;
+            startupReservation?.release();
+            dslog("runtime.start_ready", "runtime 已完成初始化", {
+                execution_id: input.executionId,
+                runtime: runtime.name,
+                startup_ms: Date.now() - runtimeLaunchAt,
+            });
+            runtimeReadyNotification = Promise.resolve(callbacks.onRuntimeReady?.(runtime.name));
+            resolveRuntimeReady();
+        };
         const readline = createInterface({ input: child.stdout });
         readline.on("line", (line) => {
             const event = parseLine(line);
             if (!event)
                 return;
+            if (isRuntimeReadyEvent(runtime.name, event))
+                markRuntimeReady();
             const meta = extractRunMeta(event);
             if (meta.sessionId)
                 sessionId = meta.sessionId;
@@ -358,6 +407,39 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         });
         let runtimeExit;
         try {
+            if (startupReservation !== null) {
+                let startupTimer;
+                let startupOutcome;
+                try {
+                    startupOutcome = await awaitWithCancellation(Promise.race([
+                        runtimeReadySignal.then(() => ({ kind: "ready" })),
+                        child.exit.then((exit) => ({ kind: "exit", exit })),
+                        new Promise((resolve) => {
+                            startupTimer = setTimeout(() => resolve({ kind: "timeout" }), dependencies.startupTimeoutMs ?? 60_000);
+                        }),
+                    ]), dependencies.cancellation);
+                }
+                finally {
+                    if (startupTimer !== undefined)
+                        clearTimeout(startupTimer);
+                }
+                if (startupOutcome.kind !== "ready") {
+                    if (startupOutcome.kind === "timeout") {
+                        dslog("runtime.start_timeout", "runtime 启动超时", {
+                            level: "ERROR",
+                            execution_id: input.executionId,
+                            runtime: runtime.name,
+                            startup_timeout_ms: dependencies.startupTimeoutMs ?? 60_000,
+                        });
+                        await child.cancel?.();
+                    }
+                    startupReservation.release();
+                    throw new Error(startupOutcome.kind === "timeout"
+                        ? `${runtime.name} startup timed out`
+                        : `${runtime.name} exited before signaling ready (exit ${startupOutcome.exit.exitCode})`);
+                }
+                await runtimeReadyNotification;
+            }
             runtimeExit = await awaitWithCancellation(child.exit, dependencies.cancellation);
         }
         catch (error) {
@@ -415,6 +497,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         };
     }
     finally {
+        startupReservation?.release();
         const attachmentDirectories = new Set([
             ...(knownAttachmentDirectory === null ? [] : [knownAttachmentDirectory]),
             ...(materialized === null ? [] : [materialized.directory]),

package/dist/machine-info.js

@@ -25,6 +25,8 @@ export const DAEMON_CAPABILITIES = [
     "execution_external_output_v1",
     "execution_attachments_v1",
     "execution_answer_stream_v1",
+    "execution_machine_queue_v1",
+    "execution_agent_memory_policy_v1",
 ];
 export const EXECUTION_PROTOCOL = Object.freeze({ min: 1, max: 1 });
 /** 候选 runtime CLI:展示名 → 可执行文件名。 */
@@ -117,7 +119,21 @@ export async function collectMachineHello(agentsRoot, executionLimits, runtimePl
         capabilities: DAEMON_CAPABILITIES,
         ...(backend.supported ? {
             executionProtocol: EXECUTION_PROTOCOL,
-            executionLimits: Object.freeze({ ...executionLimits }),
+            executionLimits: Object.freeze({
+                maxPromptBytes: executionLimits.maxPromptBytes,
+                maxTimeoutMs: executionLimits.maxTimeoutMs,
+                maxEventBytes: executionLimits.maxEventBytes,
+                maxParallelPerAgent: executionLimits.maxParallelPerAgent,
+                maxQueuedPerAgent: executionLimits.maxQueuedPerAgent,
+            }),
+            executionScheduler: Object.freeze({
+                maxParallelTotal: executionLimits.maxParallelTotal,
+                maxQueuedTotal: executionLimits.maxQueuedTotal,
+                maxStartingTotal: executionLimits.maxStartingTotal,
+                maxStartingPerRuntime: executionLimits.maxStartingPerRuntime,
+                startupGapMs: executionLimits.startupGapMs,
+                startupTimeoutMs: executionLimits.startupTimeoutMs,
+            }),
         } : {}),
         agentHandles,
     };

package/dist/runner.js

@@ -106,6 +106,10 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
     }, { onActivity, onConsole }, {
         launchRuntime: dependencies.launchRuntime ?? ((request) => launchSupervisedRuntime(request, dependencies.startSupervisor, dependencies.cancellation, dependencies.platform)),
         ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }),
+        ...(dependencies.startupGate === undefined ? {} : { startupGate: dependencies.startupGate }),
+        ...(dependencies.startupTimeoutMs === undefined
+            ? {}
+            : { startupTimeoutMs: dependencies.startupTimeoutMs }),
     });
     const activities = [...local.activities];
     if (!input.scheduled && (runtime === "codex" || runtime === "kimi")