@11agents/cli 0.1.7 → 0.1.9

package/README.md

@@ -27,7 +27,7 @@ export ELEVENAGENTS_SERVER="http://localhost:8082"
 
 On startup, the CLI prints its current version and target server to stderr. It also checks npm for a newer `@11agents/cli` package and prints an upgrade command when one is available.
 
-Project-scoped MCP and knowledge-base sync tokens can be stored in `~/.11agents/credentials`:
+Project-scoped MCP, knowledge-base sync, and database sync tokens can be stored in `~/.11agents/credentials`:
 
 ```yaml
 # tokens:
@@ -35,7 +35,24 @@ flatkey: gtm_xxxxxxxxxxxxxxxxxxxx
 voc-ai: gtm_yyyyyyyyyyyyyyyyyyyy
 ```
 
-When syncing a project knowledge base, the CLI chooses tokens in this order: explicit tool/command token, matching project token from `~/.11agents/credentials`, `GTM_SWARM_TOKEN`, then the daemon control token as a compatibility fallback.
+When syncing project data, the CLI chooses tokens in this order: explicit tool/command token, matching project token from `~/.11agents/credentials`, `GTM_SWARM_TOKEN`, then the daemon control token as a compatibility fallback.
+
+For runtime tasks, token lookup tries the cloud `workspace.slug`, cloud `workspace.name`, `--project`, and `--workspace`. Use the project slug when you know it; adding the display name is also safe when the slug/name differ:
+
+```yaml
+# tokens:
+flatkey-prod: gtm_xxxxxxxxxxxxxxxxxxxx
+Flat Key: gtm_xxxxxxxxxxxxxxxxxxxx
+```
+
+The credentials file must live under the same `HOME` used by the daemon process. If the daemon is launched by a service manager or SSH session under a different user, confirm with `11agents daemon status` and check that user has the file at `~/.11agents/credentials`. After changing credentials or upgrading the CLI, restart the daemon:
+
+```bash
+npm install -g @11agents/cli@latest
+11agents --version
+11agents daemon stop
+11agents daemon start --background
+```
 
 ## Runtime Pool
 

package/package.json

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

package/src/commands/runtime.js

@@ -106,6 +106,27 @@ async function runWithDaemonRetry(label, operation, deps, retryState) {
   }
 }
 
+async function runWithTaskRetry(label, operation, deps, { maxAttempts = 3 } = {}) {
+  let failures = 0
+  while (true) {
+    try {
+      return await operation()
+    } catch (error) {
+      failures += 1
+      if (failures >= maxAttempts) throw error
+      const delay = retryDelayMs(failures)
+      deps.log(JSON.stringify({
+        retrying: label,
+        error: errorMessage(error),
+        consecutive_failures: failures,
+        max_attempts: maxAttempts,
+        next_retry_ms: delay,
+      }, null, 2))
+      await deps.sleep(delay)
+    }
+  }
+}
+
 export async function scanRuntime(flags = {}) {
   const scan = await buildRuntimeScan({ env: scanEnvWithOverrides(flags), cliVersion: CLI_VERSION })
   console.log(JSON.stringify(scan, null, 2))
@@ -183,7 +204,7 @@ async function syncRuntimeProjectMetadataBestEffort(flags, deps) {
 
 function normalizeTaskCompletion(task, completion) {
   const result = completion && typeof completion === 'object' ? completion : {}
-  return {
+  const body = {
     task_id: task.id,
     runtime_id: task.runtime_id,
     machine_key: task.runtime?.machine_key || '',
@@ -191,6 +212,26 @@ function normalizeTaskCompletion(task, completion) {
     memory_delta: String(result.memory_delta || result.memoryDelta || ''),
     status: result.status ? String(result.status) : null,
   }
+  if (result.knowledge_snapshot || result.knowledgeSnapshot) {
+    body.knowledge_snapshot = result.knowledge_snapshot || result.knowledgeSnapshot
+  }
+  return body
+}
+
+function extractJsonObject(text) {
+  const source = String(text || '').trim()
+  if (!source) return null
+  const fenced = source.match(/```(?:json)?\s*([\s\S]*?)```/i)
+  const candidates = fenced ? [fenced[1].trim(), source] : [source]
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate)
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed
+    } catch {
+      // Try the next representation.
+    }
+  }
+  return null
 }
 
 async function loadTaskHandler(handlerPath, deps) {
@@ -272,6 +313,16 @@ async function projectSyncToken(project, flags = {}, deps = {}) {
   })
 }
 
+function projectTokenCandidatesForTask(task, flags = {}) {
+  return [
+    task.workspace?.slug,
+    task.workspace?.name,
+    task.workspace_slug,
+    flag(flags, 'project'),
+    flag(flags, 'workspace'),
+  ].filter(Boolean)
+}
+
 async function writeFileIfMissing(filePath, content) {
   try {
     await writeFile(filePath, content, { flag: 'wx' })
@@ -447,7 +498,7 @@ async function syncDatabaseIfNeeded({ task, workdir, config, flags, deps }) {
   if (!spec.syncRequired && localRevision === spec.cloudRevision) return { synced: false, cloud_revision: localRevision }
 
   const project = projectSlugForTask(task)
-  const token = await projectSyncToken(project, flags, deps)
+  const token = await projectSyncToken(projectTokenCandidatesForTask(task, flags), flags, deps)
   const syncConfig = { ...config, token }
   const result = await deps.requestJson(`/api/projects/${project}/database/sync`, {
     method: 'POST',
@@ -561,24 +612,18 @@ function buildCodexPrompt(task) {
         source_url: deepOrganize.source_url,
         source_type: deepOrganize.source_type || (deepOrganize.source_url.includes('github.com') ? 'github' : 'url'),
         output_dir: task.execution_context?.workdir ? `${task.execution_context.workdir}/knowledge_base` : './knowledge_base',
-        callback: 'After organizing files, call the 11agents MCP knowledge_sync tool with mode=push so cloud receives the finished wiki.',
+        callback: 'Prefer the 11agents MCP knowledge_sync tool with mode=push. If MCP/local writes are unavailable, include a knowledge_snapshot object in the final task completion JSON so the platform writes cloud knowledge during task completion.',
       }),
       '',
-      'Build the knowledge base using the standard llms.txt / LLM Wiki pattern popularized for LLM-readable documentation:',
-      '- Create or update ./knowledge_base/llms.txt with one H1 project title, a blockquote summary, concise context, and H2 sections containing Markdown links to the most important files.',
-      '- Create or update ./knowledge_base/llms-full.txt as a fuller single-file context pack when useful.',
-      '- Create or update ./knowledge_base/README.md, ./knowledge_base/index.md, and ./knowledge_base/CLAUDE.md as the human entry point, node map, and agent operating guide.',
-      '- Treat the finished result as an agent skill graph like a strong hand-built knowledge base: every durable file should tell the next agent exactly when to read it and how to act on it.',
-      '- Do not stop at project-profile.md / knowledge-map.md placeholders. Create concrete markdown files with actionable content.',
-      '- For product, website, or business sources, use semantic folders such as information/, voice/, audience/, marketing/, product-design/, resources/, and decisions/. Create files like information/what-we-do/product-overview.md, voice/brand-voice.md, audience/README.md, and marketing/README.md when the source supports them.',
-      '- For GitHub sources, use semantic folders such as codebase/, architecture/, api/, operations/, examples/, resources/, and agent-playbook/. Create files like codebase/README.md, architecture/overview.md, operations/setup.md, api/README.md, and examples/README.md when the repo supports them.',
-      '- README.md should include a "Where to Start" table and a directory overview.',
-      '- index.md should include Identity, Node Map, and Execution Instructions sections with wiki-style references to important files.',
-      '- CLAUDE.md should include the exact read order and output/update rules for runtime agents.',
-      '- If source_type is github, inspect README, docs, package manifests, examples, and source tree. Prefer concise durable explanations over raw dumps.',
-      '- If source_type is url, read the page and prefer /llms.txt or /llms-full.txt from that origin when available.',
-      '- Keep file paths stable and descriptive. Do not write temporary research into the durable wiki.',
-      '- When done, use MCP to push the local knowledge_base back to cloud.',
+      'Build the knowledge base using https://github.com/lewislulu/llm-wiki-skill:',
+      '- Install or inspect llm-wiki-skill when possible, then follow its compile/ingest/query/lint/audit workflow.',
+      '- Use MCP knowledge_sync mode=pull first when available so existing cloud knowledge is included.',
+      '- Use MCP knowledge_sync mode=push after organizing when available.',
+      '- If shell, apply_patch, local file writes, skill installation, or MCP push are unavailable, still produce the organized result as a knowledge_snapshot in the task completion payload.',
+      '- knowledge_snapshot must contain nodes and edges arrays compatible with 11agents knowledge sync. Each node should include id, kind, title, body, and local_path.',
+      '- When using the built-in Codex worker, finish with a JSON object or fenced ```json block containing comment, memory_delta, status, and knowledge_snapshot.',
+      '- Do not report blocked only because shell, apply_patch, local file writes, or MCP push are unavailable. Report blocked only if source research and a structured knowledge_snapshot are also impossible.',
+      '- Preserve useful existing knowledge, remove duplication, and make the wiki directly usable by future runtime agents.',
     ].join('\n') : '',
     '',
     'Work in this repository and make the needed changes. When finished, respond with a concise summary for the task thread.',
@@ -620,6 +665,17 @@ async function runCodex({ task, prompt, flags = {}, deps }) {
       status: 'failed',
     }
   }
+  if (knowledgeDeepOrganizeSpec(task)) {
+    const structured = extractJsonObject(output)
+    if (structured?.knowledge_snapshot || structured?.knowledgeSnapshot) {
+      return {
+        ...structured,
+        comment: String(structured.comment || structured.summary || output || `Codex completed task ${task.id}.`),
+        memory_delta: String(structured.memory_delta || structured.memoryDelta || `Codex completed task ${task.id}.`),
+        status: structured.status ? String(structured.status) : 'in_review',
+      }
+    }
+  }
   return {
     comment: output || `Codex completed task ${task.id}.`,
     memory_delta: `Codex completed task ${task.id}.`,
@@ -677,51 +733,86 @@ async function claimAndRunRuntimeTasks(registration, flags, deps, handlerModule,
     }
 
     deps.log(JSON.stringify({ claimed: runtimeTask.id, runtime_id: runtime.id }, null, 2))
+    let completion = null
+    let executionContext = null
     if (runtimeTask.workspace?.slug) {
-      const token = await projectSyncToken(runtimeTask.workspace.slug, flags, deps)
+      const token = await projectSyncToken(projectTokenCandidatesForTask(runtimeTask, flags), flags, deps)
       const syncConfig = { ...config, token }
-      await runWithDaemonRetry('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, retryState)
+      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',
+        }
+      }
     }
-    const executionContext = await prepareRuntimeTask(runtimeTask, flags, deps, config)
-    runtimeTask.execution_context = executionContext
-    let completion
-    try {
-      completion = await handlerModule.handleRuntimeTask(runtimeTask)
-    } catch (error) {
-      completion = {
-        comment: error instanceof Error ? error.message : String(error),
-        status: 'failed',
+    if (!completion) {
+      executionContext = await prepareRuntimeTask(runtimeTask, flags, deps, config)
+      runtimeTask.execution_context = executionContext
+      try {
+        completion = await handlerModule.handleRuntimeTask(runtimeTask)
+      } catch (error) {
+        completion = {
+          comment: error instanceof Error ? error.message : String(error),
+          status: 'failed',
+        }
+      } finally {
+        await rm(executionContext.tmp_dir, { recursive: true, force: true })
       }
-    } finally {
-      await rm(executionContext.tmp_dir, { recursive: true, force: true })
     }
-    await appendTaskMemoryDelta({ task: runtimeTask, completion, workdir: executionContext.workdir })
+    if (executionContext) {
+      await appendTaskMemoryDelta({ task: runtimeTask, completion, workdir: executionContext.workdir })
+    }
 
-    if (runtimeTask.workspace?.slug) {
-      const syncBack = knowledgeDeepOrganizeSpec(runtimeTask) ? deps.mcpKnowledgeSync : deps.syncKnowledge
-      const token = await projectSyncToken(runtimeTask.workspace.slug, flags, deps)
+    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 }
-      await runWithDaemonRetry('sync knowledge base back to cloud', () => (
-        syncBack({
-          project: runtimeTask.workspace.slug,
-          mode: 'push',
-          server: flags.server,
-          token,
-        }, {
-          requestJson: (apiPath, options = {}) => deps.requestJson(apiPath, { ...options, config: syncConfig }),
-          log: () => {},
-        })
-      ), deps, retryState)
+      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)

package/src/credentials.js

@@ -63,8 +63,11 @@ export async function resolveProjectToken(project, {
   if (token) return token
 
   const credentials = await readCredentials({ homeDir })
-  const projectToken = credentials.tokens[slugify(project)]
-  if (projectToken) return projectToken
+  const projects = Array.isArray(project) ? project : [project]
+  for (const candidate of projects) {
+    const projectToken = credentials.tokens[slugify(candidate)]
+    if (projectToken) return projectToken
+  }
 
   return env.GTM_SWARM_TOKEN || fallbackToken || ''
 }