@mndrk/agx 1.4.30 → 1.4.33

package/lib/cli/runCli.js

@@ -21,7 +21,7 @@
 //     → spawns: agx <provider> --continue <task>
 // ============================================================
 
-const { spawn, spawnSync, execSync } = require('child_process');
+const execa = require('execa');
 const pMap = require('p-map');
 const pRetry = require("p-retry");
 const pRetryFn = pRetry.default || pRetry;
@@ -37,6 +37,8 @@ const { loadCloudConfigFile, saveCloudConfigFile, clearCloudConfig } = require('
 const { truncateForComment, cleanAgentOutputForComment, extractFileRefsFromText } = require('../ui/text');
 const { commandExists } = require('../proc/commandExists');
 const { spawnCloudTaskProcess } = require('../proc/spawnCloudTaskProcess');
+const { scheduleTermination } = require('../proc/killProcessTree');
+const { getProcessManager } = require('../proc/ProcessManager');
 const { createCloudClient } = require('../cloud/client');
 const { buildContinueCloudTaskPrompt, buildNewAutonomousCloudTaskPrompt } = require('../prompts/cloudTask');
 const {
@@ -132,9 +134,11 @@ const {
   createDaemonArtifactsRecorder,
   buildLocalRunIndexEntry,
   saveAugmentedPrompt,
+  extractSection,
   buildFullDaemonPromptContext,
   resolveTaskTicketType,
   parseList,
+  localArtifactKey,
 } = cloudArtifacts;
 
 // Config paths
@@ -180,6 +184,11 @@ async function postTaskLog(taskId, content, logType) {
   if (!cloudConfig?.apiUrl) return;
 
   try {
+    const text = String(content ?? '');
+    // Server rejects empty/whitespace-only log bodies (400). Skip to avoid noisy failures.
+    if (!text.trim()) return;
+
+    const type = (typeof logType === 'string' && logType.trim()) ? logType.trim() : 'output';
     await fetch(`${cloudConfig.apiUrl}/api/tasks/${taskId}/logs`, {
       method: 'POST',
       headers: {
@@ -187,7 +196,7 @@ async function postTaskLog(taskId, content, logType) {
         ...(cloudConfig?.token ? { 'Authorization': `Bearer ${cloudConfig.token}` } : {}),
         'x-user-id': cloudConfig.userId || '',
       },
-      body: JSON.stringify({ content, log_type: logType })
+      body: JSON.stringify({ content: text, log_type: type })
     });
   } catch { }
 }
@@ -244,6 +253,7 @@ const cloudRunner = createCloudRunner({
   fetch: globalThis.fetch,
 
   // config + transport
+  loadConfig,
   loadCloudConfigFile,
   postTaskLog,
   postTaskComment,
@@ -252,6 +262,8 @@ const cloudRunner = createCloudRunner({
   sanitizeCliArgs,
   commandExists,
   spawnCloudTaskProcess,
+  scheduleTermination,
+  getProcessManager,
   pMap,
   pRetryFn,
 
@@ -691,66 +703,66 @@ async function checkOnboarding() {
     console.log(`${c.green}✓${c.reset} Running task inline`);
     console.log(`${c.dim}Task: ${taskId}${c.reset}`);
 
-	    const decisionPayload = await runCloudDaemonTask(effectiveTask);
-	    // Inline run: always print the explanation so failures are actionable.
-	    if (decisionPayload?.decision && decisionPayload.decision !== 'done') {
-	      const detail = String(decisionPayload.summary || decisionPayload.explanation || '').trim();
-	      if (detail) {
-	        console.error(`${c.red}✗${c.reset} ${decisionPayload.decision}: ${detail}`);
-	      } else {
-	        console.error(`${c.red}✗${c.reset} ${decisionPayload.decision}`);
-	      }
-	    }
-	    const decision = String(decisionPayload?.decision || 'failed').toLowerCase();
-	    return decision === 'done' ? 0 : 1;
-	  }
-
-	  function normalizeDaemonDecision(decision, fallbackSummary = '', extra = {}) {
-	    const allowed = new Set(['done', 'blocked', 'not_done', 'failed']);
-	    const extractedDecision = typeof decision?.decision === 'string' ? decision.decision.trim() : '';
-	    const normalizedDecision = allowed.has(extractedDecision) ? extractedDecision : 'failed';
-
-	    const extraErr = typeof extra?.error === 'string' && extra.error.trim() ? extra.error.trim() : '';
-	    const explanation = typeof decision?.explanation === 'string' && decision.explanation.trim()
-	      ? decision.explanation.trim()
-	      : (extraErr || fallbackSummary || `Daemon decision: ${normalizedDecision}`);
-	    const finalResult = typeof decision?.final_result === 'string' && decision.final_result.trim()
-	      ? decision.final_result.trim()
-	      : explanation;
-	    const summary = typeof decision?.summary === 'string' && decision.summary.trim()
-	      ? decision.summary.trim()
-	      : (extraErr || '');
-
-	    return {
-	      decision: normalizedDecision,
-	      explanation,
-	      final_result: finalResult,
-	      summary,
-	    };
-	  }
-
-	async function runCloudDaemonTask(task) {
-	    const { buildCloudTaskTerminalPatch } = require('../cloud/status');
-
-	    const taskId = String(task?.id || '').trim();
-	    if (!taskId) {
-	      throw new Error('Queue returned task without id');
-	    }
-
-	    const provider = String(task?.provider || task?.engine || 'claude').toLowerCase();
-	    const model = typeof task?.model === 'string' && task.model.trim() ? task.model.trim() : null;
-	    const logger = createTaskLogger(taskId);
-	    const localArtifacts = isLocalArtifactsEnabled();
-	    const storage = localArtifacts ? require('../storage') : null;
-	    const stageLocal = mapCloudStageToLocalStage(task?.stage);
-	    let projectSlug = null;
-	    let taskSlug = null;
-	    const orchestrator = getOrchestrator();
-	    const cancellationWatcher = createCancellationWatcher({ orchestrator, taskId });
-
-	    let lockHandle = null;
-	    let lastRun = null;
-	    let runIndexEntry = null;
+    const decisionPayload = await runCloudDaemonTask(effectiveTask);
+    // Inline run: always print the explanation so failures are actionable.
+    if (decisionPayload?.decision && decisionPayload.decision !== 'done') {
+      const detail = String(decisionPayload.summary || decisionPayload.explanation || '').trim();
+      if (detail) {
+        console.error(`${c.red}✗${c.reset} ${decisionPayload.decision}: ${detail}`);
+      } else {
+        console.error(`${c.red}✗${c.reset} ${decisionPayload.decision}`);
+      }
+    }
+    const decision = String(decisionPayload?.decision || 'failed').toLowerCase();
+    return decision === 'done' ? 0 : 1;
+  }
+
+  function normalizeDaemonDecision(decision, fallbackSummary = '', extra = {}) {
+    const allowed = new Set(['done', 'blocked', 'not_done', 'failed']);
+    const extractedDecision = typeof decision?.decision === 'string' ? decision.decision.trim() : '';
+    const normalizedDecision = allowed.has(extractedDecision) ? extractedDecision : 'failed';
+
+    const extraErr = typeof extra?.error === 'string' && extra.error.trim() ? extra.error.trim() : '';
+    const explanation = typeof decision?.explanation === 'string' && decision.explanation.trim()
+      ? decision.explanation.trim()
+      : (extraErr || fallbackSummary || `Daemon decision: ${normalizedDecision}`);
+    const finalResult = typeof decision?.final_result === 'string' && decision.final_result.trim()
+      ? decision.final_result.trim()
+      : explanation;
+    const summary = typeof decision?.summary === 'string' && decision.summary.trim()
+      ? decision.summary.trim()
+      : (extraErr || '');
+
+    return {
+      decision: normalizedDecision,
+      explanation,
+      final_result: finalResult,
+      summary,
+    };
+  }
+
+  async function runCloudDaemonTask(task) {
+    const { buildCloudTaskTerminalPatch } = require('../cloud/status');
+
+    const taskId = String(task?.id || '').trim();
+    if (!taskId) {
+      throw new Error('Queue returned task without id');
+    }
+
+    const provider = String(task?.provider || task?.engine || 'claude').toLowerCase();
+    const model = typeof task?.model === 'string' && task.model.trim() ? task.model.trim() : null;
+    const logger = createTaskLogger(taskId);
+    const localArtifacts = isLocalArtifactsEnabled();
+    const storage = localArtifacts ? require('../storage') : null;
+    const stageLocal = mapCloudStageToLocalStage(task?.stage);
+    let projectSlug = null;
+    let taskSlug = null;
+    const orchestrator = getOrchestrator();
+    const cancellationWatcher = createCancellationWatcher({ orchestrator, taskId });
+
+    let lockHandle = null;
+    let lastRun = null;
+    let runIndexEntry = null;
 
     logger.log('system', `[daemon] picked task ${taskId} (${task?.stage || 'unknown'})\n`);
     console.log(`${c.dim}[daemon] picked ${taskId} (${task?.stage || 'unknown'}) via ${provider}${model ? `/${model}` : ''}${c.reset}`);
@@ -836,19 +848,19 @@ async function checkOnboarding() {
 
         // Execute+verify loop runs per-iteration local runs under the mapped cloud stage.
         let loopResult;
-	        if (task?.swarm) {
-	          loopResult = await runSwarmExecuteVerifyLoop({
-	            taskId,
-	            task,
-	            logger,
-	            storage,
-	            projectSlug,
-	            taskSlug,
-	            stageLocal,
-	            initialPromptContext: fullPromptContext,
-	            cancellationWatcher,
-	          });
-	        } else {
+        if (task?.swarm) {
+          loopResult = await runSwarmExecuteVerifyLoop({
+            taskId,
+            task,
+            logger,
+            storage,
+            projectSlug,
+            taskSlug,
+            stageLocal,
+            initialPromptContext: fullPromptContext,
+            cancellationWatcher,
+          });
+        } else {
           loopResult = await runSingleAgentExecuteVerifyLoop({
             taskId,
             task,
@@ -866,20 +878,20 @@ async function checkOnboarding() {
 
         lastRun = loopResult?.lastRun || null;
         runIndexEntry = loopResult?.runIndexEntry || null;
-	          decisionPayload = normalizeDaemonDecision(
-	            loopResult?.decision,
-	            loopResult?.code === 0 ? 'Execution completed.' : 'Execution failed.',
-	            { error: task?.error || '' }
-	          );
+        decisionPayload = normalizeDaemonDecision(
+          loopResult?.decision,
+          loopResult?.code === 0 ? 'Execution completed.' : 'Execution failed.',
+          { error: task?.error || '' }
+        );
       } else {
         // Fallback: cloud-only execution path (legacy).
         if (task?.swarm) {
-	          runResult = await runSwarmLoop({ taskId, task, artifacts: null, cancellationWatcher });
-	          decisionPayload = normalizeDaemonDecision(
-	            runResult?.decision,
-	            runResult?.code === 0 ? 'Swarm execution completed.' : 'Swarm execution failed.',
-	            { error: task?.error || '' }
-	          );
+          runResult = await runSwarmLoop({ taskId, task, artifacts: null, cancellationWatcher });
+          decisionPayload = normalizeDaemonDecision(
+            runResult?.decision,
+            runResult?.code === 0 ? 'Swarm execution completed.' : 'Swarm execution failed.',
+            { error: task?.error || '' }
+          );
         } else {
           runResult = await runSingleAgentLoop({
             taskId,
@@ -890,36 +902,36 @@ async function checkOnboarding() {
             artifacts: null,
             cancellationWatcher,
           });
-	          decisionPayload = normalizeDaemonDecision(
-	            runResult?.decision,
-	            runResult?.code === 0 ? 'Single-agent execution completed.' : 'Single-agent execution failed.',
-	            { error: task?.error || '' }
-	          );
+          decisionPayload = normalizeDaemonDecision(
+            runResult?.decision,
+            runResult?.code === 0 ? 'Single-agent execution completed.' : 'Single-agent execution failed.',
+            { error: task?.error || '' }
+          );
         }
       }
-	    } catch (err) {
-	      const message = err?.message || 'Daemon execution failed.';
-	      // This error is in the daemon process (not the spawned agx subprocess), so also write it
-	      // to the run container when local artifacts are enabled.
-	      if (localArtifacts && lastRun?.paths?.root) {
-	        const runContainerPath = path.dirname(lastRun.paths.root);
-	        const detail = err?.stack || message;
-	        await appendRunContainerLog(runContainerPath, 'daemon/daemon_error.log', `[${new Date().toISOString()}] ${detail}`);
-	      }
-	      decisionPayload = {
-	        decision: 'failed',
-	        explanation: message,
-	        final_result: message,
-	        summary: message,
-	      };
-	      logger.log('error', `[daemon] execution failed: ${message}\n`);
-	    } finally {
-	      await logger.flushAll();
-	      try { cancellationWatcher?.destroy?.(); } catch { }
-	      if (localArtifacts) {
-	        try {
-	          // Runs are finalized per-iteration inside the execute/verify loop.
-	        } catch (e) {
+    } catch (err) {
+      const message = err?.message || 'Daemon execution failed.';
+      // This error is in the daemon process (not the spawned agx subprocess), so also write it
+      // to the run container when local artifacts are enabled.
+      if (localArtifacts && lastRun?.paths?.root) {
+        const runContainerPath = path.dirname(lastRun.paths.root);
+        const detail = err?.stack || message;
+        await appendRunContainerLog(runContainerPath, 'daemon/daemon_error.log', `[${new Date().toISOString()}] ${detail}`);
+      }
+      decisionPayload = {
+        decision: 'failed',
+        explanation: message,
+        final_result: message,
+        summary: message,
+      };
+      logger.log('error', `[daemon] execution failed: ${message}\n`);
+    } finally {
+      await logger.flushAll();
+      try { cancellationWatcher?.destroy?.(); } catch { }
+      if (localArtifacts) {
+        try {
+          // Runs are finalized per-iteration inside the execute/verify loop.
+        } catch (e) {
           // Never break cloud completion because local artifacts failed.
           logger?.log('error', `[daemon] local artifact finalize failed: ${e?.message || e}\n`);
         } finally {
@@ -930,40 +942,40 @@ async function checkOnboarding() {
       }
     }
 
-	    const completionResult = await cloudRequest('POST', '/api/queue/complete', {
-	      taskId,
-	      log: decisionPayload.summary || decisionPayload.explanation,
-	      decision: decisionPayload.decision,
-	      final_result: decisionPayload.final_result,
+    const completionResult = await cloudRequest('POST', '/api/queue/complete', {
+      taskId,
+      log: decisionPayload.summary || decisionPayload.explanation,
+      decision: decisionPayload.decision,
+      final_result: decisionPayload.final_result,
       explanation: decisionPayload.explanation,
       ...(localArtifacts && lastRun?.paths?.root ? {
         artifact_path: lastRun.paths.root,
         artifact_host: os.hostname(),
         artifact_key: localArtifactKey(lastRun.paths.root),
       } : {}),
-	      ...(runIndexEntry ? { run_entry: runIndexEntry } : {}),
-	    });
-
-	    // Best-effort: ensure cloud task status is terminal when stage/decision indicates completion.
-	    // Some board runtimes advance `stage` to "done" but leave `status` as "in_progress".
-	    try {
-	      let newStage = completionResult?.newStage || completionResult?.task?.stage || null;
-	      if (!newStage) {
-	        try {
-	          const { task: refreshed } = await cloudRequest('GET', `/api/tasks/${taskId}`);
-	          newStage = refreshed?.stage || null;
-	        } catch { }
-	      }
-	      const patch = buildCloudTaskTerminalPatch({ decision: decisionPayload?.decision, newStage });
-	      if (patch) {
-	        await cloudRequest('PATCH', `/api/tasks/${taskId}`, patch);
-	      }
-	    } catch { }
-
-	    // Post a structured outcome comment (separate from queue completion log).
-	    await postTaskComment(taskId, [
-	      `## ${task?.stage || 'stage'} completed`,
-	      '',
+      ...(runIndexEntry ? { run_entry: runIndexEntry } : {}),
+    });
+
+    // Best-effort: ensure cloud task status is terminal when stage/decision indicates completion.
+    // Some board runtimes advance `stage` to "done" but leave `status` as "in_progress".
+    try {
+      let newStage = completionResult?.newStage || completionResult?.task?.stage || null;
+      if (!newStage) {
+        try {
+          const { task: refreshed } = await cloudRequest('GET', `/api/tasks/${taskId}`);
+          newStage = refreshed?.stage || null;
+        } catch { }
+      }
+      const patch = buildCloudTaskTerminalPatch({ decision: decisionPayload?.decision, newStage });
+      if (patch) {
+        await cloudRequest('PATCH', `/api/tasks/${taskId}`, patch);
+      }
+    } catch { }
+
+    // Post a structured outcome comment (separate from queue completion log).
+    await postTaskComment(taskId, [
+      `## ${task?.stage || 'stage'} completed`,
+      '',
       `Decision: ${decisionPayload.decision}`,
       '',
       decisionPayload.summary || decisionPayload.explanation || '',
@@ -996,15 +1008,22 @@ async function checkOnboarding() {
     const inFlight = new Map();
     let stopping = false;
 
+    const pm = getProcessManager();
+
     const requestStop = () => {
       if (stopping) return;
       stopping = true;
       console.log(`\n${c.dim}[daemon] stopping... waiting for ${inFlight.size} active task(s)${c.reset}`);
+      pm.killAll();
     };
 
     process.on('SIGINT', requestStop);
     process.on('SIGTERM', requestStop);
 
+    // Periodic orphan heartbeat sweep
+    const orphanSweep = setInterval(() => pm.sweepOrphanedHeartbeats(), 60_000);
+    orphanSweep.unref();
+
     console.log(`${c.green}✓${c.reset} Daemon loop started (workers=${maxWorkers}, poll=${pollMs}ms)`);
 
     while (!stopping) {
@@ -1557,14 +1576,14 @@ async function checkOnboarding() {
 
       console.log(`${c.bold}Tasks${c.reset} (${tasks.length})\n`);
       let idx = 1;
-	      for (const task of tasks) {
-	        const statusIcon = {
-	          queued: c.yellow + '○' + c.reset,
-	          in_progress: c.blue + '●' + c.reset,
-	          blocked: c.yellow + '!' + c.reset,
-	          completed: c.green + '✓' + c.reset,
-	          failed: c.red + '✗' + c.reset,
-	        }[task.status] || '?';
+      for (const task of tasks) {
+        const statusIcon = {
+          queued: c.yellow + '○' + c.reset,
+          in_progress: c.blue + '●' + c.reset,
+          blocked: c.yellow + '!' + c.reset,
+          completed: c.green + '✓' + c.reset,
+          failed: c.red + '✗' + c.reset,
+        }[task.status] || '?';
 
         console.log(`  ${c.dim}${idx}.${c.reset} ${statusIcon} ${task.slug || 'task'}`);
         const displayProvider = task.swarm
@@ -1632,35 +1651,35 @@ async function checkOnboarding() {
         process.exit(0);
       }
 
-	      const message = log || 'Stage completed via agx CLI';
-	      const { task, newStage } = await cloudRequest('POST', '/api/queue/complete', {
-	        taskId: resolvedTaskId,
-	        log: message,
-	        decision: 'done',
-	        explanation: message,
-	        final_result: message,
-	      });
-	      let stageAfter = newStage || task?.stage || null;
-	      if (!stageAfter) {
-	        try {
-	          const { task: refreshed } = await cloudRequest('GET', `/api/tasks/${resolvedTaskId}`);
-	          stageAfter = refreshed?.stage || null;
-	        } catch { }
-	      }
-
-	      // If this completion transitioned the task into a terminal stage, align `status` too.
-	      try {
-	        const patch = buildCloudTaskTerminalPatch({ newStage: stageAfter });
-	        if (patch) {
-	          await cloudRequest('PATCH', `/api/tasks/${resolvedTaskId}`, patch);
-	        }
-	      } catch { }
-
-	      console.log(`${c.green}✓${c.reset} Stage completed`);
-	      console.log(`  New stage: ${stageAfter || 'unknown'}`);
-	      if (String(stageAfter || '').toLowerCase() === 'done') {
-	        console.log(`  ${c.green}Task is now complete!${c.reset}`);
-	      }
+      const message = log || 'Stage completed via agx CLI';
+      const { task, newStage } = await cloudRequest('POST', '/api/queue/complete', {
+        taskId: resolvedTaskId,
+        log: message,
+        decision: 'done',
+        explanation: message,
+        final_result: message,
+      });
+      let stageAfter = newStage || task?.stage || null;
+      if (!stageAfter) {
+        try {
+          const { task: refreshed } = await cloudRequest('GET', `/api/tasks/${resolvedTaskId}`);
+          stageAfter = refreshed?.stage || null;
+        } catch { }
+      }
+
+      // If this completion transitioned the task into a terminal stage, align `status` too.
+      try {
+        const patch = buildCloudTaskTerminalPatch({ newStage: stageAfter });
+        if (patch) {
+          await cloudRequest('PATCH', `/api/tasks/${resolvedTaskId}`, patch);
+        }
+      } catch { }
+
+      console.log(`${c.green}✓${c.reset} Stage completed`);
+      console.log(`  New stage: ${stageAfter || 'unknown'}`);
+      if (String(stageAfter || '').toLowerCase() === 'done') {
+        console.log(`  ${c.green}Task is now complete!${c.reset}`);
+      }
     } catch (err) {
       console.log(`${c.red}✗${c.reset} Failed: ${err.message}`);
       process.exit(1);
@@ -2160,9 +2179,12 @@ async function checkOnboarding() {
 
   // agx container ls (Docker-style namespace - list running daemons)
   if (cmd === 'container' && args[1] === 'ls') {
-    const { execSync } = require('child_process');
     try {
-      const result = execSync('pgrep -fl "agx.*daemon" 2>/dev/null || echo ""', { encoding: 'utf8' });
+      const result = execa.commandSync('pgrep -fl "agx.*daemon" 2>/dev/null || echo \"\"', {
+        shell: true,
+        encoding: 'utf8',
+        reject: false,
+      }).stdout || '';
       if (result.trim()) {
         console.log(`${c.bold}Running Containers${c.reset}\n`);
         console.log(result.trim());
@@ -2216,13 +2238,18 @@ async function checkOnboarding() {
 
   // agx container stop (Docker-style namespace - stop daemon)
   if (cmd === 'container' && args[1] === 'stop') {
-    const { execSync } = require('child_process');
     try {
-      const result = execSync('pgrep -fl "agx.*daemon" 2>/dev/null || echo ""', { encoding: 'utf8' });
+      const result = execa.commandSync('pgrep -fl "agx.*daemon" 2>/dev/null || echo \"\"', {
+        shell: true,
+        encoding: 'utf8',
+        reject: false,
+      }).stdout || '';
       if (result.trim()) {
-        const pids = result.trim().split('\n').map(line => line.split(' ')[0]);
+        const pids = result.trim().split('\n').map(line => line.trim().split(/\s+/)[0]).filter(Boolean);
         for (const pid of pids) {
-          execSync(`kill ${pid}`, { encoding: 'utf8' });
+          const n = Number.parseInt(pid, 10);
+          if (!Number.isFinite(n) || n <= 0) continue;
+          try { process.kill(n, 'SIGTERM'); } catch { }
         }
         console.log(`${c.green}✓${c.reset} Container(s) stopped`);
       } else {
@@ -2307,7 +2334,7 @@ async function checkOnboarding() {
     // Helper to get current crontab
     const getCrontab = () => {
       try {
-        return execSync('crontab -l 2>/dev/null', { encoding: 'utf8' });
+        return execa.commandSync('crontab -l 2>/dev/null', { shell: true, encoding: 'utf8', reject: false }).stdout || '';
       } catch {
         return '';
       }
@@ -2318,9 +2345,9 @@ async function checkOnboarding() {
       const tmp = path.join(os.tmpdir(), `agx-crontab-${Date.now()}`);
       fs.writeFileSync(tmp, content);
       try {
-        execSync(`crontab ${tmp}`, { timeout: 5000 });
+        execa.commandSync(`crontab ${tmp}`, { shell: true, timeout: 5000, reject: false });
       } finally {
-        try { fs.unlinkSync(tmp); } catch {}
+        try { fs.unlinkSync(tmp); } catch { }
       }
     };
 
@@ -2374,11 +2401,13 @@ async function checkOnboarding() {
     // Default: update now
     console.log(`${c.cyan}→${c.reset} Checking for updates...`);
     try {
-      const result = spawnSync('npm', ['update', '-g', '@mndrk/agx'], { 
+      const child = execa('npm', ['update', '-g', '@mndrk/agx'], {
         stdio: 'inherit',
-        shell: true 
+        shell: false,
+        reject: false,
       });
-      if (result.status === 0) {
+      const result = await child;
+      if (result.exitCode === 0) {
         console.log(`${c.green}✓${c.reset} Update complete`);
       } else {
         console.log(`${c.red}✗${c.reset} Update failed`);
@@ -2456,35 +2485,35 @@ async function runCli(argv = process.argv) {
   const originalArgv = process.argv;
   if (Array.isArray(argv)) process.argv = argv;
   try {
-  if (await checkOnboarding()) return;
+    if (await checkOnboarding()) return;
 
-  const args = process.argv.slice(2);
-  let provider = args[0];
-  const config = loadConfig();
+    const args = process.argv.slice(2);
+    let provider = args[0];
+    const config = loadConfig();
 
-  // Normalize provider aliases
-  const PROVIDER_ALIASES = {
-    'g': 'gemini',
-    'gem': 'gemini',
-    'gemini': 'gemini',
-    'c': 'claude',
-    'cl': 'claude',
-    'claude': 'claude',
-    'x': 'codex',
-    'codex': 'codex',
-    'o': 'ollama',
-    'ol': 'ollama',
-    'ollama': 'ollama'
-  };
+    // Normalize provider aliases
+    const PROVIDER_ALIASES = {
+      'g': 'gemini',
+      'gem': 'gemini',
+      'gemini': 'gemini',
+      'c': 'claude',
+      'cl': 'claude',
+      'claude': 'claude',
+      'x': 'codex',
+      'codex': 'codex',
+      'o': 'ollama',
+      'ol': 'ollama',
+      'ollama': 'ollama'
+    };
 
-  const VALID_PROVIDERS = ['gemini', 'claude', 'ollama', 'codex'];
+    const VALID_PROVIDERS = ['gemini', 'claude', 'ollama', 'codex'];
 
-  // Handle help
-  if (args.includes('--help') || args.includes('-h')) {
-    const defaultNote = config?.defaultProvider
-      ? `  Default: ${config.defaultProvider}`
-      : '';
-    console.log(`agx - Autonomous AI Agent CLI
+    // Handle help
+    if (args.includes('--help') || args.includes('-h')) {
+      const defaultNote = config?.defaultProvider
+        ? `  Default: ${config.defaultProvider}`
+        : '';
+      console.log(`agx - Autonomous AI Agent CLI
 
 USAGE:
   agx -a -p "build something"     Autonomous: works until done
@@ -2548,386 +2577,338 @@ EXAMPLES:
   agx codex -p "refactor this"    # One-shot question
   agx task ls               # Check cloud tasks
   agx container logs         # See what's happening`);
-    process.exit(0);
-  }
-
-  // Detect if first arg is a provider or an option
-  const isProviderArg = provider && PROVIDER_ALIASES[provider.toLowerCase()];
-
-  // If no provider specified, use default from config
-  if (!provider || (!isProviderArg && provider.startsWith('-'))) {
-    if (config?.defaultProvider) {
-      // Shift: treat current args as options, use default provider
-      if (provider && provider.startsWith('-')) {
-        // First arg is an option, not a provider
-        provider = config.defaultProvider;
-      } else if (!provider) {
-        provider = config.defaultProvider;
-      }
-    } else {
-      console.log(`${c.yellow}No provider specified and no default configured.${c.reset}`);
-      console.log(`\nRun ${c.cyan}agx init${c.reset} to set up, or specify a provider:\n`);
-      console.log(`  ${c.dim}agx claude --prompt "hello"${c.reset}`);
-      console.log(`  ${c.dim}agx codex --prompt "hello"${c.reset}`);
-      console.log(`  ${c.dim}agx gemini --prompt "hello"${c.reset}`);
-      console.log(`  ${c.dim}agx ollama --prompt "hello"${c.reset}\n`);
-      process.exit(1);
+      process.exit(0);
     }
-  }
 
-  // Resolve provider
-  const resolvedProvider = PROVIDER_ALIASES[provider.toLowerCase()];
-  if (!resolvedProvider) {
-    console.error(`${c.red}Error:${c.reset} Unknown provider "${provider}"`);
-    console.error(`Valid providers: ${VALID_PROVIDERS.join(', ')}`);
-    process.exit(1);
-  }
-  provider = resolvedProvider;
-
-  // Determine remaining args - if first arg wasn't a provider, include it
-  const remainingArgs = isProviderArg ? args.slice(1) : args;
-  const translatedArgs = [];
-  const rawArgs = [];
-  let env = { ...process.env };
-
-  // Split raw arguments at --
-  const dashIndex = remainingArgs.indexOf('--');
-  let processedArgs = remainingArgs;
-  if (dashIndex !== -1) {
-    processedArgs = remainingArgs.slice(0, dashIndex);
-    rawArgs.push(...remainingArgs.slice(dashIndex + 1));
-  }
-
-  // Parsed options (explicit structure for predictability)
-  const options = {
-    prompt: null,
-    model: null,
-    yolo: false,
-    print: false,
-    interactive: false,
-    sandbox: false,
-    debug: false,
-    mcp: null,
-    cloud: null, // null = auto-detect, true = force on, false = force off
-    cloudTaskId: null,
-    autonomous: false,
-    daemon: false
-  };
+    // Detect if first arg is a provider or an option
+    const isProviderArg = provider && PROVIDER_ALIASES[provider.toLowerCase()];
 
-  // Collect positional args (legacy support, but --prompt is preferred)
-  const positionalArgs = [];
-
-  for (let i = 0; i < processedArgs.length; i++) {
-    const arg = processedArgs[i];
-    const nextArg = processedArgs[i + 1];
-
-    switch (arg) {
-      case '--prompt':
-      case '-p':
-        if (nextArg && !nextArg.startsWith('-')) {
-          options.prompt = nextArg;
-          i++;
-        }
-        break;
-      case '--model':
-      case '-m':
-        if (nextArg && !nextArg.startsWith('-')) {
-          options.model = nextArg;
-          i++;
-        }
-        break;
-      case '--yolo':
-      case '-y':
-        options.yolo = true;
-        break;
-      case '--print':
-        options.print = true;
-        break;
-      case '--interactive':
-      case '-i':
-        options.interactive = true;
-        break;
-      case '--sandbox':
-      case '-s':
-        options.sandbox = true;
-        break;
-      case '--debug':
-      case '-d':
-        options.debug = true;
-        break;
-      case '--mcp':
-        if (nextArg && !nextArg.startsWith('-')) {
-          options.mcp = nextArg;
-          i++;
-        }
-        break;
-      case '--autonomous':
-      case '--auto':
-      case '-a':
-        options.autonomous = true;
-        options.yolo = true; // Autonomous = unattended, skip prompts
-        break;
-      case '--cloud-task':
-        if (nextArg && !nextArg.startsWith('-')) {
-          options.cloudTaskId = nextArg;
-          i++;
-        }
-        break;
-      case '--daemon':
-        options.daemon = true;
-        break;
-      default:
-        if (arg.startsWith('-')) {
-          // Unknown flag - pass through
-          translatedArgs.push(arg);
-        } else {
-          // Positional argument (legacy prompt support)
-          positionalArgs.push(arg);
+    // If no provider specified, use default from config
+    if (!provider || (!isProviderArg && provider.startsWith('-'))) {
+      if (config?.defaultProvider) {
+        // Shift: treat current args as options, use default provider
+        if (provider && provider.startsWith('-')) {
+          // First arg is an option, not a provider
+          provider = config.defaultProvider;
+        } else if (!provider) {
+          provider = config.defaultProvider;
         }
+      } else {
+        console.log(`${c.yellow}No provider specified and no default configured.${c.reset}`);
+        console.log(`\nRun ${c.cyan}agx init${c.reset} to set up, or specify a provider:\n`);
+        console.log(`  ${c.dim}agx claude --prompt "hello"${c.reset}`);
+        console.log(`  ${c.dim}agx codex --prompt "hello"${c.reset}`);
+        console.log(`  ${c.dim}agx gemini --prompt "hello"${c.reset}`);
+        console.log(`  ${c.dim}agx ollama --prompt "hello"${c.reset}\n`);
+        process.exit(1);
+      }
     }
-  }
-
-  // Determine final prompt: explicit --prompt takes precedence
-  const finalPrompt = options.prompt || positionalArgs.join(' ');
 
-  // Apply default model from config when --model is not specified
-  if (!options.model) {
-    const configuredModel = config?.models?.[provider] || (provider === 'ollama' ? config?.ollama?.model : null);
-    if (configuredModel) options.model = configuredModel;
-  }
-
-  // Build command based on provider
-  let command = '';
-
-  // Apply common options to translatedArgs
-  if (options.model) {
-    translatedArgs.push('--model', options.model);
-  }
-  if (options.debug) {
-    translatedArgs.push('--debug');
-  }
+    // Resolve provider
+    const resolvedProvider = PROVIDER_ALIASES[provider.toLowerCase()];
+    if (!resolvedProvider) {
+      console.error(`${c.red}Error:${c.reset} Unknown provider "${provider}"`);
+      console.error(`Valid providers: ${VALID_PROVIDERS.join(', ')}`);
+      process.exit(1);
+    }
+    provider = resolvedProvider;
+
+    // Determine remaining args - if first arg wasn't a provider, include it
+    const remainingArgs = isProviderArg ? args.slice(1) : args;
+    const translatedArgs = [];
+    const rawArgs = [];
+    let env = { ...process.env };
+
+    // Split raw arguments at --
+    const dashIndex = remainingArgs.indexOf('--');
+    let processedArgs = remainingArgs;
+    if (dashIndex !== -1) {
+      processedArgs = remainingArgs.slice(0, dashIndex);
+      rawArgs.push(...remainingArgs.slice(dashIndex + 1));
+    }
+
+    // Parsed options (explicit structure for predictability)
+    const options = {
+      prompt: null,
+      model: null,
+      yolo: false,
+      print: false,
+      interactive: false,
+      sandbox: false,
+      debug: false,
+      mcp: null,
+      cloud: null, // null = auto-detect, true = force on, false = force off
+      cloudTaskId: null,
+      autonomous: false,
+      daemon: false
+    };
 
-  if (provider === 'gemini') {
-    command = 'gemini';
+    // Collect positional args (legacy support, but --prompt is preferred)
+    const positionalArgs = [];
 
-    // Gemini-specific translations
-    if (options.yolo) translatedArgs.push('--yolo');
-    if (options.sandbox) translatedArgs.push('--sandbox');
+    for (let i = 0; i < processedArgs.length; i++) {
+      const arg = processedArgs[i];
+      const nextArg = processedArgs[i + 1];
 
-    // Gemini prompt handling
-    if (finalPrompt) {
-      if (options.print) {
-        translatedArgs.push('--prompt', finalPrompt);
-      } else if (options.interactive) {
-        translatedArgs.push('--prompt-interactive', finalPrompt);
-      } else {
-        translatedArgs.push(finalPrompt);
-      }
-    }
-  } else if (provider === 'codex') {
-    command = 'codex';
-
-    // Use non-interactive mode whenever this is a scripted invocation.
-    const shouldUseExec = options.cloudTaskId
-      || options.autonomous
-      || options.daemon
-      || options.print
-      || (finalPrompt && !options.interactive);
-    if (shouldUseExec) {
-      translatedArgs.unshift('exec');
-    }
-
-    // Codex approval/sandbox modes:
-    // - Officially documented: --auto-edit, --full-auto
-    // - Some Codex builds also accept: --dangerously-bypass-approvals-and-sandbox
-    // We only attempt the dangerous bypass for unattended runs, and we add a runtime
-    // retry below if the installed Codex CLI rejects the flag.
-    // If we're using `codex exec`, choose exactly one execution policy:
-    // - default unattended: --full-auto (sandboxed, workspace-write)
-    // - explicit yolo: --dangerously-bypass-approvals-and-sandbox (unsandboxed)
-    //
-    // Codex CLI rejects using both at once.
-    if (shouldUseExec) {
-      if (options.yolo) {
-        translatedArgs.push('--dangerously-bypass-approvals-and-sandbox');
-      } else {
-        translatedArgs.push('--full-auto');
+      switch (arg) {
+        case '--prompt':
+        case '-p':
+          if (nextArg && !nextArg.startsWith('-')) {
+            options.prompt = nextArg;
+            i++;
+          }
+          break;
+        case '--model':
+        case '-m':
+          if (nextArg && !nextArg.startsWith('-')) {
+            options.model = nextArg;
+            i++;
+          }
+          break;
+        case '--yolo':
+        case '-y':
+          options.yolo = true;
+          break;
+        case '--print':
+          options.print = true;
+          break;
+        case '--interactive':
+        case '-i':
+          options.interactive = true;
+          break;
+        case '--sandbox':
+        case '-s':
+          options.sandbox = true;
+          break;
+        case '--debug':
+        case '-d':
+          options.debug = true;
+          break;
+        case '--mcp':
+          if (nextArg && !nextArg.startsWith('-')) {
+            options.mcp = nextArg;
+            i++;
+          }
+          break;
+        case '--autonomous':
+        case '--auto':
+        case '-a':
+          options.autonomous = true;
+          options.yolo = true; // Autonomous = unattended, skip prompts
+          break;
+        case '--cloud-task':
+          if (nextArg && !nextArg.startsWith('-')) {
+            options.cloudTaskId = nextArg;
+            i++;
+          }
+          break;
+        case '--daemon':
+          options.daemon = true;
+          break;
+        default:
+          if (arg.startsWith('-')) {
+            // Unknown flag - pass through
+            translatedArgs.push(arg);
+          } else {
+            // Positional argument (legacy prompt support)
+            positionalArgs.push(arg);
+          }
       }
     }
 
-    if (finalPrompt) {
-      translatedArgs.push(finalPrompt);
+    // Determine final prompt: explicit --prompt takes precedence
+    const finalPrompt = options.prompt || positionalArgs.join(' ');
+
+    // Apply default model from config when --model is not specified
+    if (!options.model) {
+      const configuredModel = config?.models?.[provider] || (provider === 'ollama' ? config?.ollama?.model : null);
+      if (configuredModel) options.model = configuredModel;
     }
-  } else if (provider === 'ollama') {
-    // Ollama now routes through Claude CLI with Ollama base URL
-    command = 'claude';
-    translatedArgs.length = 0; // Clear any accumulated args
 
-    // Environment variables for Ollama-via-Claude
-    env.ANTHROPIC_AUTH_TOKEN = 'ollama';
-    env.ANTHROPIC_BASE_URL = 'http://localhost:11434';
-    env.ANTHROPIC_API_KEY = '';
+    // Build command based on provider
+    let command = '';
 
-    // Claude flags for Ollama compatibility
-    translatedArgs.push('--dangerously-skip-permissions');
+    // Apply common options to translatedArgs
+    if (options.model) {
+      translatedArgs.push('--model', options.model);
+    }
+    if (options.debug) {
+      translatedArgs.push('--debug');
+    }
 
-    // Get model from options or config
-    const ollamaModel = options.model || config?.models?.ollama || config?.ollama?.model || 'llama3.2:3b';
-    translatedArgs.push('--model', ollamaModel);
+    if (provider === 'gemini') {
+      command = 'gemini';
 
-    if (finalPrompt) {
-      translatedArgs.push('-p', finalPrompt);
-    }
-  } else {
-    // Claude
-    command = 'claude';
+      // Gemini-specific translations
+      if (options.yolo) translatedArgs.push('--yolo');
+      if (options.sandbox) translatedArgs.push('--sandbox');
 
-    // Claude-specific translations
-    if (options.yolo) translatedArgs.push('--dangerously-skip-permissions');
-    // Default to --print when prompt is provided and --interactive not specified
-    if (options.print || (finalPrompt && !options.interactive)) {
-      translatedArgs.push('--print');
-    }
-    if (options.mcp) translatedArgs.push('--mcp-config', options.mcp);
+      // Gemini prompt handling
+      if (finalPrompt) {
+        if (options.print) {
+          translatedArgs.push('--prompt', finalPrompt);
+        } else if (options.interactive) {
+          translatedArgs.push('--prompt-interactive', finalPrompt);
+        } else {
+          translatedArgs.push(finalPrompt);
+        }
+      }
+    } else if (provider === 'codex') {
+      command = 'codex';
+
+      // Use non-interactive mode whenever this is a scripted invocation.
+      const shouldUseExec = options.cloudTaskId
+        || options.autonomous
+        || options.daemon
+        || options.print
+        || (finalPrompt && !options.interactive);
+      if (shouldUseExec) {
+        translatedArgs.unshift('exec');
+      }
+
+      // Codex approval/sandbox modes:
+      // - Officially documented: --auto-edit, --full-auto
+      // - Some Codex builds also accept: --dangerously-bypass-approvals-and-sandbox
+      // We only attempt the dangerous bypass for unattended runs, and we add a runtime
+      // retry below if the installed Codex CLI rejects the flag.
+      // If we're using `codex exec`, choose exactly one execution policy:
+      // - default unattended: --full-auto (sandboxed, workspace-write)
+      // - explicit yolo: --dangerously-bypass-approvals-and-sandbox (unsandboxed)
+      //
+      // Codex CLI rejects using both at once.
+      if (shouldUseExec) {
+        if (options.yolo) {
+          translatedArgs.push('--dangerously-bypass-approvals-and-sandbox');
+        } else {
+          translatedArgs.push('--full-auto');
+        }
+      }
 
-    // Claude prompt (positional at end)
-    if (finalPrompt) {
-      translatedArgs.push(finalPrompt);
-    }
-  }
+      if (finalPrompt) {
+        translatedArgs.push(finalPrompt);
+      }
+    } else if (provider === 'ollama') {
+      // Ollama now routes through Claude CLI with Ollama base URL
+      command = 'claude';
+      translatedArgs.length = 0; // Clear any accumulated args
 
-  // Append raw args at the end
-  translatedArgs.push(...rawArgs);
+      // Environment variables for Ollama-via-Claude
+      env.ANTHROPIC_AUTH_TOKEN = 'ollama';
+      env.ANTHROPIC_BASE_URL = 'http://localhost:11434';
+      env.ANTHROPIC_API_KEY = '';
 
-  // ==================== CLOUD INTEGRATION ====================
+      // Claude flags for Ollama compatibility
+      translatedArgs.push('--dangerously-skip-permissions');
 
-  // Cloud context logic:
-  // - agx -p "..." → one-shot, no task
-  // - agx -a -p "..." → create new task in cloud
-  // - agx --cloud-task <id> → continue cloud task (used by daemon)
+      // Get model from options or config
+      const ollamaModel = options.model || config?.models?.ollama || config?.ollama?.model || 'llama3.2:3b';
+      translatedArgs.push('--model', ollamaModel);
 
-  const cloudClient = createCloudClient({ configDir: CONFIG_DIR });
-  const loadCloudConfig = cloudClient.loadConfig;
-  const saveCloudConfig = cloudClient.saveConfig;
-  const cloudRequest = cloudClient.request;
+      if (finalPrompt) {
+        translatedArgs.push('-p', finalPrompt);
+      }
+    } else {
+      // Claude
+      command = 'claude';
 
-  // Best-effort: if local CLI settings are newer than DB settings, up-sync to cloud.
-  // Non-fatal on failure (offline DB, schema missing, etc.).
-  try {
-    const meta = config?.settingsMeta || {};
-    const cliChangedAt = typeof meta.changedAt === 'string' ? meta.changedAt : '';
-    const cliChangedTs = cliChangedAt ? Date.parse(cliChangedAt) : NaN;
-    const cliProvider = config?.defaultProvider || '';
-    const cliModel = cliProvider
-      ? (config?.models?.[cliProvider] || (cliProvider === 'ollama' ? config?.ollama?.model : null))
-      : null;
-
-    if (Number.isFinite(cliChangedTs) && cliProvider && cliModel) {
-      let dbChangedTs = NaN;
-      try {
-        const db = await cloudRequest('GET', '/api/user-settings');
-        const dbChangedAt = typeof db?.settings?.changed_at === 'string' ? db.settings.changed_at : '';
-        dbChangedTs = dbChangedAt ? Date.parse(dbChangedAt) : NaN;
-      } catch { }
+      // Claude-specific translations
+      if (options.yolo) translatedArgs.push('--dangerously-skip-permissions');
+      // Default to --print when prompt is provided and --interactive not specified
+      if (options.print || (finalPrompt && !options.interactive)) {
+        translatedArgs.push('--print');
+      }
+      if (options.mcp) translatedArgs.push('--mcp-config', options.mcp);
 
-      if (!Number.isFinite(dbChangedTs) || cliChangedTs > dbChangedTs) {
-        await cloudRequest('PUT', '/api/user-settings', {
-          default_provider: cliProvider,
-          default_model: cliModel,
-          models: config?.models || { [cliProvider]: cliModel },
-          provenance: 'cli',
-          changed_at: cliChangedAt,
-        });
+      // Claude prompt (positional at end)
+      if (finalPrompt) {
+        translatedArgs.push(finalPrompt);
       }
     }
-  } catch { }
 
-  // --cloud-task: load existing task from cloud (used by daemon)
-  if (options.cloudTaskId) {
-    try {
-      const { task } = await cloudRequest('GET', `/api/tasks/${options.cloudTaskId}`);
+    // Append raw args at the end
+    translatedArgs.push(...rawArgs);
 
-      // Fetch task comments
-      let taskComments = [];
-      try {
-        const commentsResponse = await cloudRequest('GET', `/api/tasks/${options.cloudTaskId}/comments`);
-        taskComments = commentsResponse?.comments || [];
-      } catch (err) {
-        console.error(`${c.yellow}Warning: Could not fetch task comments:${c.reset} ${err.message}`);
-      }
-
-      // Build augmented prompt with task context
-      const plan = extractSection(task.content, 'Plan');
-      const todo = extractSection(task.content, 'Todo') || extractSection(task.content, 'TODO');
-      const checkpoints = extractSection(task.content, 'Checkpoints');
-      const learnings = extractSection(task.content, 'Learnings');
-
-      const stageKey = task?.stage || 'unknown';
-      const stagePrompt = resolveStageObjective(task, stageKey, '');
-      const stageRequirement = buildStageRequirementPrompt({ stage: stageKey, stagePrompt });
-
-      const augmentedPrompt = buildContinueCloudTaskPrompt({
-        task,
-        taskComments,
-        finalPrompt,
-        stagePrompt,
-        stageRequirement,
-        extracted: { plan, todo, checkpoints, learnings },
-      });
+    // ==================== CLOUD INTEGRATION ====================
 
-      const promptIndex = translatedArgs.indexOf(finalPrompt);
-      if (promptIndex !== -1) {
-        translatedArgs[promptIndex] = augmentedPrompt;
-      } else {
-        translatedArgs.push(augmentedPrompt);
-      }
-      saveAugmentedPrompt(augmentedPrompt, options.debug);
+    // Cloud context logic:
+    // - agx -p "..." → one-shot, no task
+    // - agx -a -p "..." → create new task in cloud
+    // - agx --cloud-task <id> → continue cloud task (used by daemon)
 
-      console.log(`${c.dim}[cloud] Loaded task: ${task.title || task.id}${c.reset}\n`);
-    } catch (err) {
-      console.error(`${c.red}Failed to load cloud task:${c.reset} ${err.message}`);
-      process.exit(1);
-    }
-  }
-
-  // Auto-create task in cloud if --autonomous specified
-  if (options.autonomous && finalPrompt && !options.cloudTaskId) {
-    console.log(`${c.dim}[cloud] Creating task...${c.reset}`);
+    const cloudClient = createCloudClient({ configDir: CONFIG_DIR });
+    const loadCloudConfig = cloudClient.loadConfig;
+    const saveCloudConfig = cloudClient.saveConfig;
+    const cloudRequest = cloudClient.request;
 
+    // Best-effort: if local CLI settings are newer than DB settings, up-sync to cloud.
+    // Non-fatal on failure (offline DB, schema missing, etc.).
     try {
-      const cloudConfig = loadCloudConfig();
-      if (cloudConfig?.apiUrl) {
-        const frontmatter = ['status: queued', 'stage: ideation'];
-        frontmatter.push(`engine: ${provider}`);
-
-        const content = `---\n${frontmatter.join('\n')}\n---\n\n# ${finalPrompt}\n`;
+      const meta = config?.settingsMeta || {};
+      const cliChangedAt = typeof meta.changedAt === 'string' ? meta.changedAt : '';
+      const cliChangedTs = cliChangedAt ? Date.parse(cliChangedAt) : NaN;
+      const cliProvider = config?.defaultProvider || '';
+      const cliModel = cliProvider
+        ? (config?.models?.[cliProvider] || (cliProvider === 'ollama' ? config?.ollama?.model : null))
+        : null;
+
+      if (Number.isFinite(cliChangedTs) && cliProvider && cliModel) {
+        let dbChangedTs = NaN;
+        try {
+          const db = await cloudRequest('GET', '/api/user-settings');
+          const dbChangedAt = typeof db?.settings?.changed_at === 'string' ? db.settings.changed_at : '';
+          dbChangedTs = dbChangedAt ? Date.parse(dbChangedAt) : NaN;
+        } catch { }
 
-        const { task } = await cloudRequest('POST', '/api/tasks', { content });
+        if (!Number.isFinite(dbChangedTs) || cliChangedTs > dbChangedTs) {
+          await cloudRequest('PUT', '/api/user-settings', {
+            default_provider: cliProvider,
+            default_model: cliModel,
+            models: config?.models || { [cliProvider]: cliModel },
+            provenance: 'cli',
+            changed_at: cliChangedAt,
+          });
+        }
+      }
+    } catch { }
 
-        console.log(`${c.green}✓${c.reset} Task created in cloud: ${task.id}`);
-        options.cloudTaskId = task.id;
+    // --cloud-task: load existing task from cloud (used by daemon)
+    if (options.cloudTaskId) {
+      try {
+        const { task } = await cloudRequest('GET', `/api/tasks/${options.cloudTaskId}`);
 
-        // Fetch task comments (should be empty for new tasks, but good practice)
+        // Fetch task comments
         let taskComments = [];
         try {
-          const commentsResponse = await cloudRequest('GET', `/api/tasks/${task.id}/comments`);
+          const commentsResponse = await cloudRequest('GET', `/api/tasks/${options.cloudTaskId}/comments`);
           taskComments = commentsResponse?.comments || [];
         } catch (err) {
           console.error(`${c.yellow}Warning: Could not fetch task comments:${c.reset} ${err.message}`);
         }
 
-        // Update prompt with task context
-        const stageKey = task?.stage || 'unknown';
-        const stagePrompt = resolveStageObjective(task, stageKey, '');
-        const stageRequirement = buildStageRequirementPrompt({ stage: stageKey, stagePrompt });
-
-        const augmentedPrompt = buildNewAutonomousCloudTaskPrompt({
-          task,
-          taskComments,
-          finalPrompt,
-          stagePrompt,
-          stageRequirement,
-        });
+        // Build augmented prompt with task context
+        const plan = cloudArtifacts.extractSection(task.content, 'Plan');
+        const todo = cloudArtifacts.extractSection(task.content, 'Todo') || cloudArtifacts.extractSection(task.content, 'TODO');
+        const checkpoints = cloudArtifacts.extractSection(task.content, 'Checkpoints');
+        const learnings = cloudArtifacts.extractSection(task.content, 'Learnings');
+
+	        const stageKey = task?.stage || 'unknown';
+	        const stagePrompt = resolveStageObjective(task, stageKey, '');
+	        const stageRequirement = buildStageRequirementPrompt({ stage: stageKey, stagePrompt });
+	        const runContext = {
+	          run_root: process.env.AGX_RUN_ROOT || '',
+	          plan_dir: process.env.AGX_RUN_PLAN_DIR || '',
+	          artifacts_dir: process.env.AGX_RUN_ARTIFACTS_DIR || '',
+	        };
+
+	        const augmentedPrompt = buildContinueCloudTaskPrompt({
+	          task,
+	          taskComments,
+	          finalPrompt,
+	          stagePrompt,
+	          stageRequirement,
+	          extracted: { plan, todo, checkpoints, learnings },
+	          runContext,
+	        });
 
         const promptIndex = translatedArgs.indexOf(finalPrompt);
         if (promptIndex !== -1) {
@@ -2937,115 +2918,170 @@ EXAMPLES:
         }
         saveAugmentedPrompt(augmentedPrompt, options.debug);
 
-        // Start daemon for autonomous mode
-        if (options.autonomous) {
-          startDaemon();
-          console.log(`${c.green}✓${c.reset} Autonomous mode: daemon running\n`);
-        }
-      } else {
-        console.log(`${c.yellow}Cloud API URL not configured. Set AGX_CLOUD_URL (default http://localhost:41741).${c.reset}`);
-        console.log(`${c.dim}Task not created. Running in one-shot mode.${c.reset}`);
+        console.log(`${c.dim}[cloud] Loaded task: ${task.title || task.id}${c.reset}\n`);
+      } catch (err) {
+        console.error(`${c.red}Failed to load cloud task:${c.reset} ${err.message}`);
+        process.exit(1);
       }
-    } catch (err) {
-      console.error(`${c.yellow}Warning: Could not create cloud task:${c.reset} ${err.message}`);
-      console.log(`${c.dim}Running in one-shot mode.${c.reset}`);
     }
-  }
 
-  // Normal mode - just pass through to provider
-  const useOllamaPipe = provider === 'ollama' && options.ollamaPrompt && command === 'ollama';
-  const shouldRetryCodexBypassFlag = command === 'codex'
-    && translatedArgs.includes('--dangerously-bypass-approvals-and-sandbox');
+    // Auto-create task in cloud if --autonomous specified
+    if (options.autonomous && finalPrompt && !options.cloudTaskId) {
+      console.log(`${c.dim}[cloud] Creating task...${c.reset}`);
 
-  const spawnProvider = (cmd, args, spawnOpts) => {
-    const childProc = spawn(cmd, args, spawnOpts);
-    // Send prompt to Ollama via stdin
-    if (useOllamaPipe && childProc.stdin) {
-      childProc.stdin.write(options.ollamaPrompt);
-      childProc.stdin.end();
-    }
+      try {
+        const cloudConfig = loadCloudConfig();
+        if (cloudConfig?.apiUrl) {
+          const frontmatter = ['status: queued', 'stage: ideation'];
+          frontmatter.push(`engine: ${provider}`);
 
-    childProc.on('exit', (code) => {
-      process.exit(code || 0);
-    });
+          const content = `---\n${frontmatter.join('\n')}\n---\n\n# ${finalPrompt}\n`;
+
+          const { task } = await cloudRequest('POST', '/api/tasks', { content });
+
+          console.log(`${c.green}✓${c.reset} Task created in cloud: ${task.id}`);
+          options.cloudTaskId = task.id;
+
+          // Fetch task comments (should be empty for new tasks, but good practice)
+          let taskComments = [];
+          try {
+            const commentsResponse = await cloudRequest('GET', `/api/tasks/${task.id}/comments`);
+            taskComments = commentsResponse?.comments || [];
+          } catch (err) {
+            console.error(`${c.yellow}Warning: Could not fetch task comments:${c.reset} ${err.message}`);
+          }
+
+          // Update prompt with task context
+          const stageKey = task?.stage || 'unknown';
+          const stagePrompt = resolveStageObjective(task, stageKey, '');
+          const stageRequirement = buildStageRequirementPrompt({ stage: stageKey, stagePrompt });
+
+          const augmentedPrompt = buildNewAutonomousCloudTaskPrompt({
+            task,
+            taskComments,
+            finalPrompt,
+            stagePrompt,
+            stageRequirement,
+          });
+
+          const promptIndex = translatedArgs.indexOf(finalPrompt);
+          if (promptIndex !== -1) {
+            translatedArgs[promptIndex] = augmentedPrompt;
+          } else {
+            translatedArgs.push(augmentedPrompt);
+          }
+          saveAugmentedPrompt(augmentedPrompt, options.debug);
 
-    childProc.on('error', (err) => {
-      if (err.code === 'ENOENT') {
-        console.error(`${c.red}Error:${c.reset} "${cmd}" command not found.`);
-        console.error(`\n${c.dim}Install it first:${c.reset}`);
-        if (cmd === 'claude') {
-          console.error(`  npm install -g @anthropic-ai/claude-code`);
-        } else if (cmd === 'gemini') {
-          console.error(`  npm install -g @google/gemini-cli`);
-        } else if (cmd === 'ollama') {
-          console.error(`  brew install ollama  # macOS`);
-          console.error(`  curl -fsSL https://ollama.ai/install.sh | sh  # Linux`);
-        } else if (cmd === 'codex') {
-          console.error(`  npm install -g @openai/codex`);
+          // Start daemon for autonomous mode
+          if (options.autonomous) {
+            startDaemon();
+            console.log(`${c.green}✓${c.reset} Autonomous mode: daemon running\n`);
+          }
+        } else {
+          console.log(`${c.yellow}Cloud API URL not configured. Set AGX_CLOUD_URL (default http://localhost:41741).${c.reset}`);
+          console.log(`${c.dim}Task not created. Running in one-shot mode.${c.reset}`);
         }
-      } else {
-        console.error(`${c.red}Failed to start ${cmd}:${c.reset}`, err.message);
+      } catch (err) {
+        console.error(`${c.yellow}Warning: Could not create cloud task:${c.reset} ${err.message}`);
+        console.log(`${c.dim}Running in one-shot mode.${c.reset}`);
       }
-      process.exit(1);
-    });
+    }
 
-    return childProc;
-  };
+    // Normal mode - just pass through to provider
+    const useOllamaPipe = provider === 'ollama' && options.ollamaPrompt && command === 'ollama';
+    const shouldRetryCodexBypassFlag = command === 'codex'
+      && translatedArgs.includes('--dangerously-bypass-approvals-and-sandbox');
 
-  if (!shouldRetryCodexBypassFlag) {
-    spawnProvider(command, translatedArgs, {
-      env,
-      stdio: useOllamaPipe ? ['pipe', 'inherit', 'inherit'] : 'inherit',
-      shell: false
-    });
-  } else {
-    // Best-effort compatibility: if the local Codex CLI doesn't recognize
-    // --dangerously-bypass-approvals-and-sandbox, retry without it.
-    const firstArgs = translatedArgs.slice();
-    const retryArgs = translatedArgs.filter((a) => a !== '--dangerously-bypass-approvals-and-sandbox');
-
-    let stderrBuf = '';
-    const maxBuf = 16 * 1024;
-
-    const child = spawn(command, firstArgs, {
-      env,
-      stdio: ['inherit', 'pipe', 'pipe'],
-      shell: false
-    });
+    const spawnProvider = (cmd, args, spawnOpts) => {
+      const childProc = execa(cmd, args, { reject: false, ...spawnOpts });
+      // Send prompt to Ollama via stdin
+      if (useOllamaPipe && childProc.stdin) {
+        childProc.stdin.write(options.ollamaPrompt);
+        childProc.stdin.end();
+      }
 
-    if (child.stdout) {
-      child.stdout.on('data', (d) => process.stdout.write(d));
-    }
-    if (child.stderr) {
-      child.stderr.on('data', (d) => {
-        process.stderr.write(d);
-        if (stderrBuf.length < maxBuf) {
-          stderrBuf += d.toString('utf8').slice(0, maxBuf - stderrBuf.length);
+      childProc.on('exit', (code) => {
+        process.exit(code || 0);
+      });
+
+      childProc.on('error', (err) => {
+        if (err.code === 'ENOENT') {
+          console.error(`${c.red}Error:${c.reset} "${cmd}" command not found.`);
+          console.error(`\n${c.dim}Install it first:${c.reset}`);
+          if (cmd === 'claude') {
+            console.error(`  npm install -g @anthropic-ai/claude-code`);
+          } else if (cmd === 'gemini') {
+            console.error(`  npm install -g @google/gemini-cli`);
+          } else if (cmd === 'ollama') {
+            console.error(`  brew install ollama  # macOS`);
+            console.error(`  curl -fsSL https://ollama.ai/install.sh | sh  # Linux`);
+          } else if (cmd === 'codex') {
+            console.error(`  npm install -g @openai/codex`);
+          }
+        } else {
+          console.error(`${c.red}Failed to start ${cmd}:${c.reset}`, err.message);
         }
+        process.exit(1);
       });
-    }
 
-    child.on('close', (code) => {
-      const failed = (code || 0) !== 0;
-      const looksLikeUnknownFlag = /unknown option|unknown flag|unrecognized option|unexpected argument|invalid option/i.test(stderrBuf)
-        && /dangerously-bypass-approvals-and-sandbox/i.test(stderrBuf);
-      if (failed && looksLikeUnknownFlag) {
-        console.error(`${c.yellow}[agx] Codex CLI rejected --dangerously-bypass-approvals-and-sandbox; retrying without it.${c.reset}`);
-        spawnProvider(command, retryArgs, {
-          env,
-          stdio: 'inherit',
-          shell: false
+      return childProc;
+    };
+
+    if (!shouldRetryCodexBypassFlag) {
+      spawnProvider(command, translatedArgs, {
+        env,
+        stdio: useOllamaPipe ? ['pipe', 'inherit', 'inherit'] : 'inherit',
+        shell: false
+      });
+    } else {
+      // Best-effort compatibility: if the local Codex CLI doesn't recognize
+      // --dangerously-bypass-approvals-and-sandbox, retry without it.
+      const firstArgs = translatedArgs.slice();
+      const retryArgs = translatedArgs.filter((a) => a !== '--dangerously-bypass-approvals-and-sandbox');
+
+      let stderrBuf = '';
+      const maxBuf = 16 * 1024;
+
+      const child = execa(command, firstArgs, {
+        env,
+        stdio: ['inherit', 'pipe', 'pipe'],
+        shell: false,
+        reject: false,
+      });
+
+      if (child.stdout) {
+        child.stdout.on('data', (d) => process.stdout.write(d));
+      }
+      if (child.stderr) {
+        child.stderr.on('data', (d) => {
+          process.stderr.write(d);
+          if (stderrBuf.length < maxBuf) {
+            stderrBuf += d.toString('utf8').slice(0, maxBuf - stderrBuf.length);
+          }
         });
-        return;
       }
-      process.exit(code || 0);
-    });
 
-    child.on('error', (err) => {
-      console.error(`${c.red}Failed to start ${command}:${c.reset}`, err.message);
-      process.exit(1);
-    });
-  }
+      child.on('close', (code) => {
+        const failed = (code || 0) !== 0;
+        const looksLikeUnknownFlag = /unknown option|unknown flag|unrecognized option|unexpected argument|invalid option/i.test(stderrBuf)
+          && /dangerously-bypass-approvals-and-sandbox/i.test(stderrBuf);
+        if (failed && looksLikeUnknownFlag) {
+          console.error(`${c.yellow}[agx] Codex CLI rejected --dangerously-bypass-approvals-and-sandbox; retrying without it.${c.reset}`);
+          spawnProvider(command, retryArgs, {
+            env,
+            stdio: 'inherit',
+            shell: false
+          });
+          return;
+        }
+        process.exit(code || 0);
+      });
+
+      child.on('error', (err) => {
+        console.error(`${c.red}Failed to start ${command}:${c.reset}`, err.message);
+        process.exit(1);
+      });
+    }
 
   } finally {
     process.argv = originalArgv;