@11agents/cli 0.1.18 → 0.1.20

package/README.md

@@ -125,17 +125,29 @@ export async function handleRuntimeTask(task) {
 }
 ```
 
-## MCP Project Sync Server
-
-Run the local MCP server over stdio:
-
-```bash
-11agents mcp start
+## Hosted MCP
+
+Runtime agents and MCP clients should use the hosted project MCP endpoint:
+
+```json
+{
+  "mcpServers": {
+    "11agents-project-sync": {
+      "url": "https://app.11agents.ai/mcp",
+      "transport": "streamable-http",
+      "headers": {
+        "Authorization": "Bearer $PROJECT_SWARM_TOKEN"
+      }
+    }
+  }
+}
 ```
 
-Configure your MCP client to run that command. The server automatically reads matching project tokens from `~/.11agents/credentials`; a tool-call token can still be passed explicitly when needed. The server exposes:
+The hosted server exposes project-scoped tools such as:
 
 - `knowledge_sync` — pull/push the project knowledge base between cloud and `~/.11agents/<project>/knowledge_base/`.
+- `database_sync` — pull/push the cloud project database snapshot.
+- `agent_planning` — list, import, generate, and dispatch agent calendar work.
 
 ## Telemetry Compatibility
 

package/bin/11agents.js

@@ -21,13 +21,12 @@ Usage:
   11agents -v | --version
   11agents runtime scan
   11agents runtime register [--server <url>] [--token <token>] [--machine <key>]
-  11agents daemon start [--server <url>] [--token <token>] [--machine <key>] [--task-interval <seconds>] [--project-refresh-interval <seconds>] [--background]
+  11agents daemon start [--server <url>] [--token <token>] [--machine <key>] [--concurrency <n>] [--task-interval <seconds>] [--project-refresh-interval <seconds>] [--background]
   11agents daemon status
   11agents daemon stop
   11agents daemon start --handler ./worker.js  # optional custom worker override
   11agents logs daemon [--tail 200]
   11agents logs task <task-id> [--project <slug>] [--tail 120]
-  11agents mcp start
   11agents validate <file>
   11agents push batch <file>
   11agents push artifact --workspace <slug> --agent <key> --platform x --type post --external-id <id>
@@ -42,7 +41,7 @@ Environment:
   GTM_WRITES_TOKEN     control-plane token for runtime registration
   ELEVENAGENTS_MACHINE stable machine key, defaults to hostname
   GTM_SWARM_TOKEN      project swarm token for push/node commands
-  ~/.11agents/credentials project token map for MCP knowledge sync
+  ~/.11agents/credentials project token map for hosted MCP and sync commands
 
 Runtime task workspace:
   Daemon project headquarters live under ~/.11agents/<project>/.
@@ -99,6 +98,7 @@ async function main() {
       console.log(`log: ${result.logPath}`)
       return
     }
+    if (flags.concurrency === undefined) flags.concurrency = '3'
     await startRuntimeDaemon(flags)
     return
   }

package/package.json

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

package/src/commands/runtime.js

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process'
 import { createHash } from 'node:crypto'
 import { appendFileSync, readFileSync } from 'node:fs'
-import { appendFile, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { appendFile, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises'
 import os from 'node:os'
 import { dirname, resolve } from 'node:path'
 import path from 'node:path'
@@ -86,27 +86,49 @@ function runtimeDeps(overrides = {}) {
   }
 }
 
-function currentClaimPath(homeDir) {
+function legacyClaimPath(homeDir) {
   return path.join(homeDir, '.11agents', 'claim_id')
 }
 
+function claimsDirPath(homeDir) {
+  return path.join(homeDir, '.11agents', 'claims')
+}
+
+function claimFilePath(homeDir, taskId) {
+  return path.join(claimsDirPath(homeDir), `${sanitizeTaskId(taskId)}.json`)
+}
+
 async function writeCurrentClaim(deps, task, machineKey) {
   const payload = {
     task_id: String(task.id || ''),
     runtime_id: String(task.runtime_id || task.runtime?.id || ''),
     machine_key: String(task.runtime?.machine_key || machineKey || ''),
   }
-  await mkdir(path.dirname(currentClaimPath(deps.homeDir)), { recursive: true })
-  await writeFile(currentClaimPath(deps.homeDir), JSON.stringify(payload))
+  await mkdir(claimsDirPath(deps.homeDir), { recursive: true })
+  await writeFile(claimFilePath(deps.homeDir, task.id), JSON.stringify(payload))
   return payload
 }
 
-async function readCurrentClaim(deps) {
-  return readJsonFile(currentClaimPath(deps.homeDir), null)
+async function clearCurrentClaim(deps, taskId) {
+  await rm(claimFilePath(deps.homeDir, taskId), { force: true })
 }
 
-async function clearCurrentClaim(deps) {
-  await rm(currentClaimPath(deps.homeDir), { force: true })
+async function readAllCurrentClaims(deps) {
+  const claims = []
+  // Backward compat: consume legacy single-claim file
+  const legacy = await readJsonFile(legacyClaimPath(deps.homeDir), null)
+  if (legacy?.task_id && legacy?.runtime_id) {
+    claims.push({ ...legacy, _path: legacyClaimPath(deps.homeDir) })
+  }
+  // Per-task claim files
+  const entries = await readdir(claimsDirPath(deps.homeDir)).catch(err => (err?.code === 'ENOENT' ? [] : Promise.reject(err)))
+  for (const entry of entries) {
+    if (!entry.endsWith('.json')) continue
+    const filePath = path.join(claimsDirPath(deps.homeDir), entry)
+    const claim = await readJsonFile(filePath, null)
+    if (claim?.task_id && claim?.runtime_id) claims.push({ ...claim, _path: filePath })
+  }
+  return claims
 }
 
 function errorMessage(error) {
@@ -339,15 +361,20 @@ function codexAssistantTextFromJsonl(text) {
   return messages.join('\n\n')
 }
 
-async function failPersistedCurrentClaim(flags, deps, comment) {
-  const claim = await readCurrentClaim(deps)
-  if (!claim?.task_id || !claim?.runtime_id) return false
-  await deps.requestJson('/api/runtime/tasks/complete', {
-    method: 'POST',
-    body: failedClaimCompletionBody(claim, comment),
-    config: configFromFlags(flags),
-  })
-  await clearCurrentClaim(deps)
+async function failAllPersistedClaims(flags, deps, comment) {
+  const claims = await readAllCurrentClaims(deps)
+  if (!claims.length) return false
+  const config = configFromFlags(flags)
+  for (const claim of claims) {
+    try {
+      await deps.requestJson('/api/runtime/tasks/complete', {
+        method: 'POST',
+        body: failedClaimCompletionBody(claim, comment),
+        config,
+      })
+    } catch {}
+    await rm(claim._path, { force: true })
+  }
   return true
 }
 
@@ -357,14 +384,14 @@ function installCurrentClaimExitHandlers(flags, deps) {
     if (shuttingDown) return
     shuttingDown = true
     try {
-      await failPersistedCurrentClaim(
+      await failAllPersistedClaims(
         flags,
         deps,
         `Runtime task failed locally: daemon received ${signal} before the claimed task completed.`
       )
     } catch (error) {
       deps.log(JSON.stringify({
-        warning: 'failed to mark current claimed task failed during daemon shutdown',
+        warning: 'failed to mark current claimed tasks failed during daemon shutdown',
         signal,
         error: errorMessage(error),
       }, null, 2))
@@ -908,8 +935,8 @@ async function prepareRuntimeTask(task, flags, deps, config) {
   const database = await syncDatabaseIfNeeded({ task, workdir, config, flags, deps })
   const skills = await materializeSkillsIfChanged({ task, workdir, flags, deps })
 
-  // Resolve and inject the project token so MCP subprocesses (e.g. `11agents mcp start`)
-  // spawned by the runtime agent can authenticate without needing credentials on disk.
+  // Resolve and inject the project token so hosted MCP calls spawned by the
+  // runtime agent can authenticate without needing credentials on disk.
   const projectToken = await projectSyncToken(projectTokenCandidatesForTask(task, flags), flags, deps)
   const env = {
     ...process.env,
@@ -1228,156 +1255,160 @@ function defaultTaskHandler(flags, deps) {
   }
 }
 
-async function claimAndRunRuntimeTasks(registration, flags, deps, handlerModule, retryState = createRetryState(), heartbeatIntervalMs = 15000) {
-  if (!handlerModule) return 0
-  const config = configFromFlags(flags)
-  const machineKey = registration?.machine?.machine_key || machineOverride(flags) || ''
-  let handled = 0
-
-  for (const runtime of registration?.runtimes || []) {
-    if (!runtime?.id) continue
-    const claim = await runWithDaemonRetry('claim runtime task', () => (
-      deps.requestJson('/api/runtime/tasks/claim', {
-        method: 'POST',
-        body: {
-          runtime_id: runtime.id,
-          machine_key: machineKey,
-        },
-        config,
-      })
-    ), deps, retryState)
-    const task = claim?.task
-    if (!task) continue
-
-    const runtimeTask = {
-      ...task,
-      runtime_id: task.runtime_id || runtime.id,
-      runtime: {
-        provider: runtime.provider,
-        model: runtime.model || '',
-        ...(task.runtime || {}),
-        id: task.runtime?.id || runtime.id,
-        machine_key: task.runtime?.machine_key || machineKey,
+async function runOneRuntimeTaskSlot(runtime, config, machineKey, registration, flags, deps, handlerModule, retryState, heartbeatIntervalMs) {
+  const claim = await runWithDaemonRetry('claim runtime task', () => (
+    deps.requestJson('/api/runtime/tasks/claim', {
+      method: 'POST',
+      body: {
+        runtime_id: runtime.id,
+        machine_key: machineKey,
       },
+      config,
+    })
+  ), deps, retryState)
+  const task = claim?.task
+  if (!task) return false
+
+  const runtimeTask = {
+    ...task,
+    runtime_id: task.runtime_id || runtime.id,
+    runtime: {
+      provider: runtime.provider,
+      model: runtime.model || '',
+      ...(task.runtime || {}),
+      id: task.runtime?.id || runtime.id,
+      machine_key: task.runtime?.machine_key || machineKey,
+    },
+  }
+
+  deps.log(JSON.stringify({ claimed: runtimeTask.id, runtime_id: runtime.id }, null, 2))
+  await writeCurrentClaim(deps, runtimeTask, machineKey)
+  let completion = null
+  let executionContext = null
+  if (runtimeTask.workspace?.slug) {
+    const token = await projectSyncToken(projectTokenCandidatesForTask(runtimeTask, flags), flags, deps)
+    const syncConfig = { ...config, token }
+    try {
+      await runWithTaskRetry('sync knowledge base', () => (
+        deps.syncKnowledge({
+          project: runtimeTask.workspace.slug,
+          mode: 'pull',
+          server: flags.server,
+          token,
+        }, {
+          requestJson: (apiPath, options = {}) => deps.requestJson(apiPath, { ...options, config: syncConfig }),
+          log: () => {},
+        })
+      ), deps)
+    } catch (error) {
+      completion = {
+        comment: `Knowledge sync pull failed before task execution: ${errorMessage(error)}`,
+        status: 'failed',
+      }
+    }
+  }
+  if (!completion) {
+    executionContext = await prepareRuntimeTask(runtimeTask, flags, deps, config)
+    runtimeTask.execution_context = executionContext
+    await updateRunMeta(executionContext.run_dir, {
+      task_id: String(runtimeTask.id || ''),
+      runtime_id: String(runtimeTask.runtime_id || ''),
+      provider: runtimeTask.runtime?.provider || runtime.provider || '',
+      project_slug: executionContext.project_slug,
+      agent: agentNameForTask(runtimeTask),
+      issue_title: runtimeTask.issue?.title || '',
+      started_at: new Date().toISOString(),
+    })
+    try {
+      completion = await runWithRuntimeHeartbeat(
+        () => handlerModule.handleRuntimeTask(runtimeTask),
+        registration,
+        flags,
+        deps,
+        heartbeatIntervalMs
+      )
+    } catch (error) {
+      completion = {
+        comment: error instanceof Error ? error.message : String(error),
+        status: 'failed',
+      }
+    } finally {
+      await rm(executionContext.tmp_dir, { recursive: true, force: true })
     }
+  }
+  if (executionContext) {
+    await writeRunFile(executionContext.run_dir, 'completion.json', JSON.stringify(normalizeTaskCompletion(runtimeTask, completion), null, 2))
+    await updateRunMeta(executionContext.run_dir, { ended_at: new Date().toISOString() })
+  }
+  if (executionContext) {
+    await appendTaskMemoryDelta({ task: runtimeTask, completion, workdir: executionContext.workdir })
+  }
 
-    deps.log(JSON.stringify({ claimed: runtimeTask.id, runtime_id: runtime.id }, null, 2))
-    await writeCurrentClaim(deps, runtimeTask, machineKey)
-    let completion = null
-    let executionContext = null
-    if (runtimeTask.workspace?.slug) {
-      const token = await projectSyncToken(projectTokenCandidatesForTask(runtimeTask, flags), flags, deps)
-      const syncConfig = { ...config, token }
+  if (executionContext && runtimeTask.workspace?.slug) {
+    const isDeepOrganize = Boolean(knowledgeDeepOrganizeSpec(runtimeTask))
+    const syncBack = isDeepOrganize ? deps.mcpKnowledgeSync : deps.syncKnowledge
+    const token = await projectSyncToken(projectTokenCandidatesForTask(runtimeTask, flags), flags, deps)
+    const syncConfig = { ...config, token }
+    const pushKnowledge = () => syncBack({
+      project: runtimeTask.workspace.slug,
+      mode: 'push',
+      server: flags.server,
+      token,
+    }, {
+      requestJson: (apiPath, options = {}) => deps.requestJson(apiPath, { ...options, config: syncConfig }),
+      log: () => {},
+    })
+    if (isDeepOrganize) {
       try {
-        await runWithTaskRetry('sync knowledge base', () => (
-          deps.syncKnowledge({
-            project: runtimeTask.workspace.slug,
-            mode: 'pull',
-            server: flags.server,
-            token,
-          }, {
-            requestJson: (apiPath, options = {}) => deps.requestJson(apiPath, { ...options, config: syncConfig }),
-            log: () => {},
-          })
-        ), deps)
+        await pushKnowledge()
       } catch (error) {
+        const message = `Knowledge sync push failed before task completion: ${errorMessage(error)}. If a knowledge_snapshot is included in completion, the platform will write it directly.`
         completion = {
-          comment: `Knowledge sync pull failed before task execution: ${errorMessage(error)}`,
-          status: 'failed',
+          ...(completion && typeof completion === 'object' ? completion : {}),
+          comment: [String(completion?.comment || completion?.summary || '').trim(), message].filter(Boolean).join('\n\n'),
+          memory_delta: [String(completion?.memory_delta || completion?.memoryDelta || '').trim(), message].filter(Boolean).join('\n'),
         }
       }
-    }
-    if (!completion) {
-      executionContext = await prepareRuntimeTask(runtimeTask, flags, deps, config)
-      runtimeTask.execution_context = executionContext
-      await updateRunMeta(executionContext.run_dir, {
-        task_id: String(runtimeTask.id || ''),
-        runtime_id: String(runtimeTask.runtime_id || ''),
-        provider: runtimeTask.runtime?.provider || runtime.provider || '',
-        project_slug: executionContext.project_slug,
-        agent: agentNameForTask(runtimeTask),
-        issue_title: runtimeTask.issue?.title || '',
-        started_at: new Date().toISOString(),
-      })
+    } else {
       try {
-        completion = await runWithRuntimeHeartbeat(
-          () => handlerModule.handleRuntimeTask(runtimeTask),
-          registration,
-          flags,
-          deps,
-          heartbeatIntervalMs
-        )
+        await runWithTaskRetry('sync knowledge base back to cloud', pushKnowledge, deps)
       } catch (error) {
+        const message = `Knowledge sync push failed before task completion: ${errorMessage(error)}`
         completion = {
-          comment: error instanceof Error ? error.message : String(error),
+          ...(completion && typeof completion === 'object' ? completion : {}),
+          comment: [String(completion?.comment || completion?.summary || '').trim(), message].filter(Boolean).join('\n\n'),
+          memory_delta: [String(completion?.memory_delta || completion?.memoryDelta || '').trim(), message].filter(Boolean).join('\n'),
           status: 'failed',
         }
-      } finally {
-        await rm(executionContext.tmp_dir, { recursive: true, force: true })
       }
     }
-    if (executionContext) {
-      await writeRunFile(executionContext.run_dir, 'completion.json', JSON.stringify(normalizeTaskCompletion(runtimeTask, completion), null, 2))
-      await updateRunMeta(executionContext.run_dir, { ended_at: new Date().toISOString() })
-    }
-    if (executionContext) {
-      await appendTaskMemoryDelta({ task: runtimeTask, completion, workdir: executionContext.workdir })
-    }
+  }
 
-    if (executionContext && runtimeTask.workspace?.slug) {
-      const isDeepOrganize = Boolean(knowledgeDeepOrganizeSpec(runtimeTask))
-      const syncBack = isDeepOrganize ? deps.mcpKnowledgeSync : deps.syncKnowledge
-      const token = await projectSyncToken(projectTokenCandidatesForTask(runtimeTask, flags), flags, deps)
-      const syncConfig = { ...config, token }
-      const pushKnowledge = () => syncBack({
-        project: runtimeTask.workspace.slug,
-        mode: 'push',
-        server: flags.server,
-        token,
-      }, {
-        requestJson: (apiPath, options = {}) => deps.requestJson(apiPath, { ...options, config: syncConfig }),
-        log: () => {},
-      })
-      if (isDeepOrganize) {
-        try {
-          await pushKnowledge()
-        } catch (error) {
-          const message = `Knowledge sync push failed before task completion: ${errorMessage(error)}. If a knowledge_snapshot is included in completion, the platform will write it directly.`
-          completion = {
-            ...(completion && typeof completion === 'object' ? completion : {}),
-            comment: [String(completion?.comment || completion?.summary || '').trim(), message].filter(Boolean).join('\n\n'),
-            memory_delta: [String(completion?.memory_delta || completion?.memoryDelta || '').trim(), message].filter(Boolean).join('\n'),
-          }
-        }
-      } else {
-        try {
-          await runWithTaskRetry('sync knowledge base back to cloud', pushKnowledge, deps)
-        } catch (error) {
-          const message = `Knowledge sync push failed before task completion: ${errorMessage(error)}`
-          completion = {
-            ...(completion && typeof completion === 'object' ? completion : {}),
-            comment: [String(completion?.comment || completion?.summary || '').trim(), message].filter(Boolean).join('\n\n'),
-            memory_delta: [String(completion?.memory_delta || completion?.memoryDelta || '').trim(), message].filter(Boolean).join('\n'),
-            status: 'failed',
-          }
-        }
-      }
-    }
+  const body = normalizeTaskCompletion(runtimeTask, completion)
+  const result = await runWithDaemonRetry('complete runtime task', () => (
+    deps.requestJson('/api/runtime/tasks/complete', {
+      method: 'POST',
+      body,
+      config,
+    })
+  ), deps, retryState)
+  await clearCurrentClaim(deps, runtimeTask.id)
+  deps.log(JSON.stringify(result, null, 2))
+  return true
+}
 
-    const body = normalizeTaskCompletion(runtimeTask, completion)
-    const result = await runWithDaemonRetry('complete runtime task', () => (
-      deps.requestJson('/api/runtime/tasks/complete', {
-        method: 'POST',
-        body,
-        config,
-      })
-    ), deps, retryState)
-    await clearCurrentClaim(deps)
-    deps.log(JSON.stringify(result, null, 2))
-    handled += 1
-  }
+async function claimAndRunRuntimeTasks(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) || ''
 
-  return handled
+  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))
+  )
+  return results.filter(r => r.status === 'fulfilled' && r.value === true).length
 }
 
 export async function startRuntimeDaemon(flags = {}, deps = {}) {
@@ -1386,6 +1417,7 @@ 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 maxConcurrent = Math.max(1, Number(flag(flags, 'concurrency', '1')) || 1)
   const once = Boolean(flags.once)
   const handlerPath = flag(flags, 'handler')
 
@@ -1407,13 +1439,13 @@ export async function startRuntimeDaemon(flags = {}, deps = {}) {
   const uninstallExitHandlers = installCurrentClaimExitHandlers(flags, resolvedDeps)
   try {
     let registration = await runWithDaemonRetry('register runtime', () => registerRuntime(flags, resolvedDeps), resolvedDeps, retryState)
-    await runWithDaemonRetry('recover current claimed task', () => failPersistedCurrentClaim(
+    await runWithDaemonRetry('recover current claimed task', () => failAllPersistedClaims(
       flags,
       resolvedDeps,
       'Runtime task failed locally: daemon restarted with a persisted claimed task that had not completed.'
     ), resolvedDeps, retryState)
     await syncRuntimeProjectMetadataBestEffort(flags, resolvedDeps)
-    await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs)
+    await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs, maxConcurrent)
     if (once) return
 
     let lastScan = Date.now()
@@ -1432,7 +1464,7 @@ export async function startRuntimeDaemon(flags = {}, deps = {}) {
         lastHeartbeat = now
       }
       if (now - lastTaskPoll >= taskIntervalMs) {
-        await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs)
+        await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs, maxConcurrent)
         lastTaskPoll = now
       }
       if (now - lastProjectRefresh >= projectRefreshIntervalMs) {
@@ -1442,7 +1474,7 @@ export async function startRuntimeDaemon(flags = {}, deps = {}) {
     }
   } catch (error) {
     try {
-      await failPersistedCurrentClaim(
+      await failAllPersistedClaims(
         flags,
         resolvedDeps,
         `Runtime task failed locally: daemon exited with error before the claimed task completed: ${errorMessage(error)}`