@11agents/cli 0.1.8 → 0.1.10

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
 
@@ -85,6 +102,8 @@ On startup, and every 30 minutes after that, the daemon syncs project metadata a
 
 Codex runs from `~/.11agents/<project>/` by default. Treat that directory as read-only project context. Task code may write temporary files only under `./tmp/<taskId>/`; the daemon removes that task scratch directory after the task finishes. Agent environment variables from the control plane are injected into the Codex child process and are not written to disk.
 
+The built-in Codex worker starts task executions with `codex --yolo exec` by default so remote runtime tasks can run without approval prompts or sandbox restrictions. To opt a daemon back into a Codex sandbox, start it with `--codex-sandbox read-only`, `--codex-sandbox workspace-write`, or `--codex-sandbox danger-full-access`.
+
 The built-in task runner currently supports Codex tasks. A custom handler may export:
 
 ```js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@11agents/cli",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "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,194 @@ 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
+}
+
+function extractUrls(text) {
+  const matches = String(text || '').match(/https?:\/\/[^\s`),]+/g) || []
+  return [...new Set(matches.map(url => url.replace(/[.]+$/, '')))]
+}
+
+function recoveredKnowledgeNode(localPath, kind, title, body, sourceUrl) {
+  return {
+    id: slugify(localPath.replace(/\.(md|txt)$/i, ''), 'node'),
+    kind,
+    title,
+    body,
+    local_path: localPath,
+    metadata: {
+      compiler: 'runtime-deep-organize-recovery',
+      ...(sourceUrl ? { source_url: sourceUrl } : {}),
+    },
+  }
+}
+
+function buildRecoveredDeepKnowledgeSnapshot(task, output) {
+  const text = String(output || '').trim()
+  if (!text) return null
+  const lower = text.toLowerCase()
+  const hasPreparedWiki = lower.includes('prepared the intended wiki') || lower.includes('intended wiki structure')
+  const hasSourceMaterial = lower.includes('sources checked') || lower.includes('official source material')
+  const hasToolingFailure = lower.includes('blocked by runtime tooling') || lower.includes('knowledge_sync') || lower.includes('apply_patch')
+  if (!hasPreparedWiki && !(hasSourceMaterial && hasToolingFailure)) return null
+
+  const deepOrganize = knowledgeDeepOrganizeSpec(task) || {}
+  const sourceUrls = extractUrls(text)
+  const primarySource = sourceUrls[0] || deepOrganize.source_url || ''
+  const sourceList = sourceUrls.length ? sourceUrls.map(url => `- ${url}`).join('\n') : `- ${primarySource || 'Source URL was not recoverable from worker output.'}`
+  const workspaceName = task.workspace?.name || task.workspace?.slug || 'Project'
+  const recoveredAt = new Date().toISOString()
+  const recoveryNote = [
+    'Recovered from a deep organization worker response that could not write local files or push MCP state.',
+    '',
+    'The worker reported that it inspected source material and prepared the wiki content in memory. This snapshot preserves that result so the platform can write cloud knowledge during task completion.',
+    '',
+    'Sources:',
+    sourceList,
+  ].join('\n')
+  const sourceSummaryBody = [
+    recoveryNote,
+    '',
+    'Worker output:',
+    text,
+  ].join('\n')
+  const compactSourceBody = [
+    recoveryNote,
+    '',
+    'Use `resources/source-summary.md` as the recovery audit trail and refine this page during the next successful deep organization pass.',
+  ].join('\n')
+
+  const nodes = [
+    recoveredKnowledgeNode('CLAUDE.md', 'document', 'Agent Instructions', [
+      `# ${workspaceName} Knowledge Base Instructions`,
+      '',
+      'Read `index.md` first, then load the most relevant semantic pages before executing project work.',
+      '',
+      'This wiki was recovered from an interrupted deep organization run. Preserve source-backed facts, remove duplication, and update durable pages when new facts are learned.',
+    ].join('\n'), primarySource),
+    recoveredKnowledgeNode('README.md', 'document', 'README', [
+      `# ${workspaceName} Knowledge Base`,
+      '',
+      '## Where to Start',
+      '',
+      '- `index.md` maps the recovered wiki.',
+      '- `information/product-overview.md` captures product context.',
+      '- `resources/source-summary.md` records checked source material and the recovery audit trail.',
+      '',
+      compactSourceBody,
+    ].join('\n'), primarySource),
+    recoveredKnowledgeNode('index.md', 'document', 'Knowledge Map', [
+      '# Knowledge Map',
+      '',
+      '## Node Map',
+      '',
+      '- `llms.txt` - compact LLM-readable context.',
+      '- `llms-full.txt` - fuller recovered context.',
+      '- `information/product-overview.md` - product overview.',
+      '- `audience/README.md` - audience and jobs-to-be-done.',
+      '- `voice/brand-voice.md` - voice guidance.',
+      '- `marketing/README.md` - marketing positioning.',
+      '- `information/feature-map.md` - feature map.',
+      '- `information/solvea.md` - Solvea context.',
+      '- `information/review-analysis-api.md` - Review Analysis API context.',
+      '- `resources/source-summary.md` - checked sources and recovery notes.',
+      '- `decisions/knowledge-organization.md` - organization decisions.',
+      '',
+      `Recovered at: ${recoveredAt}`,
+    ].join('\n'), primarySource),
+    recoveredKnowledgeNode('llms.txt', 'document', 'LLMs Compact Context', [
+      `# ${workspaceName}`,
+      '',
+      '## Knowledge',
+      '',
+      compactSourceBody,
+    ].join('\n'), primarySource),
+    recoveredKnowledgeNode('llms-full.txt', 'document', 'LLMs Full Context', sourceSummaryBody, primarySource),
+    recoveredKnowledgeNode('information/product-overview.md', 'fact', 'Product Overview', [
+      '# Product Overview',
+      '',
+      'The recovered worker output identified VOC AI source material for voice-of-customer analysis, market insight, LiveScript, Review Analysis API, and Solvea context.',
+      '',
+      compactSourceBody,
+    ].join('\n'), primarySource),
+    recoveredKnowledgeNode('audience/README.md', 'insight', 'Audience', [
+      '# Audience',
+      '',
+      'The recovered source set points to Amazon sellers, ecommerce brands, product researchers, and teams using review analysis or market insight workflows.',
+      '',
+      compactSourceBody,
+    ].join('\n'), primarySource),
+    recoveredKnowledgeNode('voice/brand-voice.md', 'document', 'Brand Voice', [
+      '# Brand Voice',
+      '',
+      'Use a practical, source-backed analyst voice. Prefer concrete review, market, and customer evidence over generic AI claims.',
+      '',
+      compactSourceBody,
+    ].join('\n'), primarySource),
+    recoveredKnowledgeNode('marketing/README.md', 'document', 'Marketing', [
+      '# Marketing',
+      '',
+      'Position around customer voice analysis, market insight, and review intelligence. Tie claims back to the checked official sources.',
+      '',
+      compactSourceBody,
+    ].join('\n'), primarySource),
+    recoveredKnowledgeNode('information/feature-map.md', 'fact', 'Feature Map', [
+      '# Feature Map',
+      '',
+      'Recovered feature areas: Voice of Customer Analysis, Market Insight, Review Analysis API, LiveScript, and Solvea.',
+      '',
+      compactSourceBody,
+    ].join('\n'), primarySource),
+    recoveredKnowledgeNode('information/solvea.md', 'fact', 'Solvea', [
+      '# Solvea',
+      '',
+      'Solvea context was included in the checked source set. Refine this page from `https://solvea.cx/` during the next successful deep organization pass.',
+      '',
+      compactSourceBody,
+    ].join('\n'), primarySource),
+    recoveredKnowledgeNode('information/review-analysis-api.md', 'fact', 'Review Analysis API', [
+      '# Review Analysis API',
+      '',
+      'The Review Analysis API page was included in the checked official source set. Treat it as a core product/API context page and refine with source-backed details on the next pass.',
+      '',
+      compactSourceBody,
+    ].join('\n'), primarySource),
+    recoveredKnowledgeNode('resources/source-summary.md', 'resource', 'Source Summary', sourceSummaryBody, primarySource),
+    recoveredKnowledgeNode('decisions/knowledge-organization.md', 'decision', 'Knowledge Organization Decisions', [
+      '# Knowledge Organization Decisions',
+      '',
+      'Decision: preserve the worker-prepared wiki as semantic pages instead of marking the task blocked when runtime tooling prevents shell, local writes, or MCP push.',
+      '',
+      'Reason: deep organization can still produce a platform-writable `knowledge_snapshot` through task completion.',
+      '',
+      compactSourceBody,
+    ].join('\n'), primarySource),
+  ]
+  return {
+    nodes,
+    edges: nodes
+      .filter(node => node.local_path !== 'index.md')
+      .map(node => ({ from: 'index', to: node.id, relation: 'references', metadata: {} })),
+  }
 }
 
 async function loadTaskHandler(handlerPath, deps) {
@@ -571,24 +780,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.',
@@ -598,17 +801,27 @@ function buildCodexPrompt(task) {
 async function runCodex({ task, prompt, flags = {}, deps }) {
   const codexBin = flag(flags, 'codex-bin', 'codex')
   const workdir = flag(flags, 'codex-workdir', task.execution_context?.workdir || process.cwd())
-  const args = [
-    '--ask-for-approval',
-    'never',
-    'exec',
-    '--skip-git-repo-check',
-    '--sandbox',
-    flag(flags, 'codex-sandbox', 'workspace-write'),
-    '-C',
-    workdir,
-    '-',
-  ]
+  const sandbox = flag(flags, 'codex-sandbox')
+  const args = sandbox
+    ? [
+        '--ask-for-approval',
+        'never',
+        'exec',
+        '--skip-git-repo-check',
+        '--sandbox',
+        sandbox,
+        '-C',
+        workdir,
+        '-',
+      ]
+    : [
+        '--yolo',
+        'exec',
+        '--skip-git-repo-check',
+        '-C',
+        workdir,
+        '-',
+      ]
   const model = flag(flags, 'codex-model')
   const profile = flag(flags, 'codex-profile')
   const execIndex = args.indexOf('exec')
@@ -630,6 +843,36 @@ 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',
+      }
+    }
+    const recoveredSnapshot = buildRecoveredDeepKnowledgeSnapshot(task, [
+      structured?.comment || structured?.summary || '',
+      structured?.memory_delta || structured?.memoryDelta || '',
+      output,
+    ].filter(Boolean).join('\n\n'))
+    if (recoveredSnapshot) {
+      return {
+        comment: [
+          String(structured?.comment || structured?.summary || output || `Codex completed task ${task.id}.`).trim(),
+          'Recovered a knowledge_snapshot from the worker output because local tooling or MCP push was unavailable.',
+        ].filter(Boolean).join('\n\n'),
+        memory_delta: [
+          String(structured?.memory_delta || structured?.memoryDelta || '').trim(),
+          'Recovered deep knowledge organization snapshot from worker output.',
+        ].filter(Boolean).join('\n'),
+        status: 'in_review',
+        knowledge_snapshot: recoveredSnapshot,
+      }
+    }
+  }
   return {
     comment: output || `Codex completed task ${task.id}.`,
     memory_delta: `Codex completed task ${task.id}.`,
@@ -687,51 +930,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(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
+    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)