@11agents/cli 0.1.14 → 0.1.15

package/README.md

@@ -107,10 +107,11 @@ On startup, and every 30 minutes after that, the daemon syncs project metadata a
 - 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 --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/package.json

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

package/src/commands/logs.js

@@ -58,6 +58,7 @@ export async function formatTaskLog({ taskId, project = '', homeDir = homedir(),
 
   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}`,
@@ -67,6 +68,9 @@ export async function formatTaskLog({ taskId, project = '', homeDir = homedir(),
     `exit_code: ${meta.exit_code ?? ''}`,
     `run_dir: ${runDir}`,
     '',
+    'transcript:',
+    transcript,
+    '',
     'stdout:',
     stdout,
     '',

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
@@ -863,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,
@@ -878,6 +997,7 @@ async function runCodex({ task, prompt, flags = {}, deps }) {
     : [
         '--yolo',
         'exec',
+        ...jsonLogArgs,
         '--skip-git-repo-check',
         '-C',
         workdir,
@@ -890,7 +1010,6 @@ 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(' ')
-  const runDir = task.execution_context?.run_dir
   await writeRunFile(runDir, 'prompt.md', `/goal ${prompt}`)
   await updateRunMeta(runDir, {
     provider: 'codex',
@@ -901,9 +1020,14 @@ async function runCodex({ task, prompt, flags = {}, deps }) {
   })
   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', String(result.stdout || ''))
+  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) {
@@ -1003,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) {
@@ -1112,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
   }
@@ -1143,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()
   }
 }