@11agents/cli 0.1.39 → 0.1.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@11agents/cli",
-  "version": "0.1.39",
+  "version": "0.1.41",
   "description": "11agents local runtime and telemetry CLI",
   "type": "module",
   "bin": {

package/src/commands/runtime.js

@@ -83,7 +83,6 @@ function runtimeDeps(overrides = {}) {
     sleep: overrides.sleep || sleep,
     syncKnowledge: overrides.syncKnowledge || syncKnowledge,
     mcpKnowledgeSync: overrides.mcpKnowledgeSync || mcpKnowledgeSync,
-    cpuCount: overrides.cpuCount ?? os.cpus().length,
   }
 }
 
@@ -248,7 +247,7 @@ export async function scanRuntime(flags = {}) {
   return scan
 }
 
-export async function registerRuntime(flags = {}, deps = {}) {
+export async function registerRuntime(flags = {}, deps = {}, { maxConcurrent } = {}) {
   const { buildRuntimeScan: scanBuilder, log, requestJson: request } = runtimeDeps(deps)
   const config = configFromFlags(flags)
   if (!config.token) throw new Error('GTM_WRITES_TOKEN or --token is required')
@@ -256,9 +255,13 @@ export async function registerRuntime(flags = {}, deps = {}) {
   const scan = await scanBuilder({ env: scanEnvWithOverrides(flags), cliVersion: CLI_VERSION })
   if (!scan.runtimes.length) throw new Error('no local AI runtimes detected on PATH')
 
+  const body = maxConcurrent
+    ? { ...scan, runtimes: scan.runtimes.map(r => ({ ...r, max_concurrent: maxConcurrent })) }
+    : scan
+
   const result = await request('/api/runtime/machines/register', {
     method: 'POST',
-    body: scan,
+    body,
     config,
   })
   log(JSON.stringify(result, null, 2))
@@ -1641,11 +1644,7 @@ async function claimAndRunRuntimeTasks(registration, flags, deps, handlerModule,
   const config = configFromFlags(flags)
   const machineKey = registration?.machine?.machine_key || machineOverride(flags) || ''
 
-  // Each runtime gets (vCPUs - 1) slots so the host stays responsive.
-  // maxConcurrent is honoured when it exceeds the CPU-derived default.
-  const perRuntime = Math.max(1, (deps.cpuCount ?? os.cpus().length) - 1)
-  const effectiveConcurrent = Math.max(maxConcurrent, runtimes.length * perRuntime)
-  const slots = Array.from({ length: effectiveConcurrent }, (_, i) => runtimes[i % runtimes.length])
+  const slots = Array.from({ length: maxConcurrent }, (_, i) => runtimes[i % runtimes.length])
   const results = await Promise.allSettled(
     slots.map(runtime => runOneRuntimeTaskSlot(runtime, config, machineKey, registration, flags, deps, handlerModule, retryState, heartbeatIntervalMs))
   )
@@ -1653,12 +1652,28 @@ async function claimAndRunRuntimeTasks(registration, flags, deps, handlerModule,
 }
 
 async function drainRuntimeTasks(registration, flags, deps, handlerModule, retryState = createRetryState(), heartbeatIntervalMs = 15000, maxConcurrent = 1) {
+  if (!handlerModule) return 0
+  const runtimes = (registration?.runtimes || []).filter(r => r?.id)
+  if (!runtimes.length) return 0
+  const config = configFromFlags(flags)
+  const machineKey = registration?.machine?.machine_key || machineOverride(flags) || ''
+
   let completed = 0
-  while (true) {
-    const claimed = await claimAndRunRuntimeTasks(registration, flags, deps, handlerModule, retryState, heartbeatIntervalMs, maxConcurrent)
-    completed += claimed
-    if (claimed === 0) return completed
-  }
+  // Worker pool: each worker loops claiming tasks until the queue is empty,
+  // so a fast worker immediately picks up the next task without waiting for
+  // slow workers to finish (unlike the old batched Promise.allSettled approach).
+  const workers = Array.from({ length: maxConcurrent }, (_, i) => {
+    const runtime = runtimes[i % runtimes.length]
+    return (async () => {
+      while (true) {
+        const ran = await runOneRuntimeTaskSlot(runtime, config, machineKey, registration, flags, deps, handlerModule, retryState, heartbeatIntervalMs)
+        if (!ran) break
+        completed++
+      }
+    })()
+  })
+  await Promise.allSettled(workers)
+  return completed
 }
 
 export async function startRuntimeDaemon(flags = {}, deps = {}) {
@@ -1667,11 +1682,9 @@ export async function startRuntimeDaemon(flags = {}, deps = {}) {
   const scanIntervalMs = Number(flag(flags, 'scan-interval', '60')) * 1000
   const taskIntervalMs = Number(flag(flags, 'task-interval', flag(flags, 'heartbeat-interval', '15'))) * 1000
   const projectRefreshIntervalMs = Number(flag(flags, 'project-refresh-interval', '1800')) * 1000
-  const cpuCount = resolvedDeps.cpuCount ?? os.cpus().length
-  const cpuDefault = Math.max(1, cpuCount - 1)
   const envMax = Number(process.env.DAEMON_MAX_CONCURRENCY)
-  const envConcurrency = Number.isInteger(envMax) && envMax > 0 && envMax <= cpuCount - 1 ? envMax : null
-  const maxConcurrent = envConcurrency ?? Math.max(1, Number(flag(flags, 'concurrency', String(cpuDefault))) || cpuDefault)
+  const envConcurrency = Number.isInteger(envMax) && envMax > 0 ? envMax : null
+  const maxConcurrent = envConcurrency ?? Math.max(1, Number(flag(flags, 'concurrency', '10')) || 10)
   const once = Boolean(flags.once)
   const handlerPath = flag(flags, 'handler')
 
@@ -1692,7 +1705,7 @@ export async function startRuntimeDaemon(flags = {}, deps = {}) {
   const retryState = createRetryState()
   const uninstallExitHandlers = installCurrentClaimExitHandlers(flags, resolvedDeps)
   try {
-    let registration = await runWithDaemonRetry('register runtime', () => registerRuntime(flags, resolvedDeps), resolvedDeps, retryState)
+    let registration = await runWithDaemonRetry('register runtime', () => registerRuntime(flags, resolvedDeps, { maxConcurrent }), resolvedDeps, retryState)
     await runWithDaemonRetry('recover current claimed task', () => failAllPersistedClaims(
       flags,
       resolvedDeps,