@11agents/cli 0.1.13 → 0.1.15

package/README.md

@@ -84,6 +84,13 @@ Run the daemon in the background:
 
 Background mode writes its pid to `~/.11agents/daemon.pid` and logs to `~/.11agents/daemon.log`.
 
+Inspect daemon and task execution logs:
+
+```bash
+11agents logs daemon --tail 200
+11agents logs task <taskId> --project <slug>
+```
+
 Useful daemon options:
 
 ```bash
@@ -99,10 +106,12 @@ On startup, and every 30 minutes after that, the daemon syncs project metadata a
 - Agent-local skills: `~/.11agents/<project>/agents/<agent>/skills/`
 - Cloud database snapshot: `~/.11agents/<project>/database/snapshot.json`
 - Task scratch directory: `~/.11agents/<project>/tmp/<taskId>/`
+- Task execution logs: `~/.11agents/<project>/runs/<taskId>/`
+- Current claimed task marker: `~/.11agents/claim_id`
 
-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.
+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. Each run directory stores `prompt.md`, raw Codex JSONL in `stdout.log`, readable Codex dialogue in `transcript.log`, `stderr.log`, `last_message.md`, `completion.json`, and `meta.json`.
 
-The built-in Codex worker starts task executions with `codex --ask-for-approval never --yolo exec` and prefixes the task prompt with `/goal ` 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 Codex worker starts task executions with `codex --yolo exec --json --output-last-message <run>/last_message.md` and prefixes the task prompt with `/goal ` 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:
 

package/bin/11agents.js

@@ -3,6 +3,7 @@ import { readFile } from 'node:fs/promises'
 import { fileURLToPath } from 'node:url'
 import { parseArgs } from '../src/args.js'
 import { knowledgeStatus, syncKnowledge } from '../src/commands/knowledge.js'
+import { showDaemonLog, showTaskLog } from '../src/commands/logs.js'
 import { runNode } from '../src/commands/node.js'
 import { pushArtifact, pushBatch, pushObservation } from '../src/commands/push.js'
 import { registerRuntime, scanRuntime, startRuntimeDaemon } from '../src/commands/runtime.js'
@@ -24,6 +25,8 @@ Usage:
   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>
@@ -116,6 +119,17 @@ async function main() {
     return
   }
 
+  if (command === 'logs' && subcommand === 'daemon') {
+    await showDaemonLog(flags)
+    return
+  }
+
+  if (command === 'logs' && subcommand === 'task') {
+    if (!target) throw new Error('logs task requires a task id')
+    await showTaskLog(target, flags)
+    return
+  }
+
   if (command === 'mcp' && (!subcommand || subcommand === 'start')) {
     await startMcpServer()
     return

package/package.json

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

package/src/commands/logs.js

@@ -0,0 +1,100 @@
+import { readdir, readFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import path from 'node:path'
+import { backgroundPaths } from '../daemon-process.js'
+import { flag } from '../args.js'
+
+function tailText(text, lines) {
+  const count = Math.max(1, Number(lines) || 200)
+  const parts = String(text || '').replace(/\n$/, '').split('\n')
+  return parts.slice(-count).join('\n')
+}
+
+async function readText(filePath, fallback = '') {
+  try {
+    return await readFile(filePath, 'utf8')
+  } catch (error) {
+    if (error?.code === 'ENOENT') return fallback
+    throw error
+  }
+}
+
+async function readJson(filePath, fallback = {}) {
+  try {
+    return JSON.parse(await readFile(filePath, 'utf8'))
+  } catch (error) {
+    if (error?.code === 'ENOENT') return fallback
+    return fallback
+  }
+}
+
+export async function readDaemonLog({ homeDir = homedir(), tail = 200 } = {}) {
+  const text = await readText(backgroundPaths(homeDir).logPath, '')
+  return tailText(text, tail)
+}
+
+async function findTaskRunDir({ taskId, project = '', homeDir = homedir() }) {
+  if (!taskId) throw new Error('task id is required')
+  const baseDir = path.join(homeDir, '.11agents')
+  if (project) return path.join(baseDir, project, 'runs', taskId)
+
+  const entries = await readdir(baseDir, { withFileTypes: true }).catch(error => {
+    if (error?.code === 'ENOENT') return []
+    throw error
+  })
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    const runDir = path.join(baseDir, entry.name, 'runs', taskId)
+    const meta = await readJson(path.join(runDir, 'meta.json'), null)
+    if (meta) return runDir
+  }
+  return path.join(baseDir, 'project', 'runs', taskId)
+}
+
+export async function formatTaskLog({ taskId, project = '', homeDir = homedir(), tail = 120 } = {}) {
+  const runDir = await findTaskRunDir({ taskId, project, homeDir })
+  const meta = await readJson(path.join(runDir, 'meta.json'), null)
+  if (!meta) throw new Error(`task log not found: ${taskId}`)
+
+  const stdout = tailText(await readText(path.join(runDir, 'stdout.log'), ''), tail)
+  const stderr = tailText(await readText(path.join(runDir, 'stderr.log'), ''), tail)
+  const transcript = tailText(await readText(path.join(runDir, 'transcript.log'), ''), tail)
+  const completion = await readText(path.join(runDir, 'completion.json'), '')
+  return [
+    `task: ${meta.task_id || taskId}`,
+    `provider: ${meta.provider || ''}`,
+    `workdir: ${meta.workdir || ''}`,
+    `command: ${meta.command_line || ''}`,
+    `exit_code: ${meta.exit_code ?? ''}`,
+    `run_dir: ${runDir}`,
+    '',
+    'transcript:',
+    transcript,
+    '',
+    'stdout:',
+    stdout,
+    '',
+    'stderr:',
+    stderr,
+    '',
+    'completion:',
+    completion.trim(),
+  ].join('\n').trimEnd()
+}
+
+export async function showDaemonLog(flags = {}, deps = {}) {
+  const log = await readDaemonLog({ homeDir: deps.homeDir, tail: flag(flags, 'tail', '200') })
+  ;(deps.log || console.log)(log)
+  return log
+}
+
+export async function showTaskLog(taskId, flags = {}, deps = {}) {
+  const text = await formatTaskLog({
+    taskId,
+    project: flag(flags, 'project'),
+    homeDir: deps.homeDir,
+    tail: flag(flags, 'tail', '120'),
+  })
+  ;(deps.log || console.log)(text)
+  return text
+}

package/src/commands/runtime.js

@@ -82,6 +82,29 @@ function runtimeDeps(overrides = {}) {
   }
 }
 
+function currentClaimPath(homeDir) {
+  return path.join(homeDir, '.11agents', 'claim_id')
+}
+
+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))
+  return payload
+}
+
+async function readCurrentClaim(deps) {
+  return readJsonFile(currentClaimPath(deps.homeDir), null)
+}
+
+async function clearCurrentClaim(deps) {
+  await rm(currentClaimPath(deps.homeDir), { force: true })
+}
+
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error)
 }
@@ -263,6 +286,98 @@ function normalizeTaskCompletion(task, completion) {
   return body
 }
 
+function failedClaimCompletionBody(claim, comment) {
+  return {
+    task_id: String(claim?.task_id || ''),
+    runtime_id: String(claim?.runtime_id || ''),
+    machine_key: String(claim?.machine_key || ''),
+    comment,
+    memory_delta: '',
+    status: 'failed',
+  }
+}
+
+function codexTranscriptFromJsonl(text) {
+  const lines = []
+  for (const line of String(text || '').split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    try {
+      const event = JSON.parse(trimmed)
+      if (event?.type === 'item.completed') {
+        const item = event.item || {}
+        if (item.type === 'agent_message' && item.text) {
+          lines.push(`assistant: ${String(item.text).trim()}`)
+        } else if (item.type && item.text) {
+          lines.push(`${item.type}: ${String(item.text).trim()}`)
+        }
+      } else if (event?.type === 'turn.completed' && event.usage) {
+        lines.push(`usage: ${JSON.stringify(event.usage)}`)
+      }
+    } catch {
+      lines.push(trimmed)
+    }
+  }
+  return lines.join('\n')
+}
+
+function codexAssistantTextFromJsonl(text) {
+  const messages = []
+  for (const line of String(text || '').split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    try {
+      const event = JSON.parse(trimmed)
+      const item = event?.type === 'item.completed' ? event.item || {} : {}
+      if (item.type === 'agent_message' && item.text) messages.push(String(item.text).trim())
+    } catch {}
+  }
+  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)
+  return true
+}
+
+function installCurrentClaimExitHandlers(flags, deps) {
+  let shuttingDown = false
+  const failAndExit = async (signal, exitCode) => {
+    if (shuttingDown) return
+    shuttingDown = true
+    try {
+      await failPersistedCurrentClaim(
+        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',
+        signal,
+        error: errorMessage(error),
+      }, null, 2))
+    } finally {
+      process.exit(exitCode)
+    }
+  }
+  const onSigterm = () => { void failAndExit('SIGTERM', 143) }
+  const onSigint = () => { void failAndExit('SIGINT', 130) }
+  process.once('SIGTERM', onSigterm)
+  process.once('SIGINT', onSigint)
+  return () => {
+    process.off('SIGTERM', onSigterm)
+    process.off('SIGINT', onSigint)
+  }
+}
+
 function extractJsonObject(text) {
   const source = String(text || '').trim()
   if (!source) return null
@@ -693,6 +808,19 @@ async function appendTaskMemoryDelta({ task, completion, workdir }) {
   return { written: true, path: indexPath }
 }
 
+async function writeRunFile(runDir, fileName, content) {
+  if (!runDir) return
+  await mkdir(runDir, { recursive: true })
+  await writeFile(path.join(runDir, fileName), content)
+}
+
+async function updateRunMeta(runDir, patch) {
+  if (!runDir) return
+  const metaPath = path.join(runDir, 'meta.json')
+  const current = await readJsonFile(metaPath, {})
+  await writeRunFile(runDir, 'meta.json', JSON.stringify({ ...current, ...patch }, null, 2))
+}
+
 function databaseSyncSpec(task) {
   const spec = task.database || task.cloud_database || task.workspace?.database || null
   if (!spec || typeof spec !== 'object') return null
@@ -755,7 +883,9 @@ 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 runDir = path.join(workdir, 'runs', sanitizeTaskId(task.id))
   await mkdir(tmpDir, { recursive: true })
+  await mkdir(runDir, { recursive: true })
 
   const database = await syncDatabaseIfNeeded({ task, workdir, config, flags, deps })
   const skills = await materializeSkillsIfChanged({ task, workdir, flags, deps })
@@ -770,6 +900,7 @@ async function prepareRuntimeTask(task, flags, deps, config) {
   return {
     workdir,
     tmp_dir: tmpDir,
+    run_dir: runDir,
     project_slug: projectSlugForTask(task, flags),
     readonly: true,
     env,
@@ -847,11 +978,15 @@ 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 sandbox = flag(flags, 'codex-sandbox')
+  const runDir = task.execution_context?.run_dir
+  const lastMessagePath = runDir ? path.join(runDir, 'last_message.md') : ''
+  const jsonLogArgs = lastMessagePath ? ['--json', '--output-last-message', lastMessagePath] : ['--json']
   const args = sandbox
     ? [
         '--ask-for-approval',
         'never',
         'exec',
+        ...jsonLogArgs,
         '--skip-git-repo-check',
         '--sandbox',
         sandbox,
@@ -862,6 +997,7 @@ async function runCodex({ task, prompt, flags = {}, deps }) {
     : [
         '--yolo',
         'exec',
+        ...jsonLogArgs,
         '--skip-git-repo-check',
         '-C',
         workdir,
@@ -874,10 +1010,26 @@ async function runCodex({ task, prompt, flags = {}, deps }) {
   if (profile) args.splice(execIndex + 1, 0, '--profile', profile)
 
   const commandLine = [codexBin, ...args].map(value => JSON.stringify(String(value))).join(' ')
+  await writeRunFile(runDir, 'prompt.md', `/goal ${prompt}`)
+  await updateRunMeta(runDir, {
+    provider: 'codex',
+    command: codexBin,
+    args,
+    command_line: commandLine,
+    workdir,
+  })
   deps.log(JSON.stringify({ running: 'codex exec', command: commandLine, workdir }, null, 2))
   const result = await deps.runProcess(codexBin, args, { input: `/goal ${prompt}`, cwd: workdir, env: task.execution_context?.env || process.env })
-  const output = String(result.stdout || '').trim()
+  const rawStdout = String(result.stdout || '')
+  const transcript = codexTranscriptFromJsonl(rawStdout)
+  const assistantText = codexAssistantTextFromJsonl(rawStdout)
+  const lastMessage = lastMessagePath ? String(await readFile(lastMessagePath, 'utf8').catch(() => '')).trim() : ''
+  const output = (lastMessage || assistantText || rawStdout || transcript).trim()
   const error = String(result.stderr || '').trim()
+  await writeRunFile(runDir, 'stdout.log', rawStdout)
+  await writeRunFile(runDir, 'transcript.log', transcript)
+  await writeRunFile(runDir, 'stderr.log', String(result.stderr || ''))
+  await updateRunMeta(runDir, { exit_code: result.code })
   if (result.code !== 0) {
     const body = error || output || `codex exited with status ${result.code}`
     const trustHint = body.includes('--skip-git-repo-check')
@@ -975,6 +1127,7 @@ async function claimAndRunRuntimeTasks(registration, flags, deps, handlerModule,
     }
 
     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) {
@@ -1002,6 +1155,15 @@ async function claimAndRunRuntimeTasks(registration, flags, deps, handlerModule,
     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),
@@ -1019,6 +1181,10 @@ async function claimAndRunRuntimeTasks(registration, flags, deps, handlerModule,
         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 })
     }
@@ -1071,6 +1237,7 @@ async function claimAndRunRuntimeTasks(registration, flags, deps, handlerModule,
         config,
       })
     ), deps, retryState)
+    await clearCurrentClaim(deps)
     deps.log(JSON.stringify(result, null, 2))
     handled += 1
   }
@@ -1102,33 +1269,57 @@ export async function startRuntimeDaemon(flags = {}, deps = {}) {
 
   const handlerModule = await loadTaskHandler(handlerPath, resolvedDeps) || defaultTaskHandler(flags, resolvedDeps)
   const retryState = createRetryState()
-  let registration = await runWithDaemonRetry('register runtime', () => registerRuntime(flags, resolvedDeps), resolvedDeps, retryState)
-  await syncRuntimeProjectMetadataBestEffort(flags, resolvedDeps)
-  await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs)
-  if (once) return
-
-  let lastScan = Date.now()
-  let lastHeartbeat = Date.now()
-  let lastTaskPoll = Date.now()
-  let lastProjectRefresh = Date.now()
-  while (true) {
-    await resolvedDeps.sleep(Math.min(heartbeatIntervalMs, taskIntervalMs, projectRefreshIntervalMs))
-    const now = Date.now()
-    if (now - lastScan >= scanIntervalMs) {
-      registration = await runWithDaemonRetry('register runtime', () => registerRuntime(flags, resolvedDeps), resolvedDeps, retryState)
-      lastScan = now
-      lastHeartbeat = now
-    } else if (now - lastHeartbeat >= heartbeatIntervalMs) {
-      await runWithDaemonRetry('heartbeat runtime', () => heartbeatRuntime(flags, resolvedDeps), resolvedDeps, retryState)
-      lastHeartbeat = now
-    }
-    if (now - lastTaskPoll >= taskIntervalMs) {
-      await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs)
-      lastTaskPoll = now
+  const uninstallExitHandlers = installCurrentClaimExitHandlers(flags, resolvedDeps)
+  try {
+    let registration = await runWithDaemonRetry('register runtime', () => registerRuntime(flags, resolvedDeps), resolvedDeps, retryState)
+    await runWithDaemonRetry('recover current claimed task', () => failPersistedCurrentClaim(
+      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)
+    if (once) return
+
+    let lastScan = Date.now()
+    let lastHeartbeat = Date.now()
+    let lastTaskPoll = Date.now()
+    let lastProjectRefresh = Date.now()
+    while (true) {
+      await resolvedDeps.sleep(Math.min(heartbeatIntervalMs, taskIntervalMs, projectRefreshIntervalMs))
+      const now = Date.now()
+      if (now - lastScan >= scanIntervalMs) {
+        registration = await runWithDaemonRetry('register runtime', () => registerRuntime(flags, resolvedDeps), resolvedDeps, retryState)
+        lastScan = now
+        lastHeartbeat = now
+      } else if (now - lastHeartbeat >= heartbeatIntervalMs) {
+        await runWithDaemonRetry('heartbeat runtime', () => heartbeatRuntime(flags, resolvedDeps), resolvedDeps, retryState)
+        lastHeartbeat = now
+      }
+      if (now - lastTaskPoll >= taskIntervalMs) {
+        await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs)
+        lastTaskPoll = now
+      }
+      if (now - lastProjectRefresh >= projectRefreshIntervalMs) {
+        await syncRuntimeProjectMetadataBestEffort(flags, resolvedDeps)
+        lastProjectRefresh = now
+      }
     }
-    if (now - lastProjectRefresh >= projectRefreshIntervalMs) {
-      await syncRuntimeProjectMetadataBestEffort(flags, resolvedDeps)
-      lastProjectRefresh = now
+  } catch (error) {
+    try {
+      await failPersistedCurrentClaim(
+        flags,
+        resolvedDeps,
+        `Runtime task failed locally: daemon exited with error before the claimed task completed: ${errorMessage(error)}`
+      )
+    } catch (cleanupError) {
+      resolvedDeps.log(JSON.stringify({
+        warning: 'failed to mark current claimed task failed during daemon error exit',
+        error: errorMessage(cleanupError),
+      }, null, 2))
     }
+    throw error
+  } finally {
+    if (once) uninstallExitHandlers()
   }
 }