@mthanhlm/autodev 0.4.3 → 0.5.0

package/autodev/bin/autodev-tools.cjs

@@ -3,31 +3,119 @@
 const fs = require('fs');
 const path = require('path');
 
-const DEFAULT_CONFIG = {
-  project: {
-    type: null
-  },
-  workflow: {
-    research: false,
-    review_after_execute: true
-  },
-  execution: {},
-  git: {
-    mode: 'read-only'
-  },
-  hooks: {
+const DEFAULT_STATE = {
+  version: 1,
+  project_type: null,
+  stage: 'briefing',
+  current_item: null,
+  last_result: 'unverified',
+  last_run_at: null,
+  last_run_path: null,
+  settings: {
+    git_mode: 'read-only',
     auto_format: true,
-    context_warnings: true,
-    read_guard: true,
-    workflow_guard: true,
-    prompt_guard: true,
-    git_guard: true,
-    session_state: true,
-    phase_boundary: true
+    background_tasks_disabled: true
   }
 };
 
-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',
+  'package-lock.json',
+  'pnpm-lock.yaml',
+  'yarn.lock',
+  '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 fileExists(filePath) {
+  try {
+    return fs.existsSync(filePath);
+  } catch {
+    return false;
+  }
+}
+
+function isFile(filePath) {
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function readText(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function readJson(filePath, fallback = null) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJson(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+function slugify(value) {
+  return String(value || 'run')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .replace(/-+/g, '-') || 'run';
+}
 
 function findWorkspaceRoot(startDir) {
   let cursor = path.resolve(startDir || process.cwd());
@@ -62,70 +150,63 @@ function rootPaths(cwd) {
   return {
     workspaceRoot,
     root,
-    config: path.join(root, 'config.json'),
-    project: path.join(root, 'PROJECT.md'),
-    state: path.join(root, 'STATE.md'),
-    activeTrack: path.join(root, 'ACTIVE_TRACK'),
-    codebaseDir: path.join(root, 'codebase'),
-    codebaseSummary: path.join(root, 'codebase', 'summary.md'),
-    tracksDir: path.join(root, 'tracks')
+    brief: path.join(root, 'brief.md'),
+    context: path.join(root, 'context.md'),
+    plan: path.join(root, 'plan.md'),
+    state: path.join(root, 'state.json'),
+    runsDir: path.join(root, 'runs'),
+    legacyDir: path.join(root, 'legacy')
   };
 }
 
-function readText(filePath) {
-  try {
-    return fs.readFileSync(filePath, 'utf8');
-  } catch {
-    return null;
-  }
+function codeFileNameLooksReal(entryName) {
+  return CODE_FILE_EXTENSIONS.has(path.extname(entryName).toLowerCase());
 }
 
-function readJson(filePath, fallback = null) {
-  try {
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-  } catch {
-    return fallback;
+function directoryContainsCodeMarker(dirPath, depth = 2) {
+  if (depth < 0 || !fileExists(dirPath)) {
+    return false;
   }
-}
 
-function fileExists(filePath) {
+  let entries;
   try {
-    return fs.existsSync(filePath);
+    entries = fs.readdirSync(dirPath, { withFileTypes: true });
   } catch {
     return false;
   }
-}
 
-function slugify(value) {
-  return String(value)
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .replace(/-+/g, '-') || 'track';
-}
+  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;
+    }
 
-function padPhase(number) {
-  return String(number).padStart(2, '0');
+    if (directoryContainsCodeMarker(fullPath, depth - 1)) {
+      return true;
+    }
+  }
+
+  return false;
 }
 
 function detectExistingCodebase(cwd) {
   const workspaceRoot = findWorkspaceRoot(cwd);
-  const knownFiles = [
-    'package.json',
-    'package-lock.json',
-    'pnpm-lock.yaml',
-    'yarn.lock',
-    'tsconfig.json',
-    'jsconfig.json',
-    'pyproject.toml',
-    'requirements.txt',
-    'Pipfile',
-    'Cargo.toml',
-    'go.mod',
-    'pom.xml',
-    'build.gradle',
-    'Dockerfile'
-  ];
+
+  if ([...NESTED_CODE_MARKER_FILES].some(name => fileExists(path.join(workspaceRoot, name)))) {
+    return true;
+  }
+
   const knownDirs = [
     'src',
     'app',
@@ -141,10 +222,6 @@ function detectExistingCodebase(cwd) {
     '__tests__'
   ];
 
-  if (knownFiles.some(name => fileExists(path.join(workspaceRoot, name)))) {
-    return true;
-  }
-
   if (knownDirs.some(name => fileExists(path.join(workspaceRoot, name)))) {
     return true;
   }
@@ -152,842 +229,526 @@ function detectExistingCodebase(cwd) {
   try {
     const entries = fs.readdirSync(workspaceRoot, { withFileTypes: true });
     return entries.some(entry => {
-      if (entry.name === '.autodev' || entry.name === '.claude' || entry.name.startsWith('.')) {
+      if (entry.name.startsWith('.') || IGNORED_SCAN_DIRS.has(entry.name)) {
         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()) {
+        return false;
+      }
+
+      return directoryContainsCodeMarker(path.join(workspaceRoot, entry.name));
     });
   } catch {
     return false;
   }
 }
 
-function mergeSection(defaultValue, actualValue) {
-  if (defaultValue && typeof defaultValue === 'object' && !Array.isArray(defaultValue)) {
-    return {
-      ...defaultValue,
-      ...((actualValue && typeof actualValue === 'object' && !Array.isArray(actualValue)) ? actualValue : {})
-    };
+function normalizeProjectType(value, fallbackCwd = process.cwd()) {
+  if (value === 'brownfield' || value === 'greenfield') {
+    return value;
   }
-  return actualValue !== undefined ? actualValue : defaultValue;
+  return detectExistingCodebase(fallbackCwd) ? 'brownfield' : 'greenfield';
 }
 
-function loadConfig(cwd) {
-  const config = readJson(rootPaths(cwd).config, {}) || {};
-  return {
-    project: mergeSection(DEFAULT_CONFIG.project, config.project),
-    workflow: mergeSection(DEFAULT_CONFIG.workflow, config.workflow),
-    execution: mergeSection(DEFAULT_CONFIG.execution, config.execution),
-    git: mergeSection(DEFAULT_CONFIG.git, config.git),
-    hooks: mergeSection(DEFAULT_CONFIG.hooks, config.hooks)
-  };
+function normalizeStage(value) {
+  const allowed = new Set(['briefing', 'context', 'planning', 'execution', 'blocked', 'complete']);
+  return allowed.has(value) ? value : DEFAULT_STATE.stage;
 }
 
-function readActiveTrack(cwd) {
-  const value = readText(rootPaths(cwd).activeTrack);
-  return value ? value.trim() || null : null;
-}
+function normalizeCurrentItem(value) {
+  if (value === null || value === undefined || value === '' || value === 'none') {
+    return null;
+  }
 
-function trackDir(cwd, slug) {
-  return path.join(rootPaths(cwd).tracksDir, slug);
+  const raw = String(value).trim();
+  return /^\d+$/.test(raw) ? raw.padStart(2, '0') : null;
 }
 
-function trackPaths(cwd, slug = readActiveTrack(cwd)) {
-  if (!slug) {
+function loadState(cwd) {
+  const paths = rootPaths(cwd);
+  const state = readJson(paths.state, null);
+  if (!state || typeof state !== 'object' || Array.isArray(state)) {
     return null;
   }
 
-  const dir = trackDir(cwd, slug);
   return {
-    slug,
-    dir,
-    track: path.join(dir, 'TRACK.md'),
-    requirements: path.join(dir, 'REQUIREMENTS.md'),
-    roadmap: path.join(dir, 'ROADMAP.md'),
-    state: path.join(dir, 'STATE.md'),
-    phasesDir: path.join(dir, 'phases')
+    ...DEFAULT_STATE,
+    ...state,
+    project_type: normalizeProjectType(state.project_type, cwd),
+    stage: normalizeStage(state.stage),
+    current_item: normalizeCurrentItem(state.current_item),
+    settings: {
+      ...DEFAULT_STATE.settings,
+      ...((state.settings && typeof state.settings === 'object') ? state.settings : {})
+    }
   };
 }
 
-function listTracks(cwd) {
-  const tracksDir = rootPaths(cwd).tracksDir;
-  if (!fileExists(tracksDir)) {
-    return [];
-  }
-
-  return fs.readdirSync(tracksDir, { withFileTypes: true })
-    .filter(entry => entry.isDirectory())
-    .map(entry => {
-      const paths = trackPaths(cwd, entry.name);
-      const trackName = (() => {
-        const content = readText(paths.track);
-        const match = content && content.match(/^#\s+Track:\s*(.+)$/m);
-        return match ? match[1].trim() : entry.name;
-      })();
-
-      return {
-        slug: entry.name,
-        name: trackName,
-        paths,
-        active: readActiveTrack(cwd) === entry.name
-      };
-    })
-    .sort((left, right) => left.slug.localeCompare(right.slug));
+function saveState(cwd, state) {
+  const paths = rootPaths(cwd);
+  writeJson(paths.state, {
+    ...DEFAULT_STATE,
+    ...state,
+    project_type: normalizeProjectType(state.project_type, cwd),
+    stage: normalizeStage(state.stage),
+    current_item: normalizeCurrentItem(state.current_item),
+    settings: {
+      ...DEFAULT_STATE.settings,
+      ...((state.settings && typeof state.settings === 'object') ? state.settings : {})
+    }
+  });
 }
 
-function parseRoadmap(content) {
-  const phases = [];
-  if (!content) {
-    return phases;
+function archiveLegacyState(cwd) {
+  const paths = rootPaths(cwd);
+  if (!fileExists(paths.root) || fileExists(paths.state)) {
+    return null;
   }
 
-  const matcher = /^##\s+Phase\s+(\d+)(?:\s+\[([a-z-]+)\])?\s*:\s*(.+)$/gm;
-  let match;
-  while ((match = matcher.exec(content)) !== null) {
-    phases.push({
-      number: Number(match[1]),
-      type: match[2] || 'feature',
-      name: match[3].trim()
-    });
-  }
-  return phases;
-}
+  const entries = fs.readdirSync(paths.root).filter(entry => entry !== 'legacy');
+  const legacyMarkers = new Set([
+    'ACTIVE_TRACK',
+    'PROJECT.md',
+    'STATE.md',
+    'TRACK.md',
+    'codebase',
+    'tracks'
+  ]);
 
-function phasePaths(cwd, slug, phase) {
-  const track = trackPaths(cwd, slug);
-  if (!track) {
+  if (!entries.some(entry => legacyMarkers.has(entry) || /\.(md|json)$/.test(entry))) {
     return null;
   }
 
-  const prefix = padPhase(phase.number);
-  const dirName = `${prefix}-${phase.type}-${slugify(phase.name)}`;
-  const dir = path.join(track.phasesDir, dirName);
-  return {
-    ...phase,
-    padded: prefix,
-    dir,
-    planPath: path.join(dir, `${prefix}-PLAN.md`),
-    summaryPath: path.join(dir, `${prefix}-SUMMARY.md`),
-    reviewPath: path.join(dir, `${prefix}-REVIEW.md`),
-    uatPath: path.join(dir, `${prefix}-UAT.md`)
-  };
-}
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const archiveDir = path.join(paths.legacyDir, timestamp);
+  ensureDir(archiveDir);
 
-function readSingleLineField(content, label) {
-  if (!content) {
-    return null;
+  for (const entry of entries) {
+    fs.renameSync(path.join(paths.root, entry), path.join(archiveDir, entry));
   }
-  const match = content.match(new RegExp(`^${label}:\\s*(.+)$`, 'mi'));
-  return match ? match[1].trim() : null;
+
+  return archiveDir;
 }
 
-function parseStateSnapshot(content) {
-  if (!content) {
-    return null;
-  }
+function bootstrapProject(cwd, options = {}) {
+  const paths = rootPaths(cwd);
+  const archivedLegacyPath = archiveLegacyState(cwd);
+  ensureDir(paths.root);
+  ensureDir(paths.runsDir);
+
+  const current = loadState(cwd);
+  const nextState = current || {
+    ...DEFAULT_STATE,
+    project_type: normalizeProjectType(options.projectType, cwd)
+  };
 
-  const currentPhaseRaw = readSingleLineField(content, 'Current Phase');
-  const currentPhaseNumber = currentPhaseRaw && /^\d+$/.test(currentPhaseRaw)
-    ? Number(currentPhaseRaw)
-    : null;
+  saveState(cwd, nextState);
 
   return {
-    currentPhase: currentPhaseNumber,
-    currentPhaseType: readSingleLineField(content, 'Current Phase Type'),
-    currentStep: readSingleLineField(content, 'Current Step'),
-    currentTask: readSingleLineField(content, 'Current Task'),
-    currentTaskStatus: readSingleLineField(content, 'Current Task Status'),
-    status: readSingleLineField(content, 'Status'),
-    nextCommand: readSingleLineField(content, 'Next Command')
+    cwd,
+    workspace_root: paths.workspaceRoot,
+    autodev_root: paths.root,
+    state_path: paths.state,
+    brief_path: paths.brief,
+    context_path: paths.context,
+    plan_path: paths.plan,
+    runs_dir: paths.runsDir,
+    existing_code_detected: detectExistingCodebase(cwd),
+    archived_legacy_path: archivedLegacyPath,
+    state: loadState(cwd)
   };
 }
 
-function readStateSnapshot(filePath) {
-  return parseStateSnapshot(readText(filePath));
+function itemIdFromTitleNumber(value) {
+  return String(value).padStart(2, '0');
 }
 
-function isBlockedTaskStatus(value) {
-  return typeof value === 'string' && /^blocked/i.test(value.trim());
-}
-
-function parseTaskDependsOn(value) {
-  if (!value || /^none$/i.test(value)) {
-    return [];
-  }
-
-  return String(value)
-    .split(/[,\s]+/)
+function parseInlineList(value) {
+  return String(value || '')
+    .split(',')
     .map(part => part.trim())
-    .filter(Boolean)
-    .map(part => {
-      const match = part.match(/(\d+)/);
-      return match ? Number(match[1]) : null;
-    })
-    .filter(number => Number.isFinite(number));
+    .filter(Boolean);
 }
 
-function readTaskTitle(content, fallbackNumber) {
-  if (!content) {
-    return `Task ${String(fallbackNumber).padStart(2, '0')}`;
-  }
-
-  const heading = content.match(/^#\s+Task\s+\d+\s*:\s*(.+)$/mi);
-  if (heading) {
-    return heading[1].trim();
-  }
-
-  const generic = content.match(/^#\s+(.+)$/m);
-  return generic ? generic[1].trim() : `Task ${String(fallbackNumber).padStart(2, '0')}`;
-}
-
-function listTasksForPhaseDetails(phaseDetails) {
-  if (!phaseDetails || !fileExists(phaseDetails.dir)) {
-    return [];
+function parseItemSection(sectionContent) {
+  const lines = sectionContent.split('\n');
+  const titleMatch = lines[0].match(/^##\s+Item\s+(\d+)\s*:\s*(.+)$/);
+  if (!titleMatch) {
+    return null;
   }
 
-  const entries = fs.readdirSync(phaseDetails.dir, { withFileTypes: true })
-    .filter(entry => entry.isFile())
-    .map(entry => entry.name);
-
-  const tasks = entries
-    .map(name => {
-      const match = name.match(/^TASK-(\d+)\.md$/);
-      if (!match) {
-        return null;
-      }
-
-      const number = Number(match[1]);
-      const padded = String(number).padStart(2, '0');
-      const taskPath = path.join(phaseDetails.dir, name);
-      const summaryPath = path.join(phaseDetails.dir, `TASK-${padded}-SUMMARY.md`);
-      const content = readText(taskPath);
-      const status = readSingleLineField(content, 'Status') || 'pending';
-      const dependsOn = parseTaskDependsOn(readSingleLineField(content, 'Depends On'));
-      const summaryExists = fileExists(summaryPath);
-
-      return {
-        number,
-        padded,
-        title: readTaskTitle(content, number),
-        status,
-        dependsOn,
-        taskPath,
-        summaryPath,
-        summaryExists
-      };
-    })
-    .filter(Boolean)
-    .sort((left, right) => left.number - right.number);
-
-  const doneSet = new Set(tasks.filter(task => task.summaryExists).map(task => task.number));
-
-  return tasks.map(task => ({
-    ...task,
-    ready: !task.summaryExists && task.dependsOn.every(dep => doneSet.has(dep)),
-    effectiveStatus: task.summaryExists ? 'done' : task.status
-  }));
-}
-
-function nextExecutableTask(tasks) {
-  return tasks.find(task => !task.summaryExists && task.ready) || null;
-}
-
-function lastCompletedTask(tasks) {
-  const completed = tasks.filter(task => task.summaryExists);
-  return completed.length > 0 ? completed[completed.length - 1] : null;
-}
-
-function lastTaskNumber(tasks) {
-  return tasks.reduce((highest, task) => Math.max(highest, task.number), 0);
-}
-
-function hasDependencyDeadlock(tasks) {
-  return tasks.some(task => !task.summaryExists) && !nextExecutableTask(tasks);
-}
+  const item = {
+    id: itemIdFromTitleNumber(titleMatch[1]),
+    number: Number(titleMatch[1]),
+    title: titleMatch[2].trim(),
+    status: 'pending',
+    goal: '',
+    files: [],
+    acceptance: [],
+    verification: []
+  };
 
-function listPhases(cwd, slug = readActiveTrack(cwd)) {
-  const track = trackPaths(cwd, slug);
-  if (!track || !fileExists(track.roadmap)) {
-    return [];
-  }
+  let activeSection = null;
 
-  return parseRoadmap(readText(track.roadmap)).map(phase => {
-    const details = phasePaths(cwd, slug, phase);
-    const planExists = fileExists(details.planPath);
-    const summaryExists = fileExists(details.summaryPath);
-    const reviewExists = fileExists(details.reviewPath);
-    const uatExists = fileExists(details.uatPath);
-    const tasks = listTasksForPhaseDetails(details);
-    const taskCount = tasks.length;
-    const taskDoneCount = tasks.filter(task => task.summaryExists).length;
-    const status = uatExists
-      ? 'verified'
-      : reviewExists
-        ? 'reviewed'
-        : summaryExists
-          ? 'executed'
-          : planExists && taskCount > 0 && taskDoneCount === taskCount
-            ? 'tasks_complete'
-            : planExists && taskDoneCount > 0
-              ? 'executing'
-          : planExists
-            ? 'planned'
-            : 'pending';
+  for (let index = 1; index < lines.length; index += 1) {
+    const line = lines[index];
+    const trimmed = line.trim();
 
-    return {
-      ...details,
-      trackSlug: slug,
-      planExists,
-      summaryExists,
-      reviewExists,
-      uatExists,
-      taskCount,
-      taskDoneCount,
-      nextTask: nextExecutableTask(tasks)?.number || null,
-      status
-    };
-  });
-}
-
-function resolvePhase(cwd, slug, requestedPhase, mode) {
-  const phases = listPhases(cwd, slug);
-  if (phases.length === 0) {
-    return null;
-  }
+    if (!trimmed) {
+      continue;
+    }
 
-  if (requestedPhase) {
-    const numeric = Number(requestedPhase);
-    return phases.find(phase => phase.number === numeric) || null;
-  }
+    const statusMatch = trimmed.match(/^Status:\s*(.+)$/);
+    if (statusMatch) {
+      const rawStatus = statusMatch[1].trim().toLowerCase();
+      item.status = ['pending', 'in_progress', 'done', 'blocked'].includes(rawStatus)
+        ? rawStatus
+        : 'pending';
+      activeSection = null;
+      continue;
+    }
 
-  const track = trackPaths(cwd, slug);
-  const trackState = track ? readStateSnapshot(track.state) : null;
-  const currentStatePhase = trackState?.currentPhase
-    ? phases.find(phase => phase.number === trackState.currentPhase) || null
-    : null;
+    const goalMatch = trimmed.match(/^Goal:\s*(.+)$/);
+    if (goalMatch) {
+      item.goal = goalMatch[1].trim();
+      activeSection = null;
+      continue;
+    }
 
-  if (mode === 'plan') {
-    if (currentStatePhase && (
-      isBlockedTaskStatus(trackState.currentTaskStatus)
-      || trackState.currentStep === 'planning'
-      || trackState.currentStep === 'plan_review'
-    )) {
-      return currentStatePhase;
+    const filesMatch = trimmed.match(/^Files:\s*(.+)$/);
+    if (filesMatch) {
+      item.files = parseInlineList(filesMatch[1]);
+      activeSection = null;
+      continue;
     }
-    return phases.find(phase => !phase.planExists) || phases[0];
-  }
 
-  if (mode === 'execute') {
-    if (currentStatePhase && (
-      trackState?.currentStep === 'execution'
-      || trackState?.currentStep === 'task_review'
-    )) {
-      return currentStatePhase;
+    const sectionMatch = trimmed.match(/^(Files|Acceptance|Verification):\s*$/);
+    if (sectionMatch) {
+      activeSection = sectionMatch[1].toLowerCase();
+      continue;
     }
-    return phases.find(phase => phase.planExists && !phase.summaryExists) || null;
-  }
 
-  if (mode === 'task_review') {
-    if (currentStatePhase && trackState?.currentStep === 'task_review') {
-      return currentStatePhase;
+    if (!trimmed.startsWith('- ')) {
+      activeSection = null;
+      continue;
     }
-    return phases.find(phase => phase.planExists && !phase.summaryExists && phase.taskDoneCount > 0) || null;
-  }
 
-  if (mode === 'review') {
-    if (currentStatePhase && trackState?.currentStep === 'review') {
-      return currentStatePhase;
+    const value = trimmed.slice(2).trim();
+    if (!value) {
+      continue;
     }
-    return phases.find(phase => phase.summaryExists && !phase.reviewExists) || null;
-  }
 
-  if (mode === 'verify') {
-    if (currentStatePhase && trackState?.currentStep === 'verification') {
-      return currentStatePhase;
+    if (activeSection === 'files') {
+      item.files.push(value);
+    } else if (activeSection === 'acceptance') {
+      item.acceptance.push(value);
+    } else if (activeSection === 'verification') {
+      item.verification.push(value);
     }
-    return phases.find(phase => phase.reviewExists && !phase.uatExists)
-      || [...phases].reverse().find(phase => phase.reviewExists)
-      || null;
   }
 
-  return phases[0];
+  return item;
 }
 
-function buildRoute(cwd) {
-  const paths = rootPaths(cwd);
-  const config = loadConfig(cwd);
-  const existingCodebase = detectExistingCodebase(cwd);
-  const projectType = config.project.type || (existingCodebase ? 'brownfield' : 'greenfield');
-  const projectExists = fileExists(paths.project);
-  const codebaseMapExists = fileExists(paths.codebaseSummary);
-  const activeTrack = readActiveTrack(cwd);
-  const tracks = listTracks(cwd);
-
-  if (!projectExists) {
+function parsePlan(content) {
+  if (!content) {
     return {
-      kind: 'init_project',
-      command: '/autodev',
-      manualCommand: '/autodev-new-project',
-      reason: existingCodebase ? 'existing_code_detected_without_project_state' : 'project_state_missing',
-      projectType
+      goal: '',
+      done_definition: [],
+      items: []
     };
   }
 
-  if (projectType === 'brownfield' && !codebaseMapExists) {
-    return {
-      kind: 'explore_codebase',
-      command: '/autodev',
-      manualCommand: '/autodev-explore-codebase',
-      reason: 'brownfield_project_needs_codebase_map',
-      projectType
-    };
+  const goalMatch = content.match(/^Goal:\s*(.+)$/mi);
+  const doneDefinition = [];
+  const doneMatch = content.match(/^Done Definition:\s*\n((?:- .+\n?)*)/mi);
+  if (doneMatch) {
+    for (const line of doneMatch[1].split('\n')) {
+      const bullet = line.trim().match(/^- (.+)$/);
+      if (bullet) {
+        doneDefinition.push(bullet[1].trim());
+      }
+    }
   }
 
-  if (!activeTrack) {
-    return {
-      kind: 'track_select',
-      command: '/autodev',
-      manualCommand: null,
-      reason: tracks.length > 0 ? 'no_active_track_selected' : 'no_tracks_created',
-      projectType
-    };
-  }
+  const headings = [...content.matchAll(/^##\s+Item\s+\d+\s*:\s*.+$/gm)];
+  const items = [];
 
-  const track = trackPaths(cwd, activeTrack);
-  if (!track || !fileExists(track.track) || !fileExists(track.roadmap) || !fileExists(track.state)) {
-    return {
-      kind: 'track_setup',
-      command: '/autodev',
-      manualCommand: null,
-      reason: 'active_track_missing_required_artifacts',
-      projectType,
-      trackSlug: activeTrack
-    };
+  for (let index = 0; index < headings.length; index += 1) {
+    const start = headings[index].index;
+    const end = index + 1 < headings.length ? headings[index + 1].index : content.length;
+    const section = content.slice(start, end).trim();
+    const item = parseItemSection(section);
+    if (item) {
+      items.push(item);
+    }
   }
 
-  const phases = listPhases(cwd, activeTrack);
-  const trackState = readStateSnapshot(track.state);
-  if (phases.length === 0) {
-    return {
-      kind: 'track_setup',
-      command: '/autodev',
-      manualCommand: null,
-      reason: 'active_track_has_no_phases',
-      projectType,
-      trackSlug: activeTrack
-    };
-  }
+  return {
+    goal: goalMatch ? goalMatch[1].trim() : '',
+    done_definition: doneDefinition,
+    items
+  };
+}
 
-  const currentStatePhase = trackState?.currentPhase
-    ? phases.find(phase => phase.number === trackState.currentPhase) || null
+function determineNextItem(items, preferredItemId) {
+  const preferred = preferredItemId
+    ? items.find(item => item.id === normalizeCurrentItem(preferredItemId))
     : null;
 
-  if (currentStatePhase && (
-    isBlockedTaskStatus(trackState?.currentTaskStatus)
-  )) {
-    return {
-      kind: 'plan_phase',
-      command: '/autodev',
-      manualCommand: `/autodev-plan-phase ${currentStatePhase.number}`,
-      reason: 'blocked_phase_requires_replanning',
-      projectType,
-      trackSlug: activeTrack,
-      phaseNumber: currentStatePhase.number
-    };
-  }
-
-  if (currentStatePhase && trackState?.currentStep === 'execution') {
-    return {
-      kind: 'execute_phase',
-      command: '/autodev',
-      manualCommand: `/autodev-execute-phase ${currentStatePhase.number}`,
-      reason: 'phase_execution_in_progress',
-      projectType,
-      trackSlug: activeTrack,
-      phaseNumber: currentStatePhase.number
-    };
-  }
-
-  if (currentStatePhase && trackState?.currentStep === 'task_review') {
-    return {
-      kind: 'task_review',
-      command: '/autodev',
-      manualCommand: `/autodev-review-task ${currentStatePhase.number}`,
-      reason: 'task_execution_checkpoint_pending_user_review',
-      projectType,
-      trackSlug: activeTrack,
-      phaseNumber: currentStatePhase.number
-    };
-  }
-
-  if (currentStatePhase && trackState?.currentStep === 'plan_review') {
-    return {
-      kind: 'plan_review',
-      command: '/autodev',
-      manualCommand: `/autodev-execute-phase ${currentStatePhase.number}`,
-      reason: 'phase_plan_awaits_review',
-      projectType,
-      trackSlug: activeTrack,
-      phaseNumber: currentStatePhase.number
-    };
+  if (preferred && ['pending', 'in_progress'].includes(preferred.status)) {
+    return preferred;
   }
 
-  if (currentStatePhase && trackState?.currentStep === 'review' && !currentStatePhase.reviewExists) {
-    return {
-      kind: 'review_phase',
-      command: '/autodev',
-      manualCommand: `/autodev-review-phase ${currentStatePhase.number}`,
-      reason: 'phase_review_in_progress',
-      projectType,
-      trackSlug: activeTrack,
-      phaseNumber: currentStatePhase.number
-    };
-  }
+  return items.find(item => item.status === 'in_progress')
+    || items.find(item => item.status === 'pending')
+    || null;
+}
 
-  if (currentStatePhase && trackState?.currentStep === 'verification' && !currentStatePhase.uatExists) {
+function buildRoute(cwd) {
+  const paths = rootPaths(cwd);
+  const state = loadState(cwd) || {
+    ...DEFAULT_STATE,
+    project_type: normalizeProjectType(null, cwd)
+  };
+  const plan = parsePlan(readText(paths.plan));
+  const briefExists = fileExists(paths.brief);
+  const contextExists = fileExists(paths.context);
+  const projectType = normalizeProjectType(state.project_type, cwd);
+  const blockedItem = plan.items.find(item => item.status === 'blocked') || null;
+  const nextItem = determineNextItem(plan.items, state.current_item);
+  const allDone = plan.items.length > 0 && plan.items.every(item => item.status === 'done');
+
+  if (!briefExists) {
     return {
-      kind: 'verify_phase',
-      command: '/autodev',
-      manualCommand: `/autodev-verify-work ${currentStatePhase.number}`,
-      reason: 'phase_verification_in_progress',
-      projectType,
-      trackSlug: activeTrack,
-      phaseNumber: currentStatePhase.number
+      kind: 'init_brief',
+      reason: 'brief_missing',
+      command: '/autodev'
     };
   }
 
-  const nextReview = phases.find(phase => phase.summaryExists && !phase.reviewExists);
-  if (nextReview && config.workflow.review_after_execute !== false) {
+  if (projectType === 'brownfield' && !contextExists) {
     return {
-      kind: 'review_phase',
-      command: '/autodev',
-      manualCommand: `/autodev-review-phase ${nextReview.number}`,
-      reason: 'phase_executed_but_not_reviewed',
-      projectType,
-      trackSlug: activeTrack,
-      phaseNumber: nextReview.number
+      kind: 'build_context',
+      reason: 'brownfield_context_missing',
+      command: '/autodev'
     };
   }
 
-  const nextVerify = phases.find(phase => phase.reviewExists && !phase.uatExists);
-  if (nextVerify) {
+  if (plan.items.length === 0) {
     return {
-      kind: 'verify_phase',
-      command: '/autodev',
-      manualCommand: `/autodev-verify-work ${nextVerify.number}`,
-      reason: 'phase_reviewed_but_not_verified',
-      projectType,
-      trackSlug: activeTrack,
-      phaseNumber: nextVerify.number
+      kind: 'plan',
+      reason: 'plan_missing_or_empty',
+      command: '/autodev'
     };
   }
 
-  const nextTaskReview = phases.find(phase => phase.planExists && !phase.summaryExists && phase.taskDoneCount > 0);
-  if (nextTaskReview) {
+  if (state.stage === 'blocked' || blockedItem) {
     return {
-      kind: 'task_review',
+      kind: 'repair_plan',
+      reason: blockedItem ? 'plan_item_blocked' : 'state_marked_blocked',
       command: '/autodev',
-      manualCommand: `/autodev-review-task ${nextTaskReview.number}`,
-      reason: 'phase_task_completed_awaiting_user_review',
-      projectType,
-      trackSlug: activeTrack,
-      phaseNumber: nextTaskReview.number
+      current_item: blockedItem ? blockedItem.id : state.current_item
     };
   }
 
-  const nextPlannedReview = phases.find(phase => phase.planExists && !phase.summaryExists);
-  if (nextPlannedReview) {
+  if (nextItem) {
     return {
-      kind: 'plan_review',
+      kind: 'execute',
+      reason: nextItem.status === 'in_progress' ? 'item_in_progress' : 'pending_plan_item',
       command: '/autodev',
-      manualCommand: `/autodev-execute-phase ${nextPlannedReview.number}`,
-      reason: 'phase_planned_awaiting_user_review',
-      projectType,
-      trackSlug: activeTrack,
-      phaseNumber: nextPlannedReview.number
+      current_item: nextItem.id
     };
   }
 
-  const nextPlan = phases.find(phase => !phase.planExists);
-  if (nextPlan) {
+  if (allDone) {
     return {
-      kind: 'plan_phase',
-      command: '/autodev',
-      manualCommand: `/autodev-plan-phase ${nextPlan.number}`,
-      reason: 'phase_not_planned',
-      projectType,
-      trackSlug: activeTrack,
-      phaseNumber: nextPlan.number
+      kind: 'complete',
+      reason: 'all_plan_items_done',
+      command: '/autodev'
     };
   }
 
   return {
-    kind: 'track_complete',
-    command: '/autodev',
-    manualCommand: '/autodev-cleanup',
-    reason: 'active_track_fully_verified',
-    projectType,
-    trackSlug: activeTrack
+    kind: 'plan',
+    reason: 'plan_needs_refresh',
+    command: '/autodev'
   };
 }
 
-function buildProgress(cwd) {
+function buildStatus(cwd) {
   const paths = rootPaths(cwd);
-  const initialized = fileExists(paths.project);
   const existingCodebase = detectExistingCodebase(cwd);
-  const config = loadConfig(cwd);
-  const projectType = config.project.type || (existingCodebase ? 'brownfield' : 'greenfield');
-  const activeTrack = readActiveTrack(cwd);
-  const tracks = listTracks(cwd);
-  const phases = activeTrack ? listPhases(cwd, activeTrack) : [];
-  const codebaseMapExists = fileExists(paths.codebaseSummary);
+  const autodevExists = fileExists(paths.root);
+  const state = loadState(cwd);
+  const projectType = normalizeProjectType(state?.project_type, cwd);
+  const plan = parsePlan(readText(paths.plan));
+  const counts = {
+    total: plan.items.length,
+    pending: plan.items.filter(item => item.status === 'pending').length,
+    in_progress: plan.items.filter(item => item.status === 'in_progress').length,
+    done: plan.items.filter(item => item.status === 'done').length,
+    blocked: plan.items.filter(item => item.status === 'blocked').length
+  };
   const route = buildRoute(cwd);
+  const currentItem = determineNextItem(plan.items, state?.current_item);
 
   return {
-    initialized,
-    projectType,
-    existingCodebase,
-    codebaseMapExists,
-    activeTrack,
-    tracks,
-    phases,
-    counts: {
-      trackCount: tracks.length,
-      total: phases.length,
-      planned: phases.filter(phase => phase.planExists).length,
-      executed: phases.filter(phase => phase.summaryExists).length,
-      reviewed: phases.filter(phase => phase.reviewExists).length,
-      verified: phases.filter(phase => phase.uatExists).length,
-      tasks: phases.reduce((total, phase) => total + phase.taskCount, 0),
-      tasksDone: phases.reduce((total, phase) => total + phase.taskDoneCount, 0)
-    },
-    route,
-    nextCommand: route.command,
-    manualNextCommand: route.manualCommand || null
+    cwd,
+    workspace_root: paths.workspaceRoot,
+    autodev_root: paths.root,
+    autodev_exists: autodevExists,
+    state_exists: fileExists(paths.state),
+    existing_code_detected: existingCodebase,
+    project_type: projectType,
+    stage: state?.stage || DEFAULT_STATE.stage,
+    current_item: currentItem ? currentItem.id : normalizeCurrentItem(state?.current_item),
+    last_result: state?.last_result || DEFAULT_STATE.last_result,
+    last_run_at: state?.last_run_at || null,
+    last_run_path: state?.last_run_path || null,
+    settings: state?.settings || { ...DEFAULT_STATE.settings },
+    brief_path: paths.brief,
+    brief_exists: fileExists(paths.brief),
+    context_path: paths.context,
+    context_exists: fileExists(paths.context),
+    context_required: projectType === 'brownfield',
+    plan_path: paths.plan,
+    plan_exists: fileExists(paths.plan),
+    plan_goal: plan.goal,
+    plan_done_definition: plan.done_definition,
+    plan_items: plan.items,
+    counts,
+    route
   };
 }
 
-function renderProgressTable(progress) {
-  if (!progress.initialized) {
-    return 'No .autodev project found.\nNext: /autodev';
-  }
-
+function renderStatusTable(status) {
   const lines = [
-    'Autodev Progress',
+    'Autodev Status',
     '',
-    `Project Type: ${progress.projectType}`,
-    `Codebase Map: ${progress.codebaseMapExists ? 'ready' : 'missing'}`,
-    `Tracks: ${progress.counts.trackCount}`,
-    `Active Track: ${progress.activeTrack || 'none'}`,
-    `Phases: ${progress.counts.total}`,
-    `Planned: ${progress.counts.planned}`,
-    `Executed: ${progress.counts.executed}`,
-    `Reviewed: ${progress.counts.reviewed}`,
-    `Verified: ${progress.counts.verified}`,
-    `Tasks: ${progress.counts.tasks}`,
-    `Task Summaries: ${progress.counts.tasksDone}`,
-    `Next: ${progress.route.command}`,
-    progress.route.manualCommand ? `Manual Shortcut: ${progress.route.manualCommand}` : null,
-    '',
-    '| Phase | Type | Name | Tasks | Done | Plan | Summary | Review | UAT | Status |',
-    '| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |'
-  ].filter(Boolean);
+    `Project Type: ${status.project_type}`,
+    `Stage: ${status.stage}`,
+    `Brief: ${status.brief_exists ? 'ready' : 'missing'}`,
+    `Context: ${status.context_required ? (status.context_exists ? 'ready' : 'missing') : 'not required'}`,
+    `Plan: ${status.plan_exists ? `${status.counts.total} item(s)` : 'missing'}`,
+    `Current Item: ${status.current_item || 'none'}`,
+    `Last Result: ${status.last_result}`,
+    `Next: ${status.route.command}`,
+    `Route: ${status.route.kind} (${status.route.reason})`
+  ];
 
-  for (const phase of progress.phases) {
+  if (status.plan_items.length > 0) {
     lines.push(
-      `| ${phase.number} | ${phase.type} | ${phase.name} | ${phase.taskCount} | ${phase.taskDoneCount} | ${phase.planExists ? 'yes' : 'no'} | ${phase.summaryExists ? 'yes' : 'no'} | ${phase.reviewExists ? 'yes' : 'no'} | ${phase.uatExists ? 'yes' : 'no'} | ${phase.status} |`
+      '',
+      '| Item | Status | Title |',
+      '| --- | --- | --- |'
     );
-  }
 
-  if (progress.tracks.length > 0) {
-    lines.push('', '| Track | Active | Name |', '| --- | --- | --- |');
-    for (const track of progress.tracks) {
-      lines.push(`| ${track.slug} | ${track.active ? 'yes' : 'no'} | ${track.name} |`);
+    for (const item of status.plan_items) {
+      lines.push(`| ${item.id} | ${item.status} | ${item.title} |`);
     }
   }
 
   return lines.join('\n');
 }
 
-function dotGet(object, key) {
-  return key.split('.').reduce((current, part) => (
-    current && Object.prototype.hasOwnProperty.call(current, part) ? current[part] : undefined
-  ), object);
-}
+function updateState(cwd, updates = {}) {
+  const current = loadState(cwd) || bootstrapProject(cwd).state;
+  const next = {
+    ...current,
+    ...updates,
+    project_type: updates.project_type !== undefined
+      ? normalizeProjectType(updates.project_type, cwd)
+      : current.project_type,
+    stage: updates.stage !== undefined ? normalizeStage(updates.stage) : current.stage,
+    current_item: updates.current_item !== undefined
+      ? normalizeCurrentItem(updates.current_item)
+      : current.current_item,
+    settings: {
+      ...current.settings,
+      ...((updates.settings && typeof updates.settings === 'object') ? updates.settings : {})
+    }
+  };
+
+  if (updates.last_run_path !== undefined || updates.last_result !== undefined || updates.touch === true) {
+    next.last_run_at = new Date().toISOString();
+  }
 
-function codebasePaths(cwd) {
-  const codebaseDir = rootPaths(cwd).codebaseDir;
-  return Object.fromEntries(CODEBASE_FILES.map(name => [name.replace(/\.md$/, ''), path.join(codebaseDir, name)]));
+  saveState(cwd, next);
+  return loadState(cwd);
 }
 
-function buildStatus(cwd) {
+function createRunReport(cwd, kind = 'run') {
   const paths = rootPaths(cwd);
-  const route = buildRoute(cwd);
-  const config = loadConfig(cwd);
-  const existingCodebase = detectExistingCodebase(cwd);
-  const projectType = config.project.type || (existingCodebase ? 'brownfield' : 'greenfield');
-  const activeTrack = readActiveTrack(cwd);
-  const tracks = listTracks(cwd);
+  ensureDir(paths.runsDir);
 
-  return {
-    cwd,
-    workspace_root: paths.workspaceRoot,
-    autodev_exists: fileExists(paths.root),
-    project_exists: fileExists(paths.project),
-    existing_code_detected: existingCodebase,
-    project_type: projectType,
-    project_path: paths.project,
-    project_state_path: paths.state,
-    active_track_path: paths.activeTrack,
-    active_track: activeTrack,
-    track_count: tracks.length,
-    tracks: tracks.map(track => ({
-      slug: track.slug,
-      name: track.name,
-      active: track.active
-    })),
-    codebase_map_exists: fileExists(paths.codebaseSummary),
-    route
-  };
-}
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const filePath = path.join(paths.runsDir, `${stamp}-${slugify(kind)}.md`);
+  const content = [
+    '# Run Report',
+    '',
+    `Kind: ${kind}`,
+    `Started: ${new Date().toISOString()}`,
+    'Outcome: pending',
+    '',
+    '## Observed',
+    '- [facts only]',
+    '',
+    '## Inferred',
+    '- [none]',
+    '',
+    '## Files Changed',
+    '- [path]',
+    '',
+    '## Verification',
+    '- [command and result]',
+    '',
+    '## Unknowns',
+    '- [none]',
+    ''
+  ].join('\n');
 
-function buildCleanupPayload(cwd) {
-  const paths = rootPaths(cwd);
-  const route = buildRoute(cwd);
-  const activeTrack = readActiveTrack(cwd);
-  const track = trackPaths(cwd, activeTrack);
-  const phases = activeTrack ? listPhases(cwd, activeTrack) : [];
-  const verifiedPhases = phases.filter(phase => phase.uatExists);
-  const completedPhases = phases.filter(phase => phase.summaryExists || phase.reviewExists || phase.uatExists);
+  fs.writeFileSync(filePath, content, 'utf8');
 
   return {
-    cwd,
-    autodev_exists: fileExists(paths.root),
-    project_exists: fileExists(paths.project),
-    project_state_path: paths.state,
-    active_track_path: paths.activeTrack,
-    active_track: activeTrack,
-    track_path: track ? track.dir : null,
-    track_state_path: track ? track.state : null,
-    phases_dir: track ? track.phasesDir : null,
-    archive_root: path.join(paths.root, 'archive'),
-    route,
-    phase_counts: {
-      total: phases.length,
-      completed: completedPhases.length,
-      verified: verifiedPhases.length
-    },
-    verified_phase_numbers: verifiedPhases.map(phase => phase.number),
-    verified_phase_dirs: verifiedPhases.map(phase => phase.dir)
+    kind,
+    path: filePath
   };
 }
 
-function initPayload(cwd, mode, requestedPhase) {
-  const paths = rootPaths(cwd);
-  const config = loadConfig(cwd);
-  const route = buildRoute(cwd);
-  const existingCodebase = detectExistingCodebase(cwd);
-  const projectType = config.project.type || (existingCodebase ? 'brownfield' : 'greenfield');
-  const activeTrack = readActiveTrack(cwd);
-  const tracks = listTracks(cwd);
-  const track = trackPaths(cwd, activeTrack);
-  const phaseMode = mode === 'review-phase'
-    ? 'review'
-    : mode === 'verify-work'
-      ? 'verify'
-      : mode === 'review-task'
-        ? 'task_review'
-      : mode === 'execute-phase' || mode === 'review-plan'
-        ? 'execute'
-        : mode === 'plan-phase'
-          ? 'plan'
-          : null;
-  const phase = phaseMode && activeTrack ? resolvePhase(cwd, activeTrack, requestedPhase, phaseMode) : null;
-  const tasks = phase ? listTasksForPhaseDetails(phase) : [];
-  const nextTask = nextExecutableTask(tasks);
-  const lastCompleted = lastCompletedTask(tasks);
-  const highestTaskNumber = lastTaskNumber(tasks);
-  const dependencyDeadlock = hasDependencyDeadlock(tasks);
-  const trackStateSnapshot = track ? readStateSnapshot(track.state) : null;
-  const currentTaskNumber = (() => {
-    const raw = trackStateSnapshot?.currentTask;
-    if (raw && /^\d+$/.test(raw)) {
-      return Number(raw);
+function dotGet(object, key) {
+  return key.split('.').reduce((current, part) => (
+    current && Object.prototype.hasOwnProperty.call(current, part) ? current[part] : undefined
+  ), object);
+}
+
+function parseOptions(args) {
+  const options = {};
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg.startsWith('--')) {
+      continue;
     }
-    return lastCompleted ? lastCompleted.number : null;
-  })();
-  const currentTask = tasks.find(task => task.number === currentTaskNumber) || lastCompleted || null;
-  const codebase = codebasePaths(cwd);
 
-  return {
-    cwd,
-    autodev_exists: fileExists(paths.root),
-    project_exists: fileExists(paths.project),
-    existing_code_detected: existingCodebase,
-    project_type: projectType,
-    config_path: paths.config,
-    project_path: paths.project,
-    project_state_path: paths.state,
-    active_track_path: paths.activeTrack,
-    active_track: activeTrack,
-    track_count: tracks.length,
-    tracks: tracks.map(trackItem => ({
-      slug: trackItem.slug,
-      name: trackItem.name,
-      active: trackItem.active,
-      path: trackItem.paths.dir
-    })),
-    codebase_dir: paths.codebaseDir,
-    codebase_map_exists: fileExists(paths.codebaseSummary),
-    codebase_paths: codebase,
-    track_path: track ? track.dir : null,
-    track_doc_path: track ? track.track : null,
-    requirements_path: track ? track.requirements : null,
-    roadmap_path: track ? track.roadmap : null,
-    track_state_path: track ? track.state : null,
-    track_state: trackStateSnapshot,
-    phases_dir: track ? track.phasesDir : null,
-    route,
-    phase_found: Boolean(phase),
-    phase_number: phase ? phase.number : null,
-    phase_type: phase ? phase.type : null,
-    phase_name: phase ? phase.name : null,
-    phase_dir: phase ? phase.dir : null,
-    plan_path: phase ? phase.planPath : null,
-    summary_path: phase ? phase.summaryPath : null,
-    review_path: phase ? phase.reviewPath : null,
-    uat_path: phase ? phase.uatPath : null,
-    plan_exists: phase ? phase.planExists : false,
-    summary_exists: phase ? phase.summaryExists : false,
-    review_exists: phase ? phase.reviewExists : false,
-    uat_exists: phase ? phase.uatExists : false,
-    tasks_dir: phase ? phase.dir : null,
-    task_count: tasks.length,
-    task_done_count: tasks.filter(task => task.summaryExists).length,
-    all_tasks_done: tasks.length > 0 && tasks.every(task => task.summaryExists),
-    dependency_deadlock: dependencyDeadlock,
-    last_task_number: highestTaskNumber,
-    next_task_number: nextTask ? nextTask.number : null,
-    next_task_path: nextTask ? nextTask.taskPath : null,
-    next_task_summary_path: nextTask ? nextTask.summaryPath : null,
-    current_task_number: currentTask ? currentTask.number : null,
-    current_task_path: currentTask ? currentTask.taskPath : null,
-    current_task_summary_path: currentTask ? currentTask.summaryPath : null,
-    last_completed_task_number: lastCompleted ? lastCompleted.number : null,
-    last_completed_task_summary_path: lastCompleted ? lastCompleted.summaryPath : null,
-    tasks: tasks.map(task => ({
-      number: task.number,
-      title: task.title,
-      status: task.effectiveStatus,
-      depends_on: task.dependsOn,
-      ready: task.ready,
-      task_path: task.taskPath,
-      summary_path: task.summaryPath,
-      summary_exists: task.summaryExists
-    })),
-    workflow: config.workflow,
-    git_mode: config.git.mode
-  };
+    const key = arg.slice(2).replace(/-/g, '_');
+    const next = args[index + 1];
+
+    if (!next || next.startsWith('--')) {
+      options[key] = true;
+      continue;
+    }
+
+    options[key] = next;
+    index += 1;
+  }
+
+  return options;
 }
 
 function printJson(value) {
@@ -995,8 +756,8 @@ function printJson(value) {
 }
 
 function main() {
-  const args = process.argv.slice(2);
   const cwd = process.cwd();
+  const args = process.argv.slice(2);
 
   if (args.length === 0) {
     process.stderr.write('autodev-tools: command required\n');
@@ -1005,14 +766,27 @@ function main() {
 
   const [command, ...rest] = args;
 
-  if (command === 'progress') {
-    const mode = rest[0] || 'table';
-    const progress = buildProgress(cwd);
-    if (mode === 'json') {
-      printJson(progress);
+  if (command === 'bootstrap') {
+    const options = parseOptions(rest);
+    printJson(bootstrapProject(cwd, {
+      projectType: options.project_type
+    }));
+    return;
+  }
+
+  if (command === 'status') {
+    const mode = rest[0] === 'table' ? 'table' : 'json';
+    const status = buildStatus(cwd);
+    if (mode === 'table') {
+      process.stdout.write(`${renderStatusTable(status)}\n`);
       return;
     }
-    process.stdout.write(`${renderProgressTable(progress)}\n`);
+    printJson(status);
+    return;
+  }
+
+  if (command === 'route') {
+    printJson(buildRoute(cwd));
     return;
   }
 
@@ -1022,7 +796,9 @@ function main() {
       process.stderr.write('autodev-tools: config key required\n');
       process.exit(1);
     }
-    const value = dotGet(loadConfig(cwd), key);
+
+    const state = loadState(cwd) || DEFAULT_STATE;
+    const value = dotGet(state, key);
     if (typeof value === 'object' && value !== null) {
       printJson(value);
     } else if (value !== undefined) {
@@ -1031,35 +807,41 @@ function main() {
     return;
   }
 
-  if (command === 'status') {
-    printJson(buildStatus(cwd));
-    return;
-  }
-
-  if (command === 'cleanup') {
-    printJson(buildCleanupPayload(cwd));
-    return;
-  }
+  if (command === 'update') {
+    const options = parseOptions(rest);
+    const updates = {};
 
-  if (command === 'route') {
-    const mode = rest[0] || 'json';
-    const route = buildRoute(cwd);
-    if (mode === 'json') {
-      printJson(route);
-      return;
+    if (options.project_type !== undefined) {
+      updates.project_type = options.project_type;
+    }
+    if (options.stage !== undefined) {
+      updates.stage = options.stage;
     }
-    process.stdout.write(`${route.command}\n`);
+    if (options.current_item !== undefined) {
+      updates.current_item = options.current_item;
+    }
+    if (options.last_result !== undefined) {
+      updates.last_result = options.last_result;
+    }
+    if (options.last_run_path !== undefined) {
+      updates.last_run_path = options.last_run_path;
+    }
+    if (options.auto_format !== undefined) {
+      updates.settings = {
+        auto_format: options.auto_format !== 'false'
+      };
+    }
+    if (options.touch === true) {
+      updates.touch = true;
+    }
+
+    printJson(updateState(cwd, updates));
     return;
   }
 
-  if (command === 'init') {
-    const mode = rest[0];
-    const phase = rest[1];
-    if (!mode) {
-      process.stderr.write('autodev-tools: init mode required\n');
-      process.exit(1);
-    }
-    printJson(initPayload(cwd, mode, phase));
+  if (command === 'create-run') {
+    const kind = rest[0] || 'run';
+    printJson(createRunReport(cwd, kind));
     return;
   }
 
@@ -1072,26 +854,20 @@ if (require.main === module) {
 }
 
 module.exports = {
+  DEFAULT_STATE,
   autodevDir,
-  buildCleanupPayload,
-  buildProgress,
+  bootstrapProject,
   buildRoute,
   buildStatus,
+  createRunReport,
   detectExistingCodebase,
   findWorkspaceRoot,
-  initPayload,
-  listPhases,
-  listTracks,
-  loadConfig,
-  parseRoadmap,
-  readActiveTrack,
-  renderProgressTable,
-  resolvePhase,
+  loadState,
+  normalizeCurrentItem,
+  normalizeProjectType,
+  parsePlan,
+  renderStatusTable,
   rootPaths,
-  trackPaths,
-  listTasksForPhaseDetails,
-  lastCompletedTask,
-  lastTaskNumber,
-  hasDependencyDeadlock,
-  nextExecutableTask
+  saveState,
+  updateState
 };