@mthanhlm/autodev 0.4.2 → 0.4.4

package/autodev/bin/autodev-tools.cjs

@@ -3,6 +3,9 @@
 const fs = require('fs');
 const path = require('path');
 
+const DEFAULT_RUN_MODE = 'checkpointed';
+const AUTO_RETRY_LIMIT = 2;
+
 const DEFAULT_CONFIG = {
   project: {
     type: null
@@ -28,6 +31,50 @@ const DEFAULT_CONFIG = {
 };
 
 const CODEBASE_FILES = ['structure.md', 'domain.md', 'runtime.md', 'quality.md', 'summary.md'];
+const CODE_FILE_EXTENSIONS = new Set([
+  '.js', '.jsx', '.cjs', '.mjs',
+  '.ts', '.tsx',
+  '.py',
+  '.go',
+  '.rs',
+  '.java',
+  '.rb',
+  '.php',
+  '.cs',
+  '.cpp',
+  '.cc',
+  '.c',
+  '.h',
+  '.hpp',
+  '.swift',
+  '.kt',
+  '.kts',
+  '.scala'
+]);
+const NESTED_CODE_MARKER_FILES = new Set([
+  'package.json',
+  'tsconfig.json',
+  'jsconfig.json',
+  'pyproject.toml',
+  'requirements.txt',
+  'Pipfile',
+  'Cargo.toml',
+  'go.mod',
+  'pom.xml',
+  'build.gradle',
+  'Dockerfile'
+]);
+const IGNORED_SCAN_DIRS = new Set([
+  '.autodev',
+  '.claude',
+  '.git',
+  'node_modules',
+  'dist',
+  'build',
+  'coverage',
+  'tmp',
+  'vendor'
+]);
 
 function findWorkspaceRoot(startDir) {
   let cursor = path.resolve(startDir || process.cwd());
@@ -108,6 +155,55 @@ function padPhase(number) {
   return String(number).padStart(2, '0');
 }
 
+function normalizeRunMode(value) {
+  return value === 'auto' ? 'auto' : DEFAULT_RUN_MODE;
+}
+
+function routeCommandForRunMode(runMode) {
+  return normalizeRunMode(runMode) === 'auto' ? '/autodev-auto' : '/autodev';
+}
+
+function codeFileNameLooksReal(entryName) {
+  return CODE_FILE_EXTENSIONS.has(path.extname(entryName).toLowerCase());
+}
+
+function directoryContainsCodeMarker(dirPath, depth = 2) {
+  if (depth < 0 || !fileExists(dirPath)) {
+    return false;
+  }
+
+  let entries;
+  try {
+    entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+
+  for (const entry of entries) {
+    if (entry.name.startsWith('.')) {
+      continue;
+    }
+
+    const fullPath = path.join(dirPath, entry.name);
+    if (entry.isFile()) {
+      if (codeFileNameLooksReal(entry.name) || NESTED_CODE_MARKER_FILES.has(entry.name)) {
+        return true;
+      }
+      continue;
+    }
+
+    if (!entry.isDirectory() || depth === 0 || IGNORED_SCAN_DIRS.has(entry.name)) {
+      continue;
+    }
+
+    if (directoryContainsCodeMarker(fullPath, depth - 1)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 function detectExistingCodebase(cwd) {
   const workspaceRoot = findWorkspaceRoot(cwd);
   const knownFiles = [
@@ -155,7 +251,16 @@ function detectExistingCodebase(cwd) {
       if (entry.name === '.autodev' || entry.name === '.claude' || entry.name.startsWith('.')) {
         return false;
       }
-      return entry.isDirectory() || /\.(js|ts|tsx|jsx|py|go|rs|java|rb|php|cs|cpp|c|swift|kt|sql|json|yaml|yml|md)$/.test(entry.name);
+
+      if (entry.isFile()) {
+        return codeFileNameLooksReal(entry.name);
+      }
+
+      if (!entry.isDirectory() || IGNORED_SCAN_DIRS.has(entry.name)) {
+        return false;
+      }
+
+      return directoryContainsCodeMarker(path.join(workspaceRoot, entry.name));
     });
   } catch {
     return false;
@@ -281,6 +386,14 @@ function readSingleLineField(content, label) {
   return match ? match[1].trim() : null;
 }
 
+function readNumericField(content, label, fallback = 0) {
+  const raw = readSingleLineField(content, label);
+  if (raw && /^\d+$/.test(raw)) {
+    return Number(raw);
+  }
+  return fallback;
+}
+
 function parseStateSnapshot(content) {
   if (!content) {
     return null;
@@ -298,7 +411,9 @@ function parseStateSnapshot(content) {
     currentTask: readSingleLineField(content, 'Current Task'),
     currentTaskStatus: readSingleLineField(content, 'Current Task Status'),
     status: readSingleLineField(content, 'Status'),
-    nextCommand: readSingleLineField(content, 'Next Command')
+    nextCommand: readSingleLineField(content, 'Next Command'),
+    runMode: normalizeRunMode(readSingleLineField(content, 'Run Mode')),
+    autoRetryCount: readNumericField(content, 'Auto Retry Count', 0)
   };
 }
 
@@ -405,6 +520,26 @@ function hasDependencyDeadlock(tasks) {
   return tasks.some(task => !task.summaryExists) && !nextExecutableTask(tasks);
 }
 
+function buildRouteResult(route, runMode, options = {}) {
+  const normalizedRunMode = normalizeRunMode(runMode);
+  return {
+    ...route,
+    command: routeCommandForRunMode(normalizedRunMode),
+    run_mode: normalizedRunMode,
+    auto_continuable: normalizedRunMode === 'auto' ? options.autoContinuable !== false : false,
+    pause_reason: normalizedRunMode === 'auto' ? (options.pauseReason || null) : null
+  };
+}
+
+function phaseTaskSnapshot(phase) {
+  const tasks = phase ? listTasksForPhaseDetails(phase) : [];
+  return {
+    tasks,
+    nextTask: nextExecutableTask(tasks),
+    dependencyDeadlock: hasDependencyDeadlock(tasks)
+  };
+}
+
 function listPhases(cwd, slug = readActiveTrack(cwd)) {
   const track = trackPaths(cwd, slug);
   if (!track || !fileExists(track.roadmap)) {
@@ -513,7 +648,8 @@ function resolvePhase(cwd, slug, requestedPhase, mode) {
   return phases[0];
 }
 
-function buildRoute(cwd) {
+function buildRoute(cwd, options = {}) {
+  const runMode = normalizeRunMode(options.runMode);
   const paths = rootPaths(cwd);
   const config = loadConfig(cwd);
   const existingCodebase = detectExistingCodebase(cwd);
@@ -524,58 +660,65 @@ function buildRoute(cwd) {
   const tracks = listTracks(cwd);
 
   if (!projectExists) {
-    return {
+    return buildRouteResult({
       kind: 'init_project',
-      command: '/autodev',
       manualCommand: '/autodev-new-project',
       reason: existingCodebase ? 'existing_code_detected_without_project_state' : 'project_state_missing',
       projectType
-    };
+    }, runMode, {
+      autoContinuable: false,
+      pauseReason: 'missing_intent'
+    });
   }
 
   if (projectType === 'brownfield' && !codebaseMapExists) {
-    return {
+    return buildRouteResult({
       kind: 'explore_codebase',
-      command: '/autodev',
       manualCommand: '/autodev-explore-codebase',
       reason: 'brownfield_project_needs_codebase_map',
       projectType
-    };
+    }, runMode);
   }
 
   if (!activeTrack) {
-    return {
+    return buildRouteResult({
       kind: 'track_select',
-      command: '/autodev',
       manualCommand: null,
       reason: tracks.length > 0 ? 'no_active_track_selected' : 'no_tracks_created',
       projectType
-    };
+    }, runMode, {
+      autoContinuable: false,
+      pauseReason: 'track_selection'
+    });
   }
 
   const track = trackPaths(cwd, activeTrack);
   if (!track || !fileExists(track.track) || !fileExists(track.roadmap) || !fileExists(track.state)) {
-    return {
+    return buildRouteResult({
       kind: 'track_setup',
-      command: '/autodev',
       manualCommand: null,
       reason: 'active_track_missing_required_artifacts',
       projectType,
       trackSlug: activeTrack
-    };
+    }, runMode, {
+      autoContinuable: false,
+      pauseReason: 'missing_intent'
+    });
   }
 
   const phases = listPhases(cwd, activeTrack);
   const trackState = readStateSnapshot(track.state);
   if (phases.length === 0) {
-    return {
+    return buildRouteResult({
       kind: 'track_setup',
-      command: '/autodev',
       manualCommand: null,
       reason: 'active_track_has_no_phases',
       projectType,
       trackSlug: activeTrack
-    };
+    }, runMode, {
+      autoContinuable: false,
+      pauseReason: 'missing_intent'
+    });
   }
 
   const currentStatePhase = trackState?.currentPhase
@@ -585,153 +728,235 @@ function buildRoute(cwd) {
   if (currentStatePhase && (
     isBlockedTaskStatus(trackState?.currentTaskStatus)
   )) {
-    return {
+    const retryLimitHit = runMode === 'auto' && (trackState?.autoRetryCount || 0) >= AUTO_RETRY_LIMIT;
+    return buildRouteResult({
       kind: 'plan_phase',
-      command: '/autodev',
       manualCommand: `/autodev-plan-phase ${currentStatePhase.number}`,
       reason: 'blocked_phase_requires_replanning',
       projectType,
       trackSlug: activeTrack,
       phaseNumber: currentStatePhase.number
-    };
+    }, runMode, retryLimitHit
+      ? {
+          autoContinuable: false,
+          pauseReason: 'auto_retry_limit'
+        }
+      : {});
   }
 
   if (currentStatePhase && trackState?.currentStep === 'execution') {
-    return {
+    return buildRouteResult({
       kind: 'execute_phase',
-      command: '/autodev',
       manualCommand: `/autodev-execute-phase ${currentStatePhase.number}`,
       reason: 'phase_execution_in_progress',
       projectType,
       trackSlug: activeTrack,
       phaseNumber: currentStatePhase.number
-    };
+    }, runMode);
   }
 
   if (currentStatePhase && trackState?.currentStep === 'task_review') {
-    return {
+    if (runMode === 'auto') {
+      const snapshot = phaseTaskSnapshot(currentStatePhase);
+      if (snapshot.dependencyDeadlock) {
+        return buildRouteResult({
+          kind: 'plan_phase',
+          manualCommand: `/autodev-plan-phase ${currentStatePhase.number}`,
+          reason: 'dependency_deadlock_requires_replanning',
+          projectType,
+          trackSlug: activeTrack,
+          phaseNumber: currentStatePhase.number
+        }, runMode, {
+          autoContinuable: false,
+          pauseReason: 'dependency_deadlock'
+        });
+      }
+
+      if (currentStatePhase.summaryExists) {
+        return buildRouteResult({
+          kind: 'review_phase',
+          manualCommand: `/autodev-review-phase ${currentStatePhase.number}`,
+          reason: 'auto_skips_task_review_after_phase_summary',
+          projectType,
+          trackSlug: activeTrack,
+          phaseNumber: currentStatePhase.number
+        }, runMode);
+      }
+
+      return buildRouteResult({
+        kind: 'execute_phase',
+        manualCommand: `/autodev-execute-phase ${currentStatePhase.number}`,
+        reason: snapshot.nextTask ? 'auto_skips_task_review_checkpoint' : 'phase_execution_in_progress',
+        projectType,
+        trackSlug: activeTrack,
+        phaseNumber: currentStatePhase.number
+      }, runMode);
+    }
+
+    return buildRouteResult({
       kind: 'task_review',
-      command: '/autodev',
       manualCommand: `/autodev-review-task ${currentStatePhase.number}`,
       reason: 'task_execution_checkpoint_pending_user_review',
       projectType,
       trackSlug: activeTrack,
       phaseNumber: currentStatePhase.number
-    };
+    }, runMode);
   }
 
   if (currentStatePhase && trackState?.currentStep === 'plan_review') {
-    return {
+    if (runMode === 'auto') {
+      return buildRouteResult({
+        kind: 'execute_phase',
+        manualCommand: `/autodev-execute-phase ${currentStatePhase.number}`,
+        reason: 'auto_skips_plan_review_checkpoint',
+        projectType,
+        trackSlug: activeTrack,
+        phaseNumber: currentStatePhase.number
+      }, runMode);
+    }
+
+    return buildRouteResult({
       kind: 'plan_review',
-      command: '/autodev',
       manualCommand: `/autodev-execute-phase ${currentStatePhase.number}`,
       reason: 'phase_plan_awaits_review',
       projectType,
       trackSlug: activeTrack,
       phaseNumber: currentStatePhase.number
-    };
+    }, runMode);
   }
 
   if (currentStatePhase && trackState?.currentStep === 'review' && !currentStatePhase.reviewExists) {
-    return {
+    return buildRouteResult({
       kind: 'review_phase',
-      command: '/autodev',
       manualCommand: `/autodev-review-phase ${currentStatePhase.number}`,
       reason: 'phase_review_in_progress',
       projectType,
       trackSlug: activeTrack,
       phaseNumber: currentStatePhase.number
-    };
+    }, runMode);
   }
 
   if (currentStatePhase && trackState?.currentStep === 'verification' && !currentStatePhase.uatExists) {
-    return {
+    return buildRouteResult({
       kind: 'verify_phase',
-      command: '/autodev',
       manualCommand: `/autodev-verify-work ${currentStatePhase.number}`,
       reason: 'phase_verification_in_progress',
       projectType,
       trackSlug: activeTrack,
       phaseNumber: currentStatePhase.number
-    };
+    }, runMode);
   }
 
   const nextReview = phases.find(phase => phase.summaryExists && !phase.reviewExists);
   if (nextReview && config.workflow.review_after_execute !== false) {
-    return {
+    return buildRouteResult({
       kind: 'review_phase',
-      command: '/autodev',
       manualCommand: `/autodev-review-phase ${nextReview.number}`,
       reason: 'phase_executed_but_not_reviewed',
       projectType,
       trackSlug: activeTrack,
       phaseNumber: nextReview.number
-    };
+    }, runMode);
   }
 
   const nextVerify = phases.find(phase => phase.reviewExists && !phase.uatExists);
   if (nextVerify) {
-    return {
+    return buildRouteResult({
       kind: 'verify_phase',
-      command: '/autodev',
       manualCommand: `/autodev-verify-work ${nextVerify.number}`,
       reason: 'phase_reviewed_but_not_verified',
       projectType,
       trackSlug: activeTrack,
       phaseNumber: nextVerify.number
-    };
+    }, runMode);
   }
 
   const nextTaskReview = phases.find(phase => phase.planExists && !phase.summaryExists && phase.taskDoneCount > 0);
   if (nextTaskReview) {
-    return {
+    if (runMode === 'auto') {
+      const snapshot = phaseTaskSnapshot(nextTaskReview);
+      if (snapshot.dependencyDeadlock) {
+        return buildRouteResult({
+          kind: 'plan_phase',
+          manualCommand: `/autodev-plan-phase ${nextTaskReview.number}`,
+          reason: 'dependency_deadlock_requires_replanning',
+          projectType,
+          trackSlug: activeTrack,
+          phaseNumber: nextTaskReview.number
+        }, runMode, {
+          autoContinuable: false,
+          pauseReason: 'dependency_deadlock'
+        });
+      }
+
+      return buildRouteResult({
+        kind: 'execute_phase',
+        manualCommand: `/autodev-execute-phase ${nextTaskReview.number}`,
+        reason: 'auto_skips_task_review_checkpoint',
+        projectType,
+        trackSlug: activeTrack,
+        phaseNumber: nextTaskReview.number
+      }, runMode);
+    }
+
+    return buildRouteResult({
       kind: 'task_review',
-      command: '/autodev',
       manualCommand: `/autodev-review-task ${nextTaskReview.number}`,
       reason: 'phase_task_completed_awaiting_user_review',
       projectType,
       trackSlug: activeTrack,
       phaseNumber: nextTaskReview.number
-    };
+    }, runMode);
   }
 
   const nextPlannedReview = phases.find(phase => phase.planExists && !phase.summaryExists);
   if (nextPlannedReview) {
-    return {
+    if (runMode === 'auto') {
+      return buildRouteResult({
+        kind: 'execute_phase',
+        manualCommand: `/autodev-execute-phase ${nextPlannedReview.number}`,
+        reason: 'auto_skips_plan_review_checkpoint',
+        projectType,
+        trackSlug: activeTrack,
+        phaseNumber: nextPlannedReview.number
+      }, runMode);
+    }
+
+    return buildRouteResult({
       kind: 'plan_review',
-      command: '/autodev',
       manualCommand: `/autodev-execute-phase ${nextPlannedReview.number}`,
       reason: 'phase_planned_awaiting_user_review',
       projectType,
       trackSlug: activeTrack,
       phaseNumber: nextPlannedReview.number
-    };
+    }, runMode);
   }
 
   const nextPlan = phases.find(phase => !phase.planExists);
   if (nextPlan) {
-    return {
+    return buildRouteResult({
       kind: 'plan_phase',
-      command: '/autodev',
       manualCommand: `/autodev-plan-phase ${nextPlan.number}`,
       reason: 'phase_not_planned',
       projectType,
       trackSlug: activeTrack,
       phaseNumber: nextPlan.number
-    };
+    }, runMode);
   }
 
-  return {
+  return buildRouteResult({
     kind: 'track_complete',
-    command: '/autodev',
     manualCommand: '/autodev-cleanup',
     reason: 'active_track_fully_verified',
     projectType,
     trackSlug: activeTrack
-  };
+  }, runMode, {
+    autoContinuable: false
+  });
 }
 
-function buildProgress(cwd) {
+function buildProgress(cwd, options = {}) {
+  const runMode = normalizeRunMode(options.runMode);
   const paths = rootPaths(cwd);
   const initialized = fileExists(paths.project);
   const existingCodebase = detectExistingCodebase(cwd);
@@ -741,10 +966,11 @@ function buildProgress(cwd) {
   const tracks = listTracks(cwd);
   const phases = activeTrack ? listPhases(cwd, activeTrack) : [];
   const codebaseMapExists = fileExists(paths.codebaseSummary);
-  const route = buildRoute(cwd);
+  const route = buildRoute(cwd, { runMode });
 
   return {
     initialized,
+    runMode,
     projectType,
     existingCodebase,
     codebaseMapExists,
@@ -763,7 +989,9 @@ function buildProgress(cwd) {
     },
     route,
     nextCommand: route.command,
-    manualNextCommand: route.manualCommand || null
+    manualNextCommand: route.manualCommand || null,
+    autoContinuable: route.auto_continuable,
+    pauseReason: route.pause_reason
   };
 }
 
@@ -775,6 +1003,7 @@ function renderProgressTable(progress) {
   const lines = [
     'Autodev Progress',
     '',
+    `Run Mode: ${progress.runMode}`,
     `Project Type: ${progress.projectType}`,
     `Codebase Map: ${progress.codebaseMapExists ? 'ready' : 'missing'}`,
     `Tracks: ${progress.counts.trackCount}`,
@@ -788,6 +1017,8 @@ function renderProgressTable(progress) {
     `Task Summaries: ${progress.counts.tasksDone}`,
     `Next: ${progress.route.command}`,
     progress.route.manualCommand ? `Manual Shortcut: ${progress.route.manualCommand}` : null,
+    progress.runMode === 'auto' ? `Auto Continue: ${progress.route.auto_continuable ? 'yes' : 'no'}` : null,
+    progress.runMode === 'auto' ? `Pause Reason: ${progress.route.pause_reason || 'none'}` : null,
     '',
     '| Phase | Type | Name | Tasks | Done | Plan | Summary | Review | UAT | Status |',
     '| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |'
@@ -820,9 +1051,10 @@ function codebasePaths(cwd) {
   return Object.fromEntries(CODEBASE_FILES.map(name => [name.replace(/\.md$/, ''), path.join(codebaseDir, name)]));
 }
 
-function buildStatus(cwd) {
+function buildStatus(cwd, options = {}) {
+  const runMode = normalizeRunMode(options.runMode);
   const paths = rootPaths(cwd);
-  const route = buildRoute(cwd);
+  const route = buildRoute(cwd, { runMode });
   const config = loadConfig(cwd);
   const existingCodebase = detectExistingCodebase(cwd);
   const projectType = config.project.type || (existingCodebase ? 'brownfield' : 'greenfield');
@@ -831,6 +1063,7 @@ function buildStatus(cwd) {
 
   return {
     cwd,
+    run_mode: runMode,
     workspace_root: paths.workspaceRoot,
     autodev_exists: fileExists(paths.root),
     project_exists: fileExists(paths.project),
@@ -847,13 +1080,16 @@ function buildStatus(cwd) {
       active: track.active
     })),
     codebase_map_exists: fileExists(paths.codebaseSummary),
+    auto_continuable: route.auto_continuable,
+    pause_reason: route.pause_reason,
     route
   };
 }
 
-function buildCleanupPayload(cwd) {
+function buildCleanupPayload(cwd, options = {}) {
+  const runMode = normalizeRunMode(options.runMode);
   const paths = rootPaths(cwd);
-  const route = buildRoute(cwd);
+  const route = buildRoute(cwd, { runMode });
   const activeTrack = readActiveTrack(cwd);
   const track = trackPaths(cwd, activeTrack);
   const phases = activeTrack ? listPhases(cwd, activeTrack) : [];
@@ -862,6 +1098,7 @@ function buildCleanupPayload(cwd) {
 
   return {
     cwd,
+    run_mode: runMode,
     autodev_exists: fileExists(paths.root),
     project_exists: fileExists(paths.project),
     project_state_path: paths.state,
@@ -871,6 +1108,8 @@ function buildCleanupPayload(cwd) {
     track_state_path: track ? track.state : null,
     phases_dir: track ? track.phasesDir : null,
     archive_root: path.join(paths.root, 'archive'),
+    auto_continuable: false,
+    pause_reason: runMode === 'auto' ? 'cleanup_confirmation' : null,
     route,
     phase_counts: {
       total: phases.length,
@@ -882,10 +1121,11 @@ function buildCleanupPayload(cwd) {
   };
 }
 
-function initPayload(cwd, mode, requestedPhase) {
+function initPayload(cwd, mode, requestedPhase, options = {}) {
+  const runMode = normalizeRunMode(options.runMode);
   const paths = rootPaths(cwd);
   const config = loadConfig(cwd);
-  const route = buildRoute(cwd);
+  const route = buildRoute(cwd, { runMode });
   const existingCodebase = detectExistingCodebase(cwd);
   const projectType = config.project.type || (existingCodebase ? 'brownfield' : 'greenfield');
   const activeTrack = readActiveTrack(cwd);
@@ -921,6 +1161,7 @@ function initPayload(cwd, mode, requestedPhase) {
 
   return {
     cwd,
+    run_mode: runMode,
     autodev_exists: fileExists(paths.root),
     project_exists: fileExists(paths.project),
     existing_code_detected: existingCodebase,
@@ -947,6 +1188,8 @@ function initPayload(cwd, mode, requestedPhase) {
     track_state_path: track ? track.state : null,
     track_state: trackStateSnapshot,
     phases_dir: track ? track.phasesDir : null,
+    auto_continuable: route.auto_continuable,
+    pause_reason: route.pause_reason,
     route,
     phase_found: Boolean(phase),
     phase_number: phase ? phase.number : null,
@@ -995,7 +1238,9 @@ function printJson(value) {
 }
 
 function main() {
-  const args = process.argv.slice(2);
+  const rawArgs = process.argv.slice(2);
+  const runMode = rawArgs.includes('--auto') ? 'auto' : DEFAULT_RUN_MODE;
+  const args = rawArgs.filter(arg => arg !== '--auto');
   const cwd = process.cwd();
 
   if (args.length === 0) {
@@ -1007,7 +1252,7 @@ function main() {
 
   if (command === 'progress') {
     const mode = rest[0] || 'table';
-    const progress = buildProgress(cwd);
+    const progress = buildProgress(cwd, { runMode });
     if (mode === 'json') {
       printJson(progress);
       return;
@@ -1032,18 +1277,18 @@ function main() {
   }
 
   if (command === 'status') {
-    printJson(buildStatus(cwd));
+    printJson(buildStatus(cwd, { runMode }));
     return;
   }
 
   if (command === 'cleanup') {
-    printJson(buildCleanupPayload(cwd));
+    printJson(buildCleanupPayload(cwd, { runMode }));
     return;
   }
 
   if (command === 'route') {
     const mode = rest[0] || 'json';
-    const route = buildRoute(cwd);
+    const route = buildRoute(cwd, { runMode });
     if (mode === 'json') {
       printJson(route);
       return;
@@ -1059,7 +1304,7 @@ function main() {
       process.stderr.write('autodev-tools: init mode required\n');
       process.exit(1);
     }
-    printJson(initPayload(cwd, mode, phase));
+    printJson(initPayload(cwd, mode, phase, { runMode }));
     return;
   }