@11agents/cli 0.1.17 → 0.1.19

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.17",
+  "version": "0.1.19",
   "description": "11agents local runtime and telemetry CLI",
   "type": "module",
   "bin": {

package/src/commands/runtime.js

@@ -772,7 +772,15 @@ async function materializeSkillsIfChanged({ task, workdir, flags, deps }) {
   const statePath = path.join(skillsDir, 'skills-state.json')
   const nextHash = stableHash(skills)
   const current = await readJsonFile(statePath, {})
-  if (current.hash === nextHash) return { changed: false, count: skills.length }
+  if (current.hash === nextHash) {
+    const allExist = (await Promise.all(
+      skills.map(skill =>
+        readFile(path.join(skillsDir, slugify(skill.name, 'skill'), 'SKILL.md'), 'utf8')
+          .then(() => true).catch(() => false)
+      )
+    )).every(Boolean)
+    if (allExist) return { changed: false, count: skills.length }
+  }
 
   await mkdir(skillsDir, { recursive: true })
   for (const skill of skills) {
@@ -886,21 +894,31 @@ function agentEnvironment(task) {
 
 async function prepareRuntimeTask(task, flags, deps, config) {
   const workdir = flag(flags, 'codex-workdir') || projectDirForTask(task, flags, deps)
-  const tmpDir = path.join(workdir, 'tmp', sanitizeTaskId(task.id))
+  const agentDir = path.join(workdir, 'agents', slugify(agentNameForTask(task), 'agent'))
+  const agentSkillsDir = path.join(agentDir, 'skills')
+  const agentMemoryDir = path.join(agentDir, 'memory')
+  const agentResultsDir = path.join(agentDir, 'results')
+  const tmpDir = path.join(agentDir, 'tmp', sanitizeTaskId(task.id))
   const runDir = path.join(workdir, 'runs', sanitizeTaskId(task.id))
   await mkdir(tmpDir, { recursive: true })
   await mkdir(runDir, { recursive: true })
+  await mkdir(agentResultsDir, { recursive: true })
+  await mkdir(agentMemoryDir, { recursive: true })
 
   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,
     ...agentEnvironment(task),
     ELEVENAGENTS_PROJECT_DIR: workdir,
+    ELEVENAGENTS_AGENT_DIR: agentDir,
+    ELEVENAGENTS_AGENT_SKILLS_DIR: agentSkillsDir,
+    ELEVENAGENTS_AGENT_MEMORY_DIR: agentMemoryDir,
+    ELEVENAGENTS_AGENT_RESULTS_DIR: agentResultsDir,
     ELEVENAGENTS_TASK_TMP: tmpDir,
     ELEVENAGENTS_TASK_ID: String(task.id || ''),
     ...(projectToken ? { GTM_SWARM_TOKEN: projectToken } : {}),
@@ -908,6 +926,10 @@ async function prepareRuntimeTask(task, flags, deps, config) {
 
   return {
     workdir,
+    agent_dir: agentDir,
+    agent_skills_dir: agentSkillsDir,
+    agent_memory_dir: agentMemoryDir,
+    agent_results_dir: agentResultsDir,
     tmp_dir: tmpDir,
     run_dir: runDir,
     project_slug: projectSlugForTask(task, flags),
@@ -926,13 +948,23 @@ function buildCodexPrompt(task) {
     'Execution workspace:',
     compactJson({
       workdir: task.execution_context?.workdir,
+      agent_skills_dir: task.execution_context?.agent_skills_dir,
+      agent_memory_dir: task.execution_context?.agent_memory_dir,
+      agent_results_dir: task.execution_context?.agent_results_dir,
       tmp_dir: task.execution_context?.tmp_dir,
       project_slug: task.execution_context?.project_slug,
-      knowledge_base: './knowledge_base/',
-      rule: 'Treat the project directory as read-only project context except ./knowledge_base/ for durable project knowledge updates and ./tmp/<taskId>/ for temporary scratch files.',
-      cleanup: 'Temporary files under ./tmp/<taskId>/ are removed by the CLI after the task finishes.',
+      knowledge_base: task.execution_context?.workdir ? path.join(task.execution_context.workdir, 'knowledge_base') : './knowledge_base',
     }),
     '',
+    'Directory rules — follow strictly:',
+    '1. agent_skills_dir: BEFORE starting work, list files here to see which skills are installed.',
+    '   Each skill is a subdirectory with a SKILL.md. If a skill you need is present, read its SKILL.md and follow it.',
+    '2. agent_results_dir: Write all final deliverables and task outputs here (generated content, reports, files).',
+    '3. agent_memory_dir: After completing work, record key decisions, facts, and learned context here.',
+    '   Append to index.qmd or create new .qmd files. This memory persists across future task runs.',
+    '4. tmp_dir: Scratch/working files only. This directory is deleted by the CLI after the task finishes — do NOT put deliverables here.',
+    '5. workdir: Treat as read-only project context except for the four agent directories and knowledge_base above.',
+    '',
     'Task context:',
     compactJson({
       queue_event: task.queue_event,
@@ -1196,156 +1228,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)
+  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 = {}) {
@@ -1354,6 +1390,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')
 
@@ -1381,7 +1418,7 @@ export async function startRuntimeDaemon(flags = {}, deps = {}) {
       '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()
@@ -1400,7 +1437,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) {