@mndrk/agx 1.4.64 → 2.0.0-next.0

package/lib/cli/runCli.js

@@ -72,6 +72,7 @@ const { handleSkillCommand } = require('./skills');
 const { runOnboarding, showConfigStatus, runConfigMenu } = require('./onboarding');
 const { runInteractiveMenu } = require('./interactiveMenu');
 const cloudArtifacts = require('./cloudArtifacts');
+const { classifyTaskExecutionTrack, buildV2RoutingError } = require('./v2TaskRouting');
 const { sendWebhookEvent } = require('../notifications/webhooks');
 const fallbackExtractSection = (markdown, heading) => {
   if (!markdown) return '';
@@ -199,7 +200,7 @@ async function abortIfCancelled(watcher) {
 
 // NOTE: commandExists/spawnCloudTaskProcess/sanitize/truncate/etc are imported above.
 
-async function postTaskLog(taskId, content, logType) {
+async function postTaskLog(taskId, content, logType, nodeId) {
   const cloudConfig = loadCloudConfigFile();
   if (!cloudConfig?.apiUrl) return;
 
@@ -209,6 +210,7 @@ async function postTaskLog(taskId, content, logType) {
     if (!text.trim()) return;
 
     const type = (typeof logType === 'string' && logType.trim()) ? logType.trim() : 'output';
+    const normalizedNodeId = (typeof nodeId === 'string' && nodeId.trim()) ? nodeId.trim() : null;
     await fetch(`${cloudConfig.apiUrl}/api/tasks/${taskId}/logs`, {
       method: 'POST',
       headers: {
@@ -216,7 +218,11 @@ async function postTaskLog(taskId, content, logType) {
         ...(cloudConfig?.token ? { 'Authorization': `Bearer ${cloudConfig.token}` } : {}),
         'x-user-id': cloudConfig.userId || '',
       },
-      body: JSON.stringify({ content: text, log_type: type })
+      body: JSON.stringify({
+        content: text,
+        log_type: type,
+        ...(normalizedNodeId ? { node_id: normalizedNodeId } : {})
+      })
     });
   } catch { }
 }
@@ -351,6 +357,7 @@ const {
   finalizeRunSafe,
   runSingleAgentExecuteVerifyLoop,
   runSwarmExecuteVerifyLoop,
+  runV2GraphExecutionLoop,
   runSwarmAggregate,
   runSwarmLoop,
 } = cloudRunner;
@@ -505,13 +512,22 @@ async function checkOnboarding() {
     const apiStart = Date.now();
     try {
       const makeRequest = async (cfg) => {
+        const internalServiceToken =
+          (process.env.AGX_INTERNAL_SERVICE_TOKEN || process.env.INTERNAL_SERVICE_TOKEN || '').trim();
+        const internalCallerId =
+          (process.env.AGX_EXECUTOR_CALLER_ID || 'executor-engine').trim();
         const options = {
           method,
           headers: {
             'Content-Type': 'application/json',
             'x-user-id': cfg.userId || '',
+            'x-agx-caller': internalCallerId,
+            'x-executor-caller-id': internalCallerId,
           },
         };
+        if (internalServiceToken) {
+          options.headers['x-internal-service-token'] = internalServiceToken;
+        }
         if (cfg?.token) options.headers.Authorization = `Bearer ${cfg.token}`;
         if (body) options.body = JSON.stringify(body);
         const response = await fetch(url, options);
@@ -703,8 +719,37 @@ async function checkOnboarding() {
     }
   }
 
+  function extractGraphFromTaskGraphResponse(response) {
+    if (!response || typeof response !== 'object') return null;
+    if (response.graph && typeof response.graph === 'object') return response.graph;
+    if (response.execution_graph && typeof response.execution_graph === 'object') return response.execution_graph;
+    if (response.executionGraph && typeof response.executionGraph === 'object') return response.executionGraph;
+    return response;
+  }
+
+  async function hydrateTaskWithGraphContext(taskId, task) {
+    if (!task || typeof task !== 'object') return task;
+
+    try {
+      const graphResponse = await cloudRequest('GET', `/api/tasks/${taskId}/graph`);
+      const graph = extractGraphFromTaskGraphResponse(graphResponse);
+      if (!graph || typeof graph !== 'object') return task;
+
+      const graphId = String(graph.id || graph.graph_id || '').trim();
+      const mode = String(graph.mode || '').trim();
+      return {
+        ...task,
+        ...(graphId ? { graph_id: graphId } : {}),
+        ...(mode ? { graph_mode: mode } : {}),
+        execution_graph: graph,
+      };
+    } catch {
+      return task;
+    }
+  }
+
   async function runTaskInline(rawTaskId, options = {}) {
-    const { resetFirst = false, forceSwarm = false, fromStage = null } = options;
+    const { resetFirst = false, forceSwarm = false, fromStage = null, resumePrompt = '' } = options;
     const taskId = await resolveTaskId(rawTaskId);
 
     if (fromStage) {
@@ -719,6 +764,39 @@ async function checkOnboarding() {
       });
     }
 
+    const ensureDependenciesReady = async () => {
+      let depGraph = null;
+      try {
+        depGraph = await cloudRequest('GET', `/api/tasks/${taskId}/dependencies`);
+      } catch {
+        return;
+      }
+
+      const deps = Array.isArray(depGraph?.depends_on_tasks) ? depGraph.depends_on_tasks : [];
+      if (!deps.length) return;
+
+      const missing = deps.filter((dep) => String(dep?.status || '').toLowerCase() !== 'completed');
+      if (!missing.length) return;
+
+      const preview = missing
+        .slice(0, 3)
+        .map((dep) => {
+          const label = String(dep?.slug || dep?.title || dep?.id || '(unknown)').trim();
+          const status = String(dep?.status || '').trim();
+          return status ? `${label} (${status})` : label;
+        })
+        .join(', ');
+      const extra = missing.length > 3 ? ` +${missing.length - 3} more` : '';
+      const reason = `Waiting on dependencies: ${preview}${extra}`;
+
+      try {
+        await cloudRequest('PATCH', `/api/tasks/${taskId}`, { status: 'blocked' });
+      } catch { }
+
+      throw new Error(reason);
+    };
+    await ensureDependenciesReady();
+
     // NOTE: `agx run` should not implicitly start the embedded orchestrator worker.
     // If you want the worker running, start it explicitly via `agx daemon start`.
 
@@ -736,7 +814,12 @@ async function checkOnboarding() {
       throw new Error(`Task not found: ${taskId}`);
     }
 
-    const effectiveTask = forceSwarm ? { ...task, swarm: true } : task;
+    const hydratedTask = await hydrateTaskWithGraphContext(taskId, task);
+    const effectiveTask = forceSwarm ? { ...hydratedTask, swarm: true } : { ...hydratedTask };
+    const normalizedResumePrompt = typeof resumePrompt === 'string' ? resumePrompt.trim() : '';
+    if (normalizedResumePrompt) {
+      effectiveTask.prompt = normalizedResumePrompt;
+    }
     console.log(`${c.green}✓${c.reset} Running task inline`);
     console.log(`${c.dim}Task: ${taskId}${c.reset}`);
 
@@ -786,6 +869,10 @@ async function checkOnboarding() {
       throw new Error('Queue returned task without id');
     }
 
+    // Always hydrate graph context before routing. Queue payloads can omit graph fields,
+    // which would incorrectly route v2 tasks into legacy execution paths.
+    task = await hydrateTaskWithGraphContext(taskId, task);
+
     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);
@@ -806,7 +893,10 @@ async function checkOnboarding() {
     console.log(`${c.dim}[daemon] picked ${taskId} (${task?.stage || 'unknown'}) via ${provider}${model ? `/${model}` : ''}${c.reset}`);
 
     let decisionPayload;
+    let runResult = null;
     try {
+      const executionTrack = classifyTaskExecutionTrack(task);
+
       if (localArtifacts) {
         // Derive project slug from task, or auto-detect from cwd
         let derivedProjectSlug = task?.project_slug || task?.project?.slug || task?.project_name || task?.project?.name;
@@ -908,22 +998,13 @@ async function checkOnboarding() {
         // Mark local task as running once before iterating.
         await storage.updateTaskState(projectSlug, taskSlug, { status: 'running' });
 
-        // Execute+verify loop runs per-iteration local runs under the mapped cloud stage.
+        // v2 tasks execute through graph runtime path; legacy tasks use stage execute/verify loops.
         let loopResult;
-        if (task?.swarm) {
-          loopResult = await runSwarmExecuteVerifyLoop({
-            taskId,
-            task,
-            logger,
-            storage,
-            projectSlug,
-            taskSlug,
-            stageLocal,
-            initialPromptContext: fullPromptContext,
-            cancellationWatcher,
-          });
-        } else {
-          loopResult = await runSingleAgentExecuteVerifyLoop({
+        if (executionTrack.track === 'v2') {
+          if (task?.swarm) {
+            throw new Error(`[v2-required] Swarm mode is not supported for v2 graph tasks (task ${taskId}).`);
+          }
+          loopResult = await runV2GraphExecutionLoop({
             taskId,
             task,
             provider,
@@ -935,7 +1016,36 @@ async function checkOnboarding() {
             stageLocal,
             initialPromptContext: fullPromptContext,
             cancellationWatcher,
+            cloudRequest,
           });
+        } else {
+          if (task?.swarm) {
+            loopResult = await runSwarmExecuteVerifyLoop({
+              taskId,
+              task,
+              logger,
+              storage,
+              projectSlug,
+              taskSlug,
+              stageLocal,
+              initialPromptContext: fullPromptContext,
+              cancellationWatcher,
+            });
+          } else {
+            loopResult = await runSingleAgentExecuteVerifyLoop({
+              taskId,
+              task,
+              provider,
+              model,
+              logger,
+              storage,
+              projectSlug,
+              taskSlug,
+              stageLocal,
+              initialPromptContext: fullPromptContext,
+              cancellationWatcher,
+            });
+          }
         }
 
         lastRun = loopResult?.lastRun || null;
@@ -946,29 +1056,33 @@ async function checkOnboarding() {
           { 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 || '' }
-          );
+        if (executionTrack.track === 'v2') {
+          throw new Error(buildV2RoutingError(task, executionTrack));
         } else {
-          runResult = await runSingleAgentLoop({
-            taskId,
-            task,
-            provider,
-            model,
-            logger,
-            artifacts: null,
-            cancellationWatcher,
-          });
-          decisionPayload = normalizeDaemonDecision(
-            runResult?.decision,
-            runResult?.code === 0 ? 'Single-agent execution completed.' : 'Single-agent execution failed.',
-            { error: task?.error || '' }
-          );
+          // 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 || '' }
+            );
+          } else {
+            runResult = await runSingleAgentLoop({
+              taskId,
+              task,
+              provider,
+              model,
+              logger,
+              artifacts: null,
+              cancellationWatcher,
+            });
+            decisionPayload = normalizeDaemonDecision(
+              runResult?.decision,
+              runResult?.code === 0 ? 'Single-agent execution completed.' : 'Single-agent execution failed.',
+              { error: task?.error || '' }
+            );
+          }
         }
       }
     } catch (err) {
@@ -1032,7 +1146,11 @@ async function checkOnboarding() {
           newStage = refreshed?.stage || null;
         } catch { }
       }
-      const patch = buildCloudTaskTerminalPatch({ decision: decisionPayload?.decision, newStage });
+      const patch = buildCloudTaskTerminalPatch({
+        decision: decisionPayload?.decision,
+        newStage,
+        previousStage: task?.stage,
+      });
       if (patch) {
         await cloudRequest('PATCH', `/api/tasks/${taskId}`, patch);
       }
@@ -1234,6 +1352,18 @@ async function checkOnboarding() {
     'o': 'ollama', 'ol': 'ollama', 'ollama': 'ollama'
   };
 
+  function normalizeApprovalMode(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    if (!normalized) return null;
+    if (normalized === 'auto' || normalized === 'auto_approve' || normalized === 'auto-approve' || normalized === 'automatic') {
+      return 'auto';
+    }
+    if (normalized === 'manual' || normalized === 'human' || normalized === 'require_approval' || normalized === 'require-approval') {
+      return 'manual';
+    }
+    return null;
+  }
+
   function collectFlagValues(args, flag) {
     const values = [];
     const consumedIndices = new Set();
@@ -1251,6 +1381,11 @@ async function checkOnboarding() {
     return { values, consumedIndices };
   }
 
+  function printProjectFlagDeprecationWarning({ jsonMode = false } = {}) {
+    if (jsonMode) return;
+    console.log(`${c.yellow}Warning:${c.reset} --project is deprecated. Use --project-slug <slug> or --project-id <uuid>.`);
+  }
+
   // ============================================================
   // LOCAL-FIRST CLI COMMANDS
   // These commands use ~/.agx/projects/ filesystem storage.
@@ -1274,7 +1409,7 @@ async function checkOnboarding() {
   // Local-first command handlers live in lib/commands/local.js.
 
   // ============================================================
-  // agx new "<goal>" [--provider c|g|o|x] [--project <slug>] [--run] [--json]
+  // agx new "<goal>" [--provider c|g|o|x] [--project-slug <slug>|--project-id <uuid>] [--approval manual|auto] [--run] [--json]
   // Creates a new task via cloud API
   // ============================================================
   if (cmd === 'new') {
@@ -1308,10 +1443,25 @@ async function checkOnboarding() {
     }
     const modelArgProvided = model !== null;
     let projectSlug = null;
+    let projectId = null;
+    let usedDeprecatedProjectFlag = false;
     const projectIdx = args.findIndex(a => a === '--project');
     if (projectIdx !== -1 && args[projectIdx + 1]) {
       projectSlug = args[projectIdx + 1];
-    } else {
+      usedDeprecatedProjectFlag = true;
+    }
+    const projectSlugIdx = args.findIndex(a => a === '--project-slug');
+    if (projectSlugIdx !== -1 && args[projectSlugIdx + 1]) {
+      projectSlug = args[projectSlugIdx + 1];
+    }
+    const projectIdIdx = args.findIndex(a => a === '--project-id');
+    if (projectIdIdx !== -1 && args[projectIdIdx + 1]) {
+      projectId = args[projectIdIdx + 1];
+    }
+    if (usedDeprecatedProjectFlag) {
+      printProjectFlagDeprecationWarning({ jsonMode });
+    }
+    if (!projectSlug && !projectId) {
       // Auto-detect project from cwd (git repo folder name or current folder)
       const cwd = process.cwd();
       let dir = cwd;
@@ -1321,7 +1471,7 @@ async function checkOnboarding() {
         try {
           const stat = require('fs').statSync(gitPath);
           if (stat.isDirectory() || stat.isFile()) {
-            projectSlug = storage.slugify(require('path').basename(dir));
+            projectSlug = slugify(require('path').basename(dir));
             foundGit = true;
             break;
           }
@@ -1329,7 +1479,7 @@ async function checkOnboarding() {
         dir = require('path').dirname(dir);
       }
       if (!foundGit) {
-        projectSlug = storage.slugify(require('path').basename(cwd));
+        projectSlug = slugify(require('path').basename(cwd));
       }
     }
     let ticketType = null;
@@ -1338,6 +1488,32 @@ async function checkOnboarding() {
       const resolvedType = normalizeTicketType(args[ticketTypeIdx + 1]);
       ticketType = resolvedType === 'spike' ? 'spike' : 'task';
     }
+    let approvalMode = 'manual';
+    for (let i = 1; i < args.length; i += 1) {
+      if (args[i] === '--auto-approve') {
+        approvalMode = 'auto';
+        continue;
+      }
+      if (args[i] === '--manual-approve') {
+        approvalMode = 'manual';
+        continue;
+      }
+      if (args[i] === '--approval' || args[i] === '--approval-mode') {
+        const raw = args[i + 1];
+        const resolved = normalizeApprovalMode(raw);
+        if (!resolved) {
+          if (jsonMode) {
+            console.log(JSON.stringify({ error: 'invalid_approval_mode', value: raw || null }));
+          } else {
+            console.log(`${c.red}Invalid approval mode:${c.reset} ${raw || '(missing)'}`);
+            console.log(`${c.dim}Valid: manual, auto${c.reset}`);
+          }
+          process.exit(1);
+        }
+        approvalMode = resolved;
+        i += 1;
+      }
+    }
     let templateName = null;
     const templateIdx = args.findIndex(a => a === '--template');
     if (templateIdx !== -1 && args[templateIdx + 1]) {
@@ -1354,9 +1530,15 @@ async function checkOnboarding() {
       '--model',
       '-m',
       '--project',
+      '--project-slug',
+      '--project-id',
       '--type',
       '--ticket-type',
       '--template',
+      '--approval',
+      '--approval-mode',
+      '--auto-approve',
+      '--manual-approve',
     ];
     const goalParts = [];
     for (let i = 1; i < args.length; i++) {
@@ -1367,8 +1549,11 @@ async function checkOnboarding() {
         if (args[i] === '--provider' || args[i] === '-P') i++;
         if (args[i] === '--model' || args[i] === '-m') i++;
         if (args[i] === '--project') i++;
+        if (args[i] === '--project-slug') i++;
+        if (args[i] === '--project-id') i++;
         if (args[i] === '--type' || args[i] === '--ticket-type') i++;
         if (args[i] === '--template') i++;
+        if (args[i] === '--approval' || args[i] === '--approval-mode') i++;
         continue;
       }
       goalParts.push(args[i]);
@@ -1377,9 +1562,9 @@ async function checkOnboarding() {
 
     if (!goalText) {
       if (jsonMode) {
-        console.log(JSON.stringify({ error: 'missing_goal', usage: 'agx new "<goal>" [--provider c] [--project <slug>] [--type spike|task] [--run] [--depends-on <task-id>]' }));
+        console.log(JSON.stringify({ error: 'missing_goal', usage: 'agx new "<goal>" [--provider c] [--project-slug <slug>|--project-id <uuid>] [--type spike|task] [--approval manual|auto] [--run] [--depends-on <task-id>]' }));
       } else {
-        console.log(`${c.red}Usage:${c.reset} agx new "<goal>" [--provider c|g|o|x] [--project <slug>] [--type spike|task] [--run] [--depends-on <task-id>]`);
+        console.log(`${c.red}Usage:${c.reset} agx new "<goal>" [--provider c|g|o|x] [--project-slug <slug>|--project-id <uuid>] [--type spike|task] [--approval manual|auto] [--run] [--depends-on <task-id>]`);
       }
       process.exit(1);
     }
@@ -1412,14 +1597,14 @@ async function checkOnboarding() {
     model = defaults.model;
 
     try {
-      let projectId = null;
-      if (projectSlug) {
+      if (projectSlug || projectId) {
         try {
-          const project = await resolveProjectByIdentifier(projectSlug);
+          const project = await resolveProjectByIdentifier(projectId || projectSlug);
           projectId = project?.id || null;
+          projectSlug = project?.slug || projectSlug;
         } catch (err) {
-          const slug = projectSlug.trim();
-          const projectErr = `Project ${slug} not found. Run agx project list to see available projects.`;
+          const identifier = String(projectId || projectSlug || '').trim();
+          const projectErr = `Project ${identifier} not found. Run agx project list to see available projects.`;
           if (jsonMode) {
             console.log(JSON.stringify({ error: projectErr }));
           } else {
@@ -1430,7 +1615,7 @@ async function checkOnboarding() {
       }
 
       // Create task via cloud API
-      const frontmatter = ['status: queued', 'stage: ideation'];
+      const frontmatter = ['status: queued', 'stage: intake'];
       frontmatter.push(`engine: ${provider}`);
       frontmatter.push(`provider: ${provider}`);
       if (projectSlug) frontmatter.push(`project: ${projectSlug}`);
@@ -1438,6 +1623,10 @@ async function checkOnboarding() {
       if (model) frontmatter.push(`model: ${model}`);
       if (ticketType) frontmatter.push(`type: ${ticketType}`);
       if (template) frontmatter.push(`template: ${template.slug}`);
+      frontmatter.push(`approval_mode: ${approvalMode}`);
+      if (dependsOnValues.length) {
+        frontmatter.push(`depends_on: ${JSON.stringify(dependsOnValues)}`);
+      }
 
       let bodyContent = `# ${goalText}\n`;
       if (template) {
@@ -1506,6 +1695,7 @@ async function checkOnboarding() {
       args,
       ctx: {
         c,
+        cloudRequest,
         loadCloudConfig,
         runCloudDaemonLoop,
         startDaemon,
@@ -1609,7 +1799,13 @@ async function checkOnboarding() {
     if (handledWorkflow) return true;
   }
 
-  // agx new "<task description>" [--project <name>] [--priority <n>] [--engine <name>]
+  {
+    const { maybeHandleChatCommand } = require('../commands/chat');
+    const handledChat = await maybeHandleChatCommand({ cmd, args, ctx: { c } });
+    if (handledChat) return true;
+  }
+
+  // agx new "<task description>" [--project <name>] [--priority <n>] [--engine <name>] [--approval manual|auto]
   if (cmd === 'new' || cmd === 'push') {
     const config = loadCloudConfig();
     if (!config) {
@@ -1620,13 +1816,15 @@ async function checkOnboarding() {
     const { values: dependsOnValues, consumedIndices: dependsOnSkipIndices } = collectFlagValues(args, '--depends-on');
 
     // Parse flags
-    let projectSlug = null, projectId = null, priority = null, engine = null, provider = null, model = null, ticketType = null, createdBy = 'user';
+    let projectSlug = null, projectId = null, priority = null, engine = null, provider = null, model = null, ticketType = null, createdBy = 'user', approvalMode = 'manual';
+    let usedDeprecatedProjectFlag = false;
     const taskParts = [];
     for (let i = 1; i < args.length; i++) {
       if (dependsOnSkipIndices.has(i)) {
         continue;
       }
       if (args[i] === '--project' || args[i] === '-p') {
+        usedDeprecatedProjectFlag = true;
         projectSlug = args[++i];
       } else if (args[i] === '--project-slug') {
         projectSlug = args[++i];
@@ -1642,6 +1840,19 @@ async function checkOnboarding() {
         model = args[++i];
       } else if (args[i] === '--type' || args[i] === '--ticket-type') {
         ticketType = normalizeTicketType(args[++i]);
+      } else if (args[i] === '--approval' || args[i] === '--approval-mode') {
+        const raw = args[++i];
+        const resolved = normalizeApprovalMode(raw);
+        if (!resolved) {
+          console.log(`${c.red}Invalid approval mode:${c.reset} ${raw || '(missing)'}`);
+          console.log(`${c.dim}Valid: manual, auto${c.reset}`);
+          process.exit(1);
+        }
+        approvalMode = resolved;
+      } else if (args[i] === '--auto-approve') {
+        approvalMode = 'auto';
+      } else if (args[i] === '--manual-approve') {
+        approvalMode = 'manual';
       } else if (args[i] === '--ai') {
         createdBy = 'ai';
       } else {
@@ -1651,23 +1862,28 @@ async function checkOnboarding() {
 
     const taskDesc = taskParts.join(' ');
     if (!taskDesc) {
-      console.log(`${c.yellow}Usage:${c.reset} agx new "<task>" [--project <slug>] [--project-slug <slug>] [--project-id <uuid>] [--priority n] [--engine claude|gemini|ollama|codex] [--type spike|task] [--depends-on <task-id>]`);
+      console.log(`${c.yellow}Usage:${c.reset} agx new "<task>" [--project <slug>] [--project-slug <slug>] [--project-id <uuid>] [--priority n] [--engine claude|gemini|ollama|codex] [--type spike|task] [--approval manual|auto] [--depends-on <task-id>]`);
       process.exit(1);
     }
 
-    if (projectSlug) {
+    if (usedDeprecatedProjectFlag) {
+      printProjectFlagDeprecationWarning();
+    }
+
+    if (projectSlug || projectId) {
       try {
-        const project = await resolveProjectByIdentifier(projectSlug);
+        const project = await resolveProjectByIdentifier(projectId || projectSlug);
         projectId = project?.id || projectId;
+        projectSlug = project?.slug || projectSlug;
       } catch (err) {
-        const slug = projectSlug.trim();
-        console.log(`${c.red}Project ${slug} not found. Run agx project list to see available projects.${c.reset}`);
+        const identifier = String(projectId || projectSlug || '').trim();
+        console.log(`${c.red}Project ${identifier} not found. Run agx project list to see available projects.${c.reset}`);
         process.exit(1);
       }
     }
 
     // Build markdown content
-    const frontmatter = ['status: queued', 'stage: ideation'];
+    const frontmatter = ['status: queued', 'stage: intake'];
     if (projectSlug) frontmatter.push(`project: ${projectSlug}`);
     if (projectId) frontmatter.push(`project_id: ${projectId}`);
     if (priority) frontmatter.push(`priority: ${priority}`);
@@ -1677,6 +1893,10 @@ async function checkOnboarding() {
     if (ticketType) frontmatter.push(`type: ${ticketType}`);
     if (createdBy !== 'user') frontmatter.push(`created_by: ${createdBy}`);
     if (!engine && provider) frontmatter.push(`engine: ${provider}`);
+    frontmatter.push(`approval_mode: ${approvalMode}`);
+    if (dependsOnValues.length) {
+      frontmatter.push(`depends_on: ${JSON.stringify(dependsOnValues)}`);
+    }
 
     const content = `---\n${frontmatter.join('\n')}\n---\n\n# ${taskDesc}\n`;
 
@@ -1691,7 +1911,7 @@ async function checkOnboarding() {
       if (task.slug) {
         console.log(`  Slug: ${task.slug}`);
       }
-      console.log(`  Stage: ${task.stage || 'ideation'}`);
+      console.log(`  Stage: ${task.stage || 'intake'}`);
       if (projectSlug) console.log(`  Project: ${projectSlug}`);
       if (projectId) console.log(`  Project ID: ${projectId}`);
       console.log(`${c.dim}Use: agx run ${task.slug || task.id}${c.reset}`);
@@ -1801,6 +2021,213 @@ async function checkOnboarding() {
     process.exit(0);
   }
 
+  // agx resume [<project>:]<task> [--from <checkpoint-id>] [--git-restore] [--dry-run]
+  // Resume execution from last checkpoint (or specified checkpoint)
+  if (cmd === 'resume') {
+    const { getHead, readCheckpointsFile } = require('../storage/checkpoints');
+    const { restoreGitState } = require('../storage/git');
+    const { buildResumePrompt } = require('../prompts/resume');
+
+    let taskIdentifier = null;
+    let fromCheckpointId = null;
+    let gitRestore = false;
+    let dryRun = false;
+
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === '--from' || args[i] === '-f') {
+        fromCheckpointId = args[++i];
+      } else if (args[i] === '--git-restore' || args[i] === '--restore-git') {
+        gitRestore = true;
+      } else if (args[i] === '--dry-run' || args[i] === '-n') {
+        dryRun = true;
+      } else if (!args[i].startsWith('-')) {
+        taskIdentifier = args[i];
+      }
+    }
+
+    if (!taskIdentifier) {
+      console.log(`${c.yellow}Usage:${c.reset} agx resume [<project>:]<task>`);
+      console.log(`${c.dim}Options:${c.reset}`);
+      console.log(`  --from <id>      Resume from specific checkpoint (default: latest)`);
+      console.log(`  --git-restore    Restore git state from checkpoint`);
+      console.log(`  --dry-run        Show what would be resumed without executing`);
+      process.exit(1);
+    }
+
+    // Parse project:task or just task
+    let projectSlug = null;
+    let taskSlug = null;
+    if (taskIdentifier.includes(':')) {
+      [projectSlug, taskSlug] = taskIdentifier.split(':');
+    } else {
+      // Try to infer project from current directory or use default
+      taskSlug = taskIdentifier;
+      // Look for most recent project with this task
+      const projectsDir = path.join(os.homedir(), '.agx', 'projects');
+      if (fs.existsSync(projectsDir)) {
+        const projects = fs.readdirSync(projectsDir).filter(p => {
+          const taskDir = path.join(projectsDir, p, 'tasks', taskSlug);
+          return fs.existsSync(taskDir);
+        });
+        if (projects.length === 1) {
+          projectSlug = projects[0];
+        } else if (projects.length > 1) {
+          console.log(`${c.yellow}Multiple projects contain task '${taskSlug}':${c.reset}`);
+          projects.forEach(p => console.log(`  - ${p}:${taskSlug}`));
+          console.log(`${c.dim}Specify project: agx resume <project>:${taskSlug}${c.reset}`);
+          process.exit(1);
+        }
+      }
+    }
+
+    if (!projectSlug || !taskSlug) {
+      console.log(`${c.red}✗${c.reset} Could not resolve task '${taskIdentifier}'`);
+      console.log(`${c.dim}Use format: agx resume <project>:<task>${c.reset}`);
+      process.exit(1);
+    }
+
+    try {
+      // Load checkpoint
+      let checkpoint = null;
+      if (fromCheckpointId) {
+        const checkpointsData = await readCheckpointsFile(projectSlug, taskSlug);
+        checkpoint = checkpointsData.history.find(cp => cp.id === fromCheckpointId);
+        if (!checkpoint) {
+          console.log(`${c.red}✗${c.reset} Checkpoint '${fromCheckpointId}' not found`);
+          const available = checkpointsData.history.slice(0, 5).map(cp => cp.id).join(', ');
+          if (available) {
+            console.log(`${c.dim}Available: ${available}${c.reset}`);
+          }
+          process.exit(1);
+        }
+      } else {
+        checkpoint = await getHead(projectSlug, taskSlug);
+      }
+
+      if (!checkpoint) {
+        console.log(`${c.red}✗${c.reset} No checkpoints found for ${projectSlug}:${taskSlug}`);
+        console.log(`${c.dim}Task must have emitted [checkpoint: ...] markers to resume${c.reset}`);
+        process.exit(1);
+      }
+
+      // Display checkpoint info
+      console.log(`${c.bold}Resume from Checkpoint${c.reset}\n`);
+      console.log(`  ${c.dim}ID:${c.reset}      ${checkpoint.id}`);
+      console.log(`  ${c.dim}Created:${c.reset} ${checkpoint.createdAt || 'unknown'}`);
+      if (checkpoint.label) {
+        console.log(`  ${c.dim}Label:${c.reset}   ${checkpoint.label}`);
+      }
+      if (checkpoint.iteration !== undefined) {
+        console.log(`  ${c.dim}Iter:${c.reset}    ${checkpoint.iteration}`);
+      }
+
+      // Show git state if present
+      if (checkpoint.git) {
+        const { sha, branch, dirty, patchFile } = checkpoint.git;
+        console.log(`\n  ${c.dim}Git:${c.reset}     ${branch || 'detached'} @ ${(sha || '').slice(0, 7)}${dirty ? ' (dirty)' : ''}`);
+        if (patchFile) {
+          console.log(`  ${c.dim}Patch:${c.reset}   ${patchFile}`);
+        }
+      }
+
+      // Build resume prompt
+      const resumePrompt = buildResumePrompt(checkpoint);
+      console.log(`\n${c.bold}Resume Prompt${c.reset} (${resumePrompt.length} chars)\n`);
+      console.log(c.dim + '─'.repeat(60) + c.reset);
+      console.log(resumePrompt.slice(0, 1500) + (resumePrompt.length > 1500 ? '\n...(truncated)' : ''));
+      console.log(c.dim + '─'.repeat(60) + c.reset);
+
+      if (dryRun) {
+        console.log(`\n${c.yellow}Dry run - no execution${c.reset}`);
+        process.exit(0);
+      }
+
+      // Optionally restore git state
+      if (gitRestore && checkpoint.git) {
+        console.log(`\n${c.dim}Restoring git state...${c.reset}`);
+        try {
+          const cwd = process.cwd();
+          restoreGitState(checkpoint.git, cwd, { force: false });
+          console.log(`${c.green}✓${c.reset} Git state restored`);
+        } catch (err) {
+          console.log(`${c.yellow}⚠${c.reset} Git restore failed: ${err.message}`);
+          console.log(`${c.dim}Continuing without git restore. Use --force if working tree has changes.${c.reset}`);
+        }
+      }
+
+      // Continue execution with resume prompt
+      if (!dryRun) {
+        // Load task.json to get cloud task ID
+        const storage = require('../storage');
+        const taskJsonPath = path.join(storage.projectRoot(projectSlug), taskSlug, 'task.json');
+        let cloudTaskId = null;
+        
+        if (fs.existsSync(taskJsonPath)) {
+          try {
+            const taskData = JSON.parse(fs.readFileSync(taskJsonPath, 'utf8'));
+            cloudTaskId = taskData?.cloud?.task_id;
+          } catch {
+            // Ignore parse errors
+          }
+        }
+        
+        if (!cloudTaskId) {
+          console.log(`${c.yellow}⚠${c.reset} No cloud task ID found. Running locally.`);
+          // For now, just use the resume prompt with the default provider
+          const provider = 'claude';
+          console.log(`\n${c.dim}Executing with ${provider}...${c.reset}`);
+          
+          try {
+            const { executeTask } = require('../executor');
+            await executeTask({
+              taskId: `${projectSlug}:${taskSlug}`,
+              title: checkpoint.objective || 'Resume task',
+              content: resumePrompt,
+              stage: 'execute',
+              engine: provider,
+              projectSlug,
+              taskSlug,
+              iteration: (checkpoint.iteration || 0) + 1,
+              objective: checkpoint.objective,
+              constraints: checkpoint.constraints,
+              dontRepeat: checkpoint.dontRepeat,
+              verifyFailures: checkpoint.verifyFailures || 0,
+              plan: checkpoint.plan,
+              criteria: checkpoint.criteria,
+              onLog: (msg) => console.log(msg),
+              onProgress: () => {},
+            });
+            console.log(`${c.green}✓${c.reset} Resume execution completed`);
+          } catch (err) {
+            console.log(`${c.red}✗${c.reset} Execution failed: ${err.message}`);
+            process.exit(1);
+          }
+        } else {
+          // Use cloud task flow
+          console.log(`\n${c.dim}Resuming cloud task ${cloudTaskId.slice(0, 8)}...${c.reset}`);
+          try {
+            const exitCode = await runTaskInline(cloudTaskId, {
+              resumePrompt,
+              fromStage: 'execution',
+            });
+            process.exit(exitCode);
+          } catch (err) {
+            console.log(`${c.red}✗${c.reset} Resume failed: ${err.message}`);
+            process.exit(1);
+          }
+        }
+      }
+
+      process.exit(0);
+    } catch (err) {
+      console.log(`${c.red}✗${c.reset} Resume failed: ${err.message}`);
+      if (process.env.DEBUG) {
+        console.error(err);
+      }
+      process.exit(1);
+    }
+  }
+
   // agx retry <taskId> [--task <id>] [--swarm] [--async]
   if (cmd === 'retry' || (cmd === 'task' && args[1] === 'retry')) {
     const runArgs = cmd === 'task' ? args.slice(1) : args;
@@ -1820,7 +2247,7 @@ async function checkOnboarding() {
       } else if (runArgs[i] === '--from') {
         const candidate = runArgs[++i];
         if (!candidate || candidate.startsWith('-')) {
-          console.log(`${c.red}✗${c.reset} --from requires a stage name (ideation/planning/execution/verification)`);
+          console.log(`${c.red}✗${c.reset} --from requires a stage name (intake/planning/execution/verification)`);
           process.exit(1);
         }
         fromStageArg = candidate;
@@ -1834,7 +2261,7 @@ async function checkOnboarding() {
       logExecutionFlow('retry command', 'output', 'missing task id');
       console.log(`${c.yellow}Usage:${c.reset} agx retry <taskId> [--from <stage>] [--task <id>] [--swarm] [--async]`);
       console.log(`${c.dim}   or:${c.reset} agx task retry <taskId> [--from <stage>] [--task <id>] [--swarm] [--async]`);
-      console.log(`${c.dim}--from: Restart from ideation/planning/execution/verification${c.reset}`);
+      console.log(`${c.dim}--from: Restart from intake/planning/execution/verification${c.reset}`);
       console.log(`${c.dim}--async: Reset status and let daemon handle (non-blocking)${c.reset}`);
       process.exit(1);
     }
@@ -1940,7 +2367,7 @@ async function checkOnboarding() {
           : (task.model || '');
         const modelSuffix = displayModel ? `/${displayModel}` : '';
         const swarmSuffix = task.swarm ? ' (swarm)' : '';
-        console.log(`    ${c.dim}${task.stage || 'ideation'} · ${displayProvider}${modelSuffix}${swarmSuffix} · ${task.id.slice(0, 8)}${c.reset}`);
+        console.log(`    ${c.dim}${task.stage || 'intake'} · ${displayProvider}${modelSuffix}${swarmSuffix} · ${task.id.slice(0, 8)}${c.reset}`);
         idx++;
       }
     } catch (err) {
@@ -2015,7 +2442,11 @@ async function checkOnboarding() {
 
       // If this completion transitioned the task into a terminal stage, align `status` too.
       try {
-        const patch = buildCloudTaskTerminalPatch({ newStage: stageAfter });
+        const patch = buildCloudTaskTerminalPatch({
+          decision: 'done',
+          newStage: stageAfter,
+          previousStage: existingStage,
+        });
         if (patch) {
           await cloudRequest('PATCH', `/api/tasks/${resolvedTaskId}`, patch);
         }
@@ -2068,7 +2499,7 @@ async function checkOnboarding() {
         } else if (data.type === 'log') {
           console.log(`${c.blue}[${timestamp}] LOG${c.reset} ${data.log?.content || '(empty)'}`);
         } else if (data.type === 'INSERT') {
-          console.log(`${c.green}[${timestamp}] NEW${c.reset} ${data.task?.title || 'Untitled'} → ${data.task?.stage || 'ideation'}`);
+          console.log(`${c.green}[${timestamp}] NEW${c.reset} ${data.task?.title || 'Untitled'} → ${data.task?.stage || 'intake'}`);
         } else if (data.type === 'UPDATE') {
           console.log(`${c.yellow}[${timestamp}] UPD${c.reset} ${data.task?.title || 'Untitled'} → ${data.task?.stage || '?'} (${data.task?.status || '?'})`);
         } else if (data.type === 'DELETE') {
@@ -2500,6 +2931,209 @@ async function checkOnboarding() {
     process.exit(0);
   }
 
+  // agx task stop <taskId> (Docker-style namespace)
+  // agx deps <taskId|slug|#> [--depends-on <taskId|slug|#> ...] [--clear]
+  // agx task deps <taskId|slug|#> [--depends-on <taskId|slug|#> ...] [--clear]
+  if (cmd === 'deps' || (cmd === 'task' && args[1] === 'deps')) {
+    const config = loadCloudConfig();
+    if (!config) {
+      console.log(`${c.red}Cloud API URL not configured.${c.reset} Set AGX_CLOUD_URL (default is http://localhost:41741)`);
+      process.exit(1);
+    }
+
+    const depArgs = cmd === 'task' ? args.slice(2) : args.slice(1);
+    let rawTaskId = null;
+    let clearDependencies = false;
+    const dependsOnInputs = [];
+
+    for (let i = 0; i < depArgs.length; i += 1) {
+      const token = depArgs[i];
+      if (token === '--task' || token === '-t') {
+        rawTaskId = depArgs[i + 1] || null;
+        i += 1;
+        continue;
+      }
+      if (token === '--depends-on') {
+        const depValue = depArgs[i + 1];
+        if (!depValue || depValue.startsWith('-')) {
+          console.log(`${c.yellow}Usage:${c.reset} agx deps <taskId|slug|#> [--depends-on <taskId|slug|#> ...] [--clear]`);
+          process.exit(1);
+        }
+        dependsOnInputs.push(depValue);
+        i += 1;
+        continue;
+      }
+      if (token === '--clear') {
+        clearDependencies = true;
+        continue;
+      }
+      if (token.startsWith('-')) {
+        console.log(`${c.red}✗${c.reset} Unknown flag: ${token}`);
+        console.log(`${c.yellow}Usage:${c.reset} agx deps <taskId|slug|#> [--depends-on <taskId|slug|#> ...] [--clear]`);
+        process.exit(1);
+      }
+      if (!rawTaskId) {
+        rawTaskId = token;
+        continue;
+      }
+      console.log(`${c.red}✗${c.reset} Unexpected argument: ${token}`);
+      console.log(`${c.yellow}Usage:${c.reset} agx deps <taskId|slug|#> [--depends-on <taskId|slug|#> ...] [--clear]`);
+      process.exit(1);
+    }
+
+    if (!rawTaskId) {
+      console.log(`${c.yellow}Usage:${c.reset} agx deps <taskId|slug|#> [--depends-on <taskId|slug|#> ...] [--clear]`);
+      console.log(`${c.dim}   or:${c.reset} agx task deps <taskId|slug|#> [--depends-on <taskId|slug|#> ...] [--clear]`);
+      console.log(`${c.dim}Examples:${c.reset}`);
+      console.log(`  ${c.cyan}agx deps task-c${c.reset}`);
+      console.log(`  ${c.cyan}agx deps task-c --depends-on task-a --depends-on task-b${c.reset}`);
+      console.log(`  ${c.cyan}agx deps task-c --clear${c.reset}`);
+      process.exit(1);
+    }
+
+    if (clearDependencies && dependsOnInputs.length > 0) {
+      console.log(`${c.red}✗${c.reset} Cannot use --clear with --depends-on in the same command.`);
+      process.exit(1);
+    }
+
+    try {
+      const resolvedTaskId = await resolveTaskId(rawTaskId);
+      const isUpdate = clearDependencies || dependsOnInputs.length > 0;
+
+      const formatTaskRef = (entry) => {
+        const slug = String(entry?.slug || '').trim();
+        if (slug) return slug;
+        const title = String(entry?.title || '').trim();
+        if (title) return title;
+        const id = String(entry?.id || '').trim();
+        return id || '(unknown)';
+      };
+
+      const readDependencyGraph = async () => {
+        try {
+          return await cloudRequest('GET', `/api/tasks/${resolvedTaskId}/dependencies`);
+        } catch {
+          return {
+            depends_on_tasks: [],
+            dependent_tasks: [],
+          };
+        }
+      };
+
+      if (!isUpdate) {
+        const { task } = await cloudRequest('GET', `/api/tasks/${resolvedTaskId}`);
+        const depGraph = await readDependencyGraph();
+        const dependsOn = Array.isArray(depGraph?.depends_on_tasks) ? depGraph.depends_on_tasks : [];
+        console.log(`${c.bold}Task Dependencies${c.reset}`);
+        console.log(`  Task: ${task?.slug || task?.id || resolvedTaskId}`);
+        if (!dependsOn.length) {
+          console.log(`  Depends on: ${c.dim}(none)${c.reset}`);
+        } else {
+          console.log(`  Depends on (${dependsOn.length}):`);
+          for (const dep of dependsOn) {
+            const suffix = dep?.status ? ` (${dep.status})` : '';
+            console.log(`    - ${formatTaskRef(dep)}${suffix}`);
+          }
+        }
+
+        const dependents = Array.isArray(depGraph?.dependent_tasks) ? depGraph.dependent_tasks : [];
+        if (!dependents.length) {
+          console.log(`  Dependents: ${c.dim}(none)${c.reset}`);
+        } else {
+          console.log(`  Dependents (${dependents.length}):`);
+          for (const dependent of dependents) {
+            const suffix = dependent?.status ? ` (${dependent.status})` : '';
+            console.log(`    - ${formatTaskRef(dependent)}${suffix}`);
+          }
+        }
+        process.exit(0);
+      }
+
+      let resolvedDependsOn = [];
+      if (!clearDependencies) {
+        const seen = new Set();
+        for (const rawDep of dependsOnInputs) {
+          const resolvedDepId = await resolveTaskId(rawDep);
+          if (resolvedDepId === resolvedTaskId) {
+            throw new Error('Task cannot depend on itself.');
+          }
+          if (!seen.has(resolvedDepId)) {
+            seen.add(resolvedDepId);
+            resolvedDependsOn.push(resolvedDepId);
+          }
+        }
+      }
+
+      const desiredDependsOn = clearDependencies ? [] : resolvedDependsOn;
+      const payload = { depends_on: desiredDependsOn };
+
+      const setDependsOnInFrontmatter = (rawContent, nextDependsOn) => {
+        const serialized = JSON.stringify(nextDependsOn);
+        const match = String(rawContent || '').match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+        if (match) {
+          const frontmatterLines = match[1]
+            .split('\n')
+            .filter((line) => !line.trim().toLowerCase().startsWith('depends_on:'));
+          frontmatterLines.push(`depends_on: ${serialized}`);
+          return `---\n${frontmatterLines.join('\n')}\n---\n${match[2] || ''}`;
+        }
+        return `---\ndepends_on: ${serialized}\n---\n\n${rawContent || ''}`;
+      };
+
+      const updateDependenciesViaPutFallback = async () => {
+        const { task: latestTask } = await cloudRequest('GET', `/api/tasks/${resolvedTaskId}`);
+        const rawContent = typeof latestTask?.content === 'string' ? latestTask.content : '';
+        if (!rawContent) {
+          throw new Error('Task content unavailable for dependency update fallback.');
+        }
+        const nextContent = setDependsOnInFrontmatter(rawContent, desiredDependsOn);
+        await cloudRequest('PUT', `/api/tasks/${resolvedTaskId}`, { content: nextContent });
+      };
+
+      try {
+        await cloudRequest('PATCH', `/api/tasks/${resolvedTaskId}`, payload);
+      } catch {
+        // Fallback to PUT path for older cloud versions that don't accept depends_on on PATCH.
+        await updateDependenciesViaPutFallback();
+      }
+
+      let depGraph = await readDependencyGraph();
+      let nextDependsOn = Array.isArray(depGraph?.depends_on_tasks)
+        ? depGraph.depends_on_tasks.map((dep) => String(dep?.id || '').trim()).filter(Boolean)
+        : [];
+      const matchesDesired =
+        nextDependsOn.length === desiredDependsOn.length &&
+        desiredDependsOn.every((id) => nextDependsOn.includes(id));
+
+      if (!matchesDesired) {
+        await updateDependenciesViaPutFallback();
+        depGraph = await readDependencyGraph();
+        nextDependsOn = Array.isArray(depGraph?.depends_on_tasks)
+          ? depGraph.depends_on_tasks.map((dep) => String(dep?.id || '').trim()).filter(Boolean)
+          : [];
+      }
+
+      console.log(`${c.green}✓${c.reset} Updated task dependencies`);
+      const { task: refreshedTask } = await cloudRequest('GET', `/api/tasks/${resolvedTaskId}`);
+      console.log(`  Task: ${refreshedTask?.slug || refreshedTask?.id || resolvedTaskId}`);
+      if (!nextDependsOn.length) {
+        console.log(`  Depends on: ${c.dim}(none)${c.reset}`);
+      } else {
+        console.log(`  Depends on (${nextDependsOn.length}):`);
+        const knownDeps = Array.isArray(depGraph?.depends_on_tasks) ? depGraph.depends_on_tasks : [];
+        for (const depId of nextDependsOn) {
+          const details = knownDeps.find((dep) => dep?.id === depId);
+          const suffix = details?.status ? ` (${details.status})` : '';
+          console.log(`    - ${formatTaskRef(details || { id: depId })}${suffix}`);
+        }
+      }
+    } catch (err) {
+      console.log(`${c.red}✗${c.reset} Failed: ${err.message}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+
   // agx task stop <taskId> (Docker-style namespace)
   if (cmd === 'task' && args[1] === 'stop') {
     const rawTaskId = args[2];
@@ -3087,6 +3721,7 @@ PROVIDERS:
   agx retry <id|slug|#>  Reset + retry a task (--async for non-blocking, --from <stage> to restart at a stage)
   agx status             Show cloud status
   agx complete <taskId>  Mark task stage complete
+  agx deps <id|slug|#> [--depends-on <id|slug|#> ... | --clear]  Show/update task dependencies
   agx project assign <project> --task <task>   Assign task to project
   agx project unassign --task <task>           Remove project assignment from task
 
@@ -3095,6 +3730,7 @@ CHECKING ON TASKS:
   agx task run <id|slug|#>  Claim and run a task
   agx task reset <id>   Reset a task to queued
   agx task logs <id> -f View/tail task logs
+  agx task deps <id|slug|#> [--depends-on <id|slug|#> ... | --clear]  Show/update dependencies
   agx task tail <id>    Tail task logs
   agx task clear <id|slug|#>  Clear comments and logs
   agx comments clear <id|slug|#>  Clear comments only
@@ -3184,7 +3820,8 @@ SUPPORT:
       cloud: null, // null = auto-detect, true = force on, false = force off
       cloudTaskId: null,
       autonomous: false,
-      daemon: false
+      daemon: false,
+      approvalMode: 'manual',
     };
 
     // Collect positional args (legacy support, but --prompt is preferred)
@@ -3240,6 +3877,27 @@ SUPPORT:
           options.autonomous = true;
           options.yolo = true; // Autonomous = unattended, skip prompts
           break;
+        case '--approval':
+        case '--approval-mode':
+          if (nextArg && !nextArg.startsWith('-')) {
+            const resolved = normalizeApprovalMode(nextArg);
+            if (!resolved) {
+              console.error(`${c.red}Error:${c.reset} Invalid approval mode "${nextArg}". Use manual|auto.`);
+              process.exit(1);
+            }
+            options.approvalMode = resolved;
+            i++;
+          } else {
+            console.error(`${c.red}Error:${c.reset} Missing value for ${arg}. Use manual|auto.`);
+            process.exit(1);
+          }
+          break;
+        case '--auto-approve':
+          options.approvalMode = 'auto';
+          break;
+        case '--manual-approve':
+          options.approvalMode = 'manual';
+          break;
         case '--cloud-task':
           if (nextArg && !nextArg.startsWith('-')) {
             options.cloudTaskId = nextArg;
@@ -3501,7 +4159,9 @@ SUPPORT:
           }
         }
 
-        console.log(`${c.dim}[cloud] Loaded task: ${task.title || task.id}${c.reset}\n`);
+        if (!process.env.AGX_CLI_CHAT_MODE) {
+          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);
@@ -3515,8 +4175,9 @@ SUPPORT:
       try {
         const cloudConfig = loadCloudConfig();
         if (cloudConfig?.apiUrl) {
-          const frontmatter = ['status: queued', 'stage: ideation'];
+          const frontmatter = ['status: queued', 'stage: intake'];
           frontmatter.push(`engine: ${provider}`);
+          frontmatter.push(`approval_mode: ${options.approvalMode}`);
 
           const content = `---\n${frontmatter.join('\n')}\n---\n\n# ${finalPrompt}\n`;