@nowcrew/daemon 0.6.11 → 0.6.13

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/agent-ability/materializer.js

@@ -440,8 +440,6 @@ const materializeWorkspaceTraining = async (agentsRoot, handle, ability) => {
             for (const mount of mounts) {
                 const sources = verified.files.filter((file) => file.path.endsWith(".md")
                     && (file.path === mount.path || file.path.startsWith(`${mount.path}/`)));
-                if (sources.length === 0)
-                    throw new Error(`ability_memory_mount_empty:${mount.path}`);
                 for (const source of sources) {
                     const relativePath = source.path === mount.path
                         ? source.path.split("/").at(-1)
@@ -467,7 +465,10 @@ const materializeWorkspaceTraining = async (agentsRoot, handle, ability) => {
                 : join(sourceRoot, asset.source);
             await cp(source, target, { recursive: true, preserveTimestamps: true });
         }
-        const evalPaths = [verified.manifest.spec.evals.policy, ...verified.manifest.spec.evals.cases];
+        const evalPaths = [
+            ...(verified.manifest.spec.evals.policy === undefined ? [] : [verified.manifest.spec.evals.policy]),
+            ...verified.manifest.spec.evals.cases,
+        ];
         for (const path of evalPaths) {
             const target = join(staging, "evals", layerRelativePath(path, "evals"));
             await mkdir(dirname(target), { recursive: true });

package/dist/agent-ability/resolver.js

@@ -253,9 +253,19 @@ const scan = (files, manifest) => {
         if (executable.has(extname(file.path).toLowerCase()))
             findings.push({ code: "executable_asset", path: file.path });
     }
-    const required = new Set(["instructions", "memory-policy", "memory-seed", "workspace", "eval-policy", "eval-cases"]);
+    const required = new Set(["instructions"]);
     if (manifest.spec.skills.length > 0)
         required.add("skills");
+    if (manifest.spec.memory.policy.length > 0)
+        required.add("memory-policy");
+    if (manifest.spec.memory.seeds.length > 0)
+        required.add("memory-seed");
+    if (manifest.spec.workspace.assets.length > 0)
+        required.add("workspace");
+    if (manifest.spec.evals.policy !== undefined)
+        required.add("eval-policy");
+    if (manifest.spec.evals.cases.length > 0)
+        required.add("eval-cases");
     return { findings, required };
 };
 const lockedManifestPaths = (manifest) => [
@@ -264,7 +274,7 @@ const lockedManifestPaths = (manifest) => [
     ...manifest.spec.memory.policy.map((entry) => entry.path),
     ...manifest.spec.memory.seeds.map((entry) => entry.path),
     ...manifest.spec.workspace.assets.map((entry) => entry.source),
-    manifest.spec.evals.policy,
+    ...(manifest.spec.evals.policy === undefined ? [] : [manifest.spec.evals.policy]),
     ...manifest.spec.evals.cases,
 ];
 export const evaluateAbilityCases = (files, manifest, lock, memory) => {
@@ -367,7 +377,7 @@ export async function resolveAbilityRelease(agentsRoot, command) {
     const assertions = [
         { name: "manifest_lock_verified", passed: true },
         { name: "manifest_asset_paths_locked", passed: lockedManifestPaths(manifest).every((path) => lockedPaths.has(path)) },
-        { name: "all_five_layers_resolvable", passed: [...security.required].every((kind) => kind === "skills" ? kinds.has(kind) || (manifest.spec.skills.length > 0 && lock.dependencies.length > 0) : kinds.has(kind)) },
+        { name: "declared_layers_resolvable", passed: [...security.required].every((kind) => kind === "skills" ? kinds.has(kind) || (manifest.spec.skills.length > 0 && lock.dependencies.length > 0) : kinds.has(kind)) },
         { name: "dependencies_pinned", passed: lock.dependencies.every((dependency) => /^[a-f0-9]{40}$/u.test(dependency.commit)) },
         { name: "security_scan_clear", passed: security.findings.length === 0 },
         ...evaluateAbilityCases(files, manifest, lock, memory),

package/dist/agent-ability/types.js

@@ -61,16 +61,20 @@ export const DaemonAbilityManifestSchema = z.object({
         skills: z.array(z.object({
             name: z.string().min(1).max(128), source: z.union([LocalSkillSchema, GitSkillSchema]),
             mount: SafeAbilityPathSchema, mode: ModeSchema, trust: z.string().max(128).optional(),
-        }).strict()).max(500),
+        }).strict()).max(500).default([]),
         memory: z.object({
-            policy: z.array(z.object({ path: SafeAbilityPathSchema, mode: ModeSchema, mergeKey: z.string().optional() }).strict()).max(100),
-            seeds: z.array(z.object({ path: SafeAbilityPathSchema, mode: ModeSchema, mergeKey: z.string().optional() }).strict()).max(1_000),
-            runtime: z.object({ store: z.literal("nowcrew-managed"), promotion: z.literal("pull-request"), retentionDays: z.number().int().positive().optional() }).strict(),
-        }).strict(),
+            policy: z.array(z.object({ path: SafeAbilityPathSchema, mode: ModeSchema, mergeKey: z.string().optional() }).strict()).max(100).default([]),
+            seeds: z.array(z.object({ path: SafeAbilityPathSchema, mode: ModeSchema, mergeKey: z.string().optional() }).strict()).max(1_000).default([]),
+            runtime: z.object({ store: z.literal("nowcrew-managed"), promotion: z.literal("pull-request"), retentionDays: z.number().int().positive().optional() }).strict()
+                .default({ store: "nowcrew-managed", promotion: "pull-request" }),
+        }).strict().default({ policy: [], seeds: [], runtime: { store: "nowcrew-managed", promotion: "pull-request" } }),
         workspace: z.object({ assets: z.array(z.object({
                 source: SafeAbilityPathSchema, target: WorkspaceAbilityTargetSchema, mode: ModeSchema,
-            }).strict()).max(1_000) }).strict(),
-        evals: z.object({ policy: SafeAbilityPathSchema, cases: z.array(SafeAbilityPathSchema).min(1).max(1_000) }).strict(),
+            }).strict()).max(1_000).default([]) }).strict().default({ assets: [] }),
+        evals: z.object({
+            policy: SafeAbilityPathSchema.optional(),
+            cases: z.array(SafeAbilityPathSchema).max(1_000).default([]),
+        }).strict().default({ cases: [] }),
         compatibility: z.object({
             providers: z.array(z.enum(["claude", "codex", "kimi", "hermes", "opencode", "deepseek-harness"])).min(1),
             minNowCrewVersion: z.string().regex(/^\d+\.\d+\.\d+$/u),

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/memory-prune-diagnostics.js

@@ -372,6 +372,10 @@ export function evaluateMemoryPrunePostcondition(before, after, execution) {
         outcome = "source_work_log_empty";
     else if (!facts.work_log_cleared)
         outcome = "work_log_not_cleared";
+    else if (!after.memory.exists)
+        outcome = "shared_memory_missing_after";
+    else if ((after.memory.size ?? 0) === 0)
+        outcome = "shared_memory_empty_after";
     else if (facts.lessons_changed && facts.shared_memory_has_lessons_reference) {
         outcome = "promoted_and_indexed";
     }
@@ -381,6 +385,8 @@ export function evaluateMemoryPrunePostcondition(before, after, execution) {
     }
     else if (facts.lessons_changed)
         outcome = "promoted_without_index_change";
+    else if (facts.shared_memory_changed)
+        outcome = "shared_memory_updated";
     else
         outcome = "no_files_changed";
     return { outcome, ...facts };