@nowcrew/daemon 0.6.14 → 0.6.15

package/README.md

@@ -371,9 +371,10 @@ CREW_RUNTIME_SAFE=1
 CREW_EXECUTION_MAX_PROMPT_BYTES=256000
 CREW_EXECUTION_MAX_TIMEOUT_MS=10800000
 CREW_EXECUTION_MAX_EVENT_BYTES=64000
-CREW_MAX_PARALLEL=4
+CREW_MAX_PARALLEL=10
+CREW_SCHEDULED_MAX_PARALLEL=4
 CREW_EXECUTION_MAX_QUEUED_PER_AGENT=32
-CREW_EXECUTION_MAX_PARALLEL_TOTAL=4
+CREW_EXECUTION_MAX_PARALLEL_TOTAL=10
 CREW_EXECUTION_MAX_QUEUED_TOTAL=128
 CREW_EXECUTION_MAX_STARTING_TOTAL=1
 CREW_EXECUTION_MAX_STARTING_PER_RUNTIME=1
@@ -381,7 +382,9 @@ CREW_EXECUTION_START_GAP_MS=3000
 CREW_EXECUTION_STARTUP_TIMEOUT_MS=120000
 ```
 
-`MAX_PARALLEL_TOTAL` is the machine-wide process cap shared by protocol-v1 and legacy work.
+`CREW_MAX_PARALLEL` limits normal executions per Agent. `CREW_SCHEDULED_MAX_PARALLEL` separately
+limits scheduled executions per Agent. `MAX_PARALLEL_TOTAL` is the machine-wide process cap shared by
+protocol-v1 and legacy work.
 Runtime startup is a separate FIFO gate: by default only one Claude, Codex, or Kimi process may be
 initializing at a time, and launches are spaced by three seconds. A process leaves the startup gate
 only after its runtime-specific ready event; startup timeout cancels the owned process tree.

package/dist/config.js

@@ -10,9 +10,10 @@ export const DEFAULT_EXECUTION_LIMITS = Object.freeze({
     maxPromptBytes: 256_000,
     maxTimeoutMs: 3 * 60 * 60_000,
     maxEventBytes: 64_000,
-    maxParallelPerAgent: 4,
+    maxParallelPerAgent: 10,
+    maxParallelScheduledPerAgent: 4,
     maxQueuedPerAgent: 32,
-    maxParallelTotal: 4,
+    maxParallelTotal: 10,
     maxQueuedTotal: 128,
     maxStartingTotal: 1,
     maxStartingPerRuntime: 1,
@@ -68,6 +69,7 @@ export function loadConfig(env = process.env) {
         maxTimeoutMs: integerEnvAtMost(env, "CREW_EXECUTION_MAX_TIMEOUT_MS", DEFAULT_EXECUTION_LIMITS.maxTimeoutMs, MAX_EXECUTION_TIMEOUT_MS),
         maxEventBytes: integerEnvAtLeast(env, "CREW_EXECUTION_MAX_EVENT_BYTES", DEFAULT_EXECUTION_LIMITS.maxEventBytes, MIN_EXECUTION_EVENT_BYTES),
         maxParallelPerAgent: positiveIntegerEnv(env, "CREW_MAX_PARALLEL", DEFAULT_EXECUTION_LIMITS.maxParallelPerAgent),
+        maxParallelScheduledPerAgent: positiveIntegerEnv(env, "CREW_SCHEDULED_MAX_PARALLEL", DEFAULT_EXECUTION_LIMITS.maxParallelScheduledPerAgent),
         maxQueuedPerAgent: positiveIntegerEnv(env, "CREW_EXECUTION_MAX_QUEUED_PER_AGENT", DEFAULT_EXECUTION_LIMITS.maxQueuedPerAgent),
         maxParallelTotal: positiveIntegerEnv(env, "CREW_EXECUTION_MAX_PARALLEL_TOTAL", DEFAULT_EXECUTION_LIMITS.maxParallelTotal),
         maxQueuedTotal: positiveIntegerEnv(env, "CREW_EXECUTION_MAX_QUEUED_TOTAL", DEFAULT_EXECUTION_LIMITS.maxQueuedTotal),

package/dist/execution-runner.js

@@ -231,7 +231,10 @@ function admission(spec, config, dependencies, at) {
         || 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 maxParallelForAgent = spec.context.scheduledRunId === undefined
+        ? config.executionLimits.maxParallelPerAgent
+        : config.executionLimits.maxParallelScheduledPerAgent;
+    const agentAtCapacity = dependencies.facts.activeForAgent >= maxParallelForAgent;
     const machineAtCapacity = dependencies.facts.activeTotal >= config.executionLimits.maxParallelTotal;
     const slotInvalid = dependencies.slot?.state === "ready"
         ? agentAtCapacity || machineAtCapacity

package/dist/host-execution-coordinator.js

@@ -4,7 +4,7 @@ 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_EXECUTION_SLOT_COUNT = 10;
 const HOST_STARTUP_GAP_MS = 3_000;
 const RETRY_MS = 50;
 export function defaultHostExecutionCoordinatorRoot(userHome = homedir()) {
@@ -215,8 +215,8 @@ export function createHostExecutionCoordinator(options = {}) {
 }
 export function hostCoordinatedSlotManager(local, host) {
     return {
-        reserve: (handle, kind) => {
-            const localReservation = local.reserve(handle, kind);
+        reserve: (handle, kind, executionClass) => {
+            const localReservation = local.reserve(handle, kind, executionClass);
             if (!localReservation.accepted)
                 return localReservation;
             const hostReservation = host.reserveExecution(localReservation.ready);

package/dist/prompt.js

@@ -234,14 +234,14 @@ ${taskAndScheduleCommands}`;
 
 ## 并行与记忆(CRITICAL — 防冲突 + 防上下文膨胀)
 你**可能同时在处理多个任务**(你自己的多个并行进程)。为避免互相覆盖、并保持上下文精简,严格遵守:
-- **普通任务默认只写两处**:① 本任务的隔离 cwd(代码/草稿);② 本任务的工作日志 **\`$CREW_TASK_LOG\`**(每任务一份,别人不会碰)。默认不要修改共享 \`$CREW_HOME/MEMORY.md\` 或 notes/;只有当前用户明确要求更新共享记忆时,才按下方条件写入相关共享文件。在工作日志里记:当前阶段 / 下一步 / 卡在谁 / 关键结论(每条尽量 ≤3 行)。
-- **当前请求明确要求更新记忆,或当前消息是对本线程紧邻记忆方案的无歧义确认时**,可以按最小范围直接写共享记忆;先读取相关索引和 note,语义已存在时不重复追加,不要把 Agent 自己判断值得记住视为用户授权。
+- **普通任务默认只写两处**:① 本任务的隔离 cwd(代码/草稿);② 本任务的工作日志 **\`$CREW_TASK_LOG\`**(每任务一份,别人不会碰)。默认不要修改共享 \`$CREW_HOME/MEMORY.md\` 或 notes/;只有当前用户明确要求更新或记住长期记忆,或明确表达具体且跨后续任务持续生效的规则、偏好或约束时,才按下方条件写入相关共享文件。在工作日志里记:当前阶段 / 下一步 / 卡在谁 / 关键结论(每条尽量 ≤3 行)。
+- **当前请求明确要求更新或记住长期记忆,明确表达需要跨后续任务持续生效的具体规则、偏好或约束,或当前消息是对本线程紧邻记忆方案的无歧义确认时**,可以按最小范围直接写共享记忆。例如“以后所有测试报告统一按五部分写”属于明确长期意图,即使没有使用“记忆”一词。先读取相关索引和 note,语义已存在时不重复追加,不要把 Agent 自己判断值得记住视为用户授权。
 - 本节的直接更新共享记忆和相关 task 流转仅适用于用户消息触发的普通交互执行。memory_prune 和 scheduled 执行只遵守各自唤醒指令,不得依据本节认领、创建、重开或推进 task。
 - 普通交互执行将写共享记忆时,使用当前线程唯一的普通 task:已有非终态 task 时先按归属规则确保当前 Agent 成功认领;当前线程没有 task 时先创建并认领一个普通 task;已有 task 为 done/closed 时不得由 Agent 重开,done 报告当前轻量方案无法安全复用终态 task,closed 保持人工终态。遇到终态或归属问题时报告冲突且不得创建第二个 task 或新的任务类型。完成写入后,只有任务本身的全部工作已完成时才推进终态以触发 prune。
 - 提出共享记忆修改方案并等待用户确认时,该 task 仍有剩余工作,保持 in_review 或其它非终态;收到无歧义确认后再执行写入,并仅在全部工作完成后推进终态。
 - 普通执行直接更新后，仍然保留任务结束后的专门收尾执行,不因已经写过而跳过 prune。
 - 新建 note 必须说明现有分类为何不适用；MEMORY.md 默认只更新 Knowledge Index，不得默认修改 Role、Core Goals 或 Active Context；只有用户明确要求或任务本身就是档案/状态维护时例外。
-- 未明确要求、记忆意图含糊或仅由 Agent 自己判断值得记住时,不直接写共享记忆,也不把含糊内容写成长期记忆候选。含糊表达本身不作为长期记忆候选,但不得因此跳过整个 task 的 memory_prune;任务按正常状态流程完成。收尾只能处理该任务其它符合现有收尾规则的稳定内容,不允许让收尾代替用户补充记忆授权。
+- 仅对本次或当前任务生效的要求不持久化。未明确要求、记忆意图含糊或仅由 Agent 自己判断值得记住时,不直接写共享记忆,也不把含糊内容写成长期记忆候选。例如“以后注意一下”等缺少具体内容或适用范围的表达仍属于含糊意图。含糊表达本身不作为长期记忆候选,但不得因此跳过整个 task 的 memory_prune;任务按正常状态流程完成。收尾只能处理该任务其它符合现有收尾规则的稳定内容,不允许让收尾代替用户补充记忆授权。
 - 若用户明确要求本次不要修改共享记忆,同样不写共享记忆或长期记忆候选。任务尚未完成时,把该禁止要求作为运行状态写入 $CREW_TASK_LOG;该运行状态不是长期记忆候选,后续执行必须保留该状态。若用户之后在同一任务中明确撤销禁止,移除该运行状态并按最新明确授权处理。完成 task 前检查该状态:Agent 可自行改状态时,使用 crew task update <taskId> --status done --skip-memory-prune。CLI 返回状态由 Server 管理时沿用上述 Server 管理任务的安全回退:不重试、不绕过权限;收尾会读取该运行状态并禁止共享记忆写入,但本路径不提供机器级 skip 保证。不要只在回复里声明不修改。
 - **跨任务协调看实时清单**:用 \`crew task list --mine\` 查你当前所有任务及其状态(谁在排队、谁在评审)。例:你一次只能测一个页面时,据此判断"正在测 #1、#2 排队",在 #2 的工作日志里标注"等 #1 完成"。
 - 需要更多背景时再 \`Read $CREW_HOME/notes/<topic>.md\`;不要一次把所有笔记读进上下文。

package/dist/serve.js

@@ -71,7 +71,8 @@ export function serve(config, opts = {}) {
     let detectedExecutionRuntimes = [];
     let runtimeFacts = null;
     const runtimeProbe = createRuntimeProbeCoordinator();
-    const hostCoordinator = opts.execution?.hostCoordinator ?? createHostExecutionCoordinator();
+    const hostCoordinator = opts.execution?.hostCoordinator
+        ?? createHostExecutionCoordinator({ executionSlots: config.executionLimits.maxParallelTotal });
     const localSlots = createSharedSlotManager(config.executionLimits);
     const sharedSlots = hostCoordinatedSlotManager(localSlots, hostCoordinator);
     const runtimeStartupGate = hostCoordinatedStartupGate(createRuntimeStartupGate(config.executionLimits), hostCoordinator);
@@ -496,12 +497,14 @@ export function serve(config, opts = {}) {
                             task_key: spec.workspace.taskKey,
                         });
                     }
-                    const reservation = sharedSlots.reserve(spec.agent.handle, "execution");
+                    const executionClass = spec.context.scheduledRunId === undefined ? "normal" : "scheduled";
+                    const 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({
@@ -517,6 +520,7 @@ export function serve(config, opts = {}) {
                         dslog("execution.machine_queued", "execution 已进入机器队列", {
                             execution_id: spec.executionId,
                             agent_handle: spec.agent.handle,
+                            execution_class: executionClass,
                             ...reservation.facts,
                         });
                     }
@@ -534,6 +538,7 @@ export function serve(config, opts = {}) {
                             ...(activeSameTask > 1 ? { level: "WARN" } : {}),
                             execution_id: spec.executionId,
                             agent_handle: spec.agent.handle,
+                            execution_class: executionClass,
                             task_key: spec.workspace.taskKey,
                             active_same_task: activeSameTask,
                             ...reservation.facts,
@@ -602,6 +607,7 @@ export function serve(config, opts = {}) {
                                     dslog("execution.machine_slot_ready", "execution 获得机器执行名额", {
                                         execution_id: spec.executionId,
                                         agent_handle: spec.agent.handle,
+                                        execution_class: executionClass,
                                         queue_ms: Date.now() - machineQueueEnteredAt,
                                         active_total: snapshot.activeTotal,
                                         queued_total: snapshot.queuedTotal,
@@ -824,7 +830,7 @@ export function serve(config, opts = {}) {
                     }
                 }
                 running.add(key);
-                legacyReservation = sharedSlots.reserve(msg.agentHandle, "legacy");
+                legacyReservation = sharedSlots.reserve(msg.agentHandle, "legacy", scheduled === null ? "normal" : "scheduled");
                 if (legacyReservation.isQueued()) {
                     const snapshot = sharedSlots.snapshot();
                     dslog("run.machine_queued", "legacy run 已进入机器队列", {

package/dist/shared-execution-slots.js

@@ -1,13 +1,18 @@
 export function createSharedSlotManager(limits) {
-    const activeByHandle = new Map();
+    const activeByHandleAndClass = new Map();
     const queue = [];
     let activeTotal = 0;
     let exclusive = false;
     const queuedFor = (handle) => queue.filter((entry) => !entry.released && entry.handle === handle).length;
+    const activeKey = (handle, executionClass) => `${handle}:${executionClass}`;
+    const maxParallelFor = (executionClass) => executionClass === "scheduled"
+        ? limits.maxParallelScheduledPerAgent
+        : limits.maxParallelPerAgent;
     const promote = () => {
         while (activeTotal < limits.maxParallelTotal) {
             const index = queue.findIndex((entry) => !entry.released
-                && (activeByHandle.get(entry.handle) ?? 0) < limits.maxParallelPerAgent);
+                && (activeByHandleAndClass.get(activeKey(entry.handle, entry.executionClass)) ?? 0)
+                    < maxParallelFor(entry.executionClass));
             if (index < 0)
                 return;
             const [next] = queue.splice(index, 1);
@@ -15,13 +20,15 @@ export function createSharedSlotManager(limits) {
                 continue;
             next.promoted = true;
             activeTotal += 1;
-            activeByHandle.set(next.handle, (activeByHandle.get(next.handle) ?? 0) + 1);
+            const key = activeKey(next.handle, next.executionClass);
+            activeByHandleAndClass.set(key, (activeByHandleAndClass.get(key) ?? 0) + 1);
             next.resolve();
         }
     };
     return {
-        reserve: (handle, kind) => {
-            const activeForAgent = activeByHandle.get(handle) ?? 0;
+        reserve: (handle, kind, executionClass = "normal") => {
+            const key = activeKey(handle, executionClass);
+            const activeForAgent = activeByHandleAndClass.get(key) ?? 0;
             const queuedForAgent = queuedFor(handle);
             const facts = {
                 activeForAgent,
@@ -39,7 +46,7 @@ export function createSharedSlotManager(limits) {
                 };
             }
             const canStartImmediately = activeTotal < limits.maxParallelTotal
-                && activeForAgent < limits.maxParallelPerAgent
+                && activeForAgent < maxParallelFor(executionClass)
                 && queue.length === 0;
             if (kind === "execution" && !canStartImmediately && (queuedForAgent >= limits.maxQueuedPerAgent
                 || queue.length >= limits.maxQueuedTotal)) {
@@ -55,6 +62,7 @@ export function createSharedSlotManager(limits) {
             const ready = new Promise((resolve) => { resolveReady = resolve; });
             const entry = {
                 handle,
+                executionClass,
                 released: false,
                 promoted: false,
                 resolve: resolveReady,
@@ -73,11 +81,11 @@ export function createSharedSlotManager(limits) {
                     entry.released = true;
                     if (entry.promoted) {
                         activeTotal = Math.max(0, activeTotal - 1);
-                        const nextForAgent = Math.max(0, (activeByHandle.get(handle) ?? 1) - 1);
+                        const nextForAgent = Math.max(0, (activeByHandleAndClass.get(key) ?? 1) - 1);
                         if (nextForAgent === 0)
-                            activeByHandle.delete(handle);
+                            activeByHandleAndClass.delete(key);
                         else
-                            activeByHandle.set(handle, nextForAgent);
+                            activeByHandleAndClass.set(key, nextForAgent);
                     }
                     else {
                         const index = queue.indexOf(entry);

package/package.json

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