@vexdo/cli 0.1.4 → 0.2.1

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import fs9 from "fs";
-import path11 from "path";
+import fs10 from "fs";
+import path12 from "path";
 import { Command } from "commander";
 
 // src/commands/abort.ts
@@ -79,6 +79,15 @@ function parseReview(value) {
     auto_submit
   };
 }
+function parseMaxConcurrent(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    throw new Error("maxConcurrent must be a positive integer");
+  }
+  return value;
+}
 function parseCodex(value) {
   if (value === void 0) {
     return { model: DEFAULT_CODEX_MODEL };
@@ -113,8 +122,8 @@ function loadConfig(projectRoot) {
   let parsed;
   try {
     parsed = parse(configRaw);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
     throw new Error(`Invalid YAML in .vexdo.yml: ${message}`);
   }
   if (!isRecord(parsed)) {
@@ -127,11 +136,13 @@ function loadConfig(projectRoot) {
   const services = parseServices(readObjectField(parsed, "services"));
   const review = parseReview(readObjectField(parsed, "review"));
   const codex = parseCodex(readObjectField(parsed, "codex"));
+  const maxConcurrent = parseMaxConcurrent(readObjectField(parsed, "maxConcurrent"));
   return {
     version: 1,
     services,
     review,
-    codex
+    codex,
+    maxConcurrent
   };
 }
 
@@ -161,15 +172,15 @@ function success(message) {
 function warn(message) {
   safeLog("log", `${pc.yellow("\u26A0")} ${message}`);
 }
+function error(message) {
+  safeLog("error", `${pc.red("\u2716")} ${message}`);
+}
 function debug(message) {
   if (!verboseEnabled) {
     return;
   }
   safeLog("log", `${pc.gray("\u2022")} ${message}`);
 }
-function step(n, total, title) {
-  safeLog("log", `${pc.bold(`Step ${String(n)}/${String(total)}:`)} ${title}`);
-}
 function iteration(n, max) {
   safeLog("log", pc.gray(`Iteration ${String(n)}/${String(max)}`));
 }
@@ -228,6 +239,56 @@ function reviewSummary(comments) {
     safeLog("log", `- ${comment.severity}${location}: ${comment.comment}`);
   }
 }
+function prefixed(prefix, message) {
+  return `${prefix}  ${message}`;
+}
+function withPrefix(prefix) {
+  return {
+    info: (message) => {
+      info(prefixed(prefix, message));
+    },
+    success: (message) => {
+      success(prefixed(prefix, message));
+    },
+    warn: (message) => {
+      warn(prefixed(prefix, message));
+    },
+    error: (message) => {
+      error(prefixed(prefix, message));
+    },
+    debug: (message) => {
+      debug(prefixed(prefix, message));
+    },
+    iteration: (n, max) => {
+      safeLog("log", prefixed(prefix, pc.gray(`Iteration ${String(n)}/${String(max)}`)));
+    },
+    reviewSummary: (comments) => {
+      const counts = {
+        critical: 0,
+        important: 0,
+        minor: 0,
+        noise: 0
+      };
+      for (const comment of comments) {
+        counts[comment.severity] += 1;
+      }
+      safeLog(
+        "log",
+        prefixed(
+          prefix,
+          `${pc.bold("Review:")} ${String(counts.critical)} critical ${String(counts.important)} important ${String(counts.minor)} minor`
+        )
+      );
+      for (const comment of comments) {
+        if (comment.severity === "noise") {
+          continue;
+        }
+        const location = comment.file ? ` (${comment.file}${comment.line ? `:${String(comment.line)}` : ""})` : "";
+        safeLog("log", prefixed(prefix, `- ${comment.severity}${location}: ${comment.comment}`));
+      }
+    }
+  };
+}
 
 // src/lib/state.ts
 import fs2 from "fs";
@@ -257,8 +318,8 @@ function loadState(projectRoot) {
   const raw = fs2.readFileSync(statePath, "utf8");
   try {
     return JSON.parse(raw);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
     throw new Error(`Corrupt state file at ${statePath}: ${message}`);
   }
 }
@@ -271,6 +332,34 @@ function saveState(projectRoot, state) {
   };
   fs2.writeFileSync(getStatePath(projectRoot), JSON.stringify(nextState, null, 2) + "\n", "utf8");
 }
+async function updateStep(projectRoot, taskId, service, updates) {
+  const currentState = loadState(projectRoot);
+  if (!currentState) {
+    throw new Error("No active state found to update.");
+  }
+  if (currentState.taskId !== taskId) {
+    throw new Error(`State task mismatch. Expected '${taskId}', found '${currentState.taskId}'.`);
+  }
+  const nextState = {
+    ...currentState,
+    steps: currentState.steps.map((step) => {
+      if (step.service !== service) {
+        return step;
+      }
+      return {
+        ...step,
+        ...updates
+      };
+    }),
+    updatedAt: nowIso()
+  };
+  const stateDir = getStateDir(projectRoot);
+  fs2.mkdirSync(stateDir, { recursive: true });
+  const statePath = getStatePath(projectRoot);
+  const tmpPath = `${statePath}.tmp`;
+  await fs2.promises.writeFile(tmpPath, JSON.stringify(nextState, null, 2) + "\n", "utf8");
+  await fs2.promises.rename(tmpPath, statePath);
+}
 function clearState(projectRoot) {
   const statePath = getStatePath(projectRoot);
   if (fs2.existsSync(statePath)) {
@@ -341,13 +430,46 @@ function parseTaskStep(value, index, config) {
     depends_on
   };
 }
+function validateDependencies(steps) {
+  const byService = new Map(steps.map((step) => [step.service, step]));
+  for (const step of steps) {
+    for (const dep of step.depends_on ?? []) {
+      if (!byService.has(dep)) {
+        throw new Error(`step '${step.service}' depends on unknown service '${dep}'`);
+      }
+      if (dep === step.service) {
+        throw new Error(`step '${step.service}' cannot depend on itself`);
+      }
+    }
+  }
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (service) => {
+    if (visited.has(service)) {
+      return;
+    }
+    if (visiting.has(service)) {
+      throw new Error(`Dependency cycle detected involving service '${service}'`);
+    }
+    visiting.add(service);
+    const step = byService.get(service);
+    for (const dep of step?.depends_on ?? []) {
+      visit(dep);
+    }
+    visiting.delete(service);
+    visited.add(service);
+  };
+  for (const step of steps) {
+    visit(step.service);
+  }
+}
 function loadAndValidateTask(taskPath, config) {
   const raw = fs3.readFileSync(taskPath, "utf8");
   let parsed;
   try {
     parsed = parseYaml(raw);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
     throw new Error(`Invalid task YAML: ${message}`);
   }
   if (!isRecord2(parsed)) {
@@ -358,12 +480,13 @@ function loadAndValidateTask(taskPath, config) {
   if (!Array.isArray(parsed.steps) || parsed.steps.length === 0) {
     throw new Error("steps must be a non-empty array");
   }
-  const steps = parsed.steps.map((step2, index) => parseTaskStep(step2, index, config));
+  const steps = parsed.steps.map((step, index) => parseTaskStep(step, index, config));
+  validateDependencies(steps);
   return { id, title, steps };
 }
 function buildInitialStepState(task) {
-  return task.steps.map((step2) => ({
-    service: step2.service,
+  return task.steps.map((step) => ({
+    service: step.service,
     status: "pending",
     iteration: 0
   }));
@@ -423,8 +546,328 @@ function registerAbortCommand(program2) {
   });
 }
 
+// src/commands/board.tsx
+import { render } from "ink";
+
+// src/components/Board.tsx
+import { spawnSync } from "child_process";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+
+// src/lib/board.ts
+import fs5 from "fs";
+import path5 from "path";
+import { parse as parse2 } from "yaml";
+function parseTaskYaml(raw) {
+  try {
+    const parsed = parse2(raw);
+    if (typeof parsed !== "object" || parsed === null) {
+      return {};
+    }
+    const obj = parsed;
+    return {
+      id: typeof obj.id === "string" ? obj.id : void 0,
+      title: typeof obj.title === "string" ? obj.title : void 0
+    };
+  } catch {
+    return {};
+  }
+}
+async function listTaskFiles(directory) {
+  if (!fs5.existsSync(directory)) {
+    return [];
+  }
+  const entries = await fs5.promises.readdir(directory, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && (entry.name.endsWith(".yml") || entry.name.endsWith(".yaml"))).map((entry) => path5.join(directory, entry.name));
+}
+async function readTaskSummary(filePath) {
+  const raw = await fs5.promises.readFile(filePath, "utf8");
+  const parsed = parseTaskYaml(raw);
+  const fallbackId = path5.basename(filePath).replace(/\.ya?ml$/i, "");
+  return {
+    id: parsed.id ?? fallbackId,
+    title: parsed.title ?? fallbackId,
+    path: filePath
+  };
+}
+async function loadColumn(projectRoot, columnDir) {
+  const directory = path5.join(projectRoot, "tasks", columnDir);
+  const files = await listTaskFiles(directory);
+  const tasks = await Promise.all(files.map((filePath) => readTaskSummary(filePath)));
+  return tasks.sort((a, b) => a.id.localeCompare(b.id));
+}
+async function loadBoardState(projectRoot) {
+  const [backlog, inProgress, review, blocked, doneFiles] = await Promise.all([
+    loadColumn(projectRoot, "backlog"),
+    loadColumn(projectRoot, "in_progress"),
+    loadColumn(projectRoot, "review"),
+    loadColumn(projectRoot, "blocked"),
+    listTaskFiles(path5.join(projectRoot, "tasks", "done"))
+  ]);
+  const doneWithStats = await Promise.all(
+    doneFiles.map(async (filePath) => ({
+      filePath,
+      stat: await fs5.promises.stat(filePath)
+    }))
+  );
+  doneWithStats.sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+  const done = await Promise.all(doneWithStats.slice(0, 20).map((item) => readTaskSummary(item.filePath)));
+  return {
+    backlog,
+    in_progress: inProgress,
+    review,
+    done,
+    blocked: blocked.map((task) => ({ ...task, blocked: true }))
+  };
+}
+
+// src/components/Board.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(value, max));
+}
+function runExternal(command, args) {
+  const wasRaw = process.stdin.isTTY && process.stdin.isRaw;
+  if (process.stdin.isTTY && wasRaw) {
+    process.stdin.setRawMode(false);
+  }
+  const result = spawnSync(command, args, { stdio: "inherit" });
+  if (process.stdin.isTTY && wasRaw) {
+    process.stdin.setRawMode(true);
+  }
+  if (result.error) {
+    return {
+      ok: false,
+      message: result.error.message
+    };
+  }
+  return {
+    ok: result.status === 0,
+    message: result.status === 0 ? "Command completed." : `Command exited with status ${String(result.status)}.`
+  };
+}
+function openInEditor(filePath) {
+  const editor = process.env.EDITOR;
+  if (!editor) {
+    return { ok: false, message: "EDITOR is not set." };
+  }
+  return runExternal(editor, [filePath]);
+}
+function runPrimaryAction(column, task) {
+  if (task.blocked) {
+    return runExternal("vexdo", ["logs", task.id]);
+  }
+  if (column === "backlog") {
+    return runExternal("vexdo", ["start", task.path]);
+  }
+  if (column === "in_progress") {
+    return runExternal("vexdo", ["status"]);
+  }
+  if (column === "review") {
+    return runExternal("vexdo", ["submit"]);
+  }
+  return openInEditor(task.path);
+}
+function TaskCard({ task, selected }) {
+  const prefix = task.blocked ? "\u26A0 " : "";
+  return /* @__PURE__ */ jsx(Text, { children: `${selected ? "> " : "  "}${prefix}${task.id}` });
+}
+function Column({
+  title,
+  count,
+  tasks,
+  selectedRow,
+  active
+}) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", flexGrow: 1, borderStyle: "single", paddingX: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color: active ? "cyan" : void 0, children: title }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: `(${String(count)})` }),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+      tasks.length === 0 ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  \u2014" }) : null,
+      tasks.map((task, index) => /* @__PURE__ */ jsx(TaskCard, { task, selected: active && index === selectedRow }, `${task.path}-${task.id}`))
+    ] })
+  ] });
+}
+function StatusBar({
+  task,
+  column,
+  message,
+  confirmAbort
+}) {
+  if (!task) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "No task selected." }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "[\u2190/\u2192/\u2191/\u2193] navigate  [r] refresh  [q] quit" })
+    ] });
+  }
+  const primaryLabel = task.blocked ? "[\u21B5] logs" : column === "backlog" ? "[\u21B5] start" : column === "in_progress" ? "[\u21B5] status" : column === "review" ? "[\u21B5] submit" : "[\u21B5] edit";
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [
+    /* @__PURE__ */ jsx(Text, { children: `${task.id} \xB7 ${task.title}` }),
+    /* @__PURE__ */ jsx(Text, { children: `${primaryLabel}  [e] edit  [l] logs  [a] abort  [r] refresh  [q] quit${confirmAbort ? "  Confirm abort: press [a] again" : ""}` }),
+    message ? /* @__PURE__ */ jsx(Text, { color: "yellow", children: message }) : null
+  ] });
+}
+function Board({ projectRoot }) {
+  const { exit } = useApp();
+  const [state, setState] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [cursor, setCursor] = useState({ column: 0, row: 0 });
+  const [message, setMessage] = useState(null);
+  const [confirmAbort, setConfirmAbort] = useState(false);
+  const refresh = useCallback(async () => {
+    setLoading(true);
+    try {
+      const next = await loadBoardState(projectRoot);
+      setState(next);
+      setMessage(null);
+    } catch (error2) {
+      const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+      setMessage(`Failed to load board: ${errorMessage}`);
+    } finally {
+      setLoading(false);
+    }
+  }, [projectRoot]);
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  const columns = useMemo(() => {
+    if (!state) {
+      return [
+        { key: "backlog", title: "BACKLOG", tasks: [] },
+        { key: "in_progress", title: "IN PROGRESS", tasks: [] },
+        { key: "review", title: "REVIEW", tasks: [] },
+        { key: "done", title: "DONE", tasks: [] }
+      ];
+    }
+    return [
+      { key: "backlog", title: "BACKLOG", tasks: [...state.blocked, ...state.backlog] },
+      { key: "in_progress", title: "IN PROGRESS", tasks: state.in_progress },
+      { key: "review", title: "REVIEW", tasks: state.review },
+      { key: "done", title: "DONE", tasks: state.done }
+    ];
+  }, [state]);
+  const activeColumn = columns[cursor.column] ?? columns[0];
+  const selectedTask = activeColumn.tasks.at(cursor.row);
+  useEffect(() => {
+    const nextColumn = clamp(cursor.column, 0, columns.length - 1);
+    const maxRow = Math.max(0, (columns[nextColumn]?.tasks.length ?? 1) - 1);
+    const nextRow = clamp(cursor.row, 0, maxRow);
+    if (nextColumn !== cursor.column || nextRow !== cursor.row) {
+      setCursor({ column: nextColumn, row: nextRow });
+    }
+  }, [columns, cursor.column, cursor.row]);
+  useInput((input2, key) => {
+    if (input2 === "q" || key.ctrl && input2 === "c") {
+      exit();
+      return;
+    }
+    if (key.leftArrow) {
+      setConfirmAbort(false);
+      setCursor((prev) => {
+        const nextColumn = clamp(prev.column - 1, 0, columns.length - 1);
+        const maxRow = Math.max(0, columns[nextColumn].tasks.length - 1);
+        return { column: nextColumn, row: clamp(prev.row, 0, maxRow) };
+      });
+      return;
+    }
+    if (key.rightArrow) {
+      setConfirmAbort(false);
+      setCursor((prev) => {
+        const nextColumn = clamp(prev.column + 1, 0, columns.length - 1);
+        const maxRow = Math.max(0, columns[nextColumn].tasks.length - 1);
+        return { column: nextColumn, row: clamp(prev.row, 0, maxRow) };
+      });
+      return;
+    }
+    if (key.upArrow) {
+      setConfirmAbort(false);
+      setCursor((prev) => ({ ...prev, row: clamp(prev.row - 1, 0, Math.max(0, activeColumn.tasks.length - 1)) }));
+      return;
+    }
+    if (key.downArrow) {
+      setConfirmAbort(false);
+      setCursor((prev) => ({ ...prev, row: clamp(prev.row + 1, 0, Math.max(0, activeColumn.tasks.length - 1)) }));
+      return;
+    }
+    if (input2 === "r") {
+      setConfirmAbort(false);
+      void refresh();
+      return;
+    }
+    if (key.return && selectedTask) {
+      const result = runPrimaryAction(activeColumn.key, selectedTask);
+      setMessage(result.message);
+      setConfirmAbort(false);
+      void refresh();
+      return;
+    }
+    if (input2 === "e" && selectedTask) {
+      const result = openInEditor(selectedTask.path);
+      setMessage(result.message);
+      setConfirmAbort(false);
+      return;
+    }
+    if (input2 === "l" && selectedTask) {
+      const result = runExternal("vexdo", ["logs", selectedTask.id]);
+      setMessage(result.message);
+      setConfirmAbort(false);
+      return;
+    }
+    if (input2 === "a" && selectedTask) {
+      if (!confirmAbort) {
+        setConfirmAbort(true);
+        setMessage(`Confirm abort task '${selectedTask.id}' by pressing 'a' again.`);
+        return;
+      }
+      const result = runExternal("vexdo", ["abort"]);
+      setMessage(result.message);
+      setConfirmAbort(false);
+      void refresh();
+    }
+  });
+  const terminalRows = typeof process.stdout.rows === "number" ? process.stdout.rows : 24;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", height: terminalRows, children: [
+    /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", borderStyle: "single", paddingX: 1, children: [
+      /* @__PURE__ */ jsx(Text, { children: "vexdo board" }),
+      /* @__PURE__ */ jsx(Text, { children: "[q] quit" })
+    ] }),
+    loading ? /* @__PURE__ */ jsx(Box, { borderStyle: "single", paddingX: 1, children: /* @__PURE__ */ jsx(Text, { children: "Loading tasks\u2026" }) }) : /* @__PURE__ */ jsx(Box, { flexGrow: 1, children: columns.map((column, index) => /* @__PURE__ */ jsx(
+      Column,
+      {
+        title: column.title,
+        count: column.tasks.length,
+        tasks: column.tasks,
+        selectedRow: cursor.row,
+        active: index === cursor.column
+      },
+      column.key
+    )) }),
+    /* @__PURE__ */ jsx(StatusBar, { task: selectedTask, column: activeColumn.key, message, confirmAbort })
+  ] });
+}
+
+// src/commands/board.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function fatalAndExit2(message) {
+  fatal(message);
+  process.exit(1);
+}
+async function runBoard() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    fatalAndExit2("Not inside a vexdo project.");
+  }
+  const instance = render(/* @__PURE__ */ jsx2(Board, { projectRoot }));
+  await instance.waitUntilExit();
+}
+function registerBoardCommand(program2) {
+  program2.command("board").description("Open interactive task board").action(() => {
+    void runBoard();
+  });
+}
+
 // src/commands/fix.ts
-import path6 from "path";
+import path7 from "path";
 
 // src/lib/claude.ts
 import Anthropic from "@anthropic-ai/sdk";
@@ -547,10 +990,10 @@ ${JSON.stringify(opts.reviewComments)}`
     for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
       try {
         return await fn();
-      } catch (error) {
-        lastError = error;
-        if (!isRetryableError(error) || attempt === MAX_ATTEMPTS) {
-          throw new ClaudeError(attempt, error);
+      } catch (error2) {
+        lastError = error2;
+        if (!isRetryableError(error2) || attempt === MAX_ATTEMPTS) {
+          throw new ClaudeError(attempt, error2);
         }
         const backoffMs = 1e3 * 2 ** (attempt - 1);
         warn(
@@ -579,7 +1022,7 @@ function extractJson(text) {
     return trimmed;
   }
   const fenced = /^```(?:json)?\s*([\s\S]*?)\s*```$/i.exec(trimmed);
-  if (fenced && fenced[1]) {
+  if (fenced?.[1]) {
     return fenced[1].trim();
   }
   return trimmed;
@@ -588,8 +1031,8 @@ function parseReviewerResult(raw) {
   let parsed;
   try {
     parsed = JSON.parse(extractJson(raw));
-  } catch (error) {
-    throw new Error(`Failed to parse reviewer JSON: ${error instanceof Error ? error.message : String(error)}`);
+  } catch (error2) {
+    throw new Error(`Failed to parse reviewer JSON: ${error2 instanceof Error ? error2.message : String(error2)}`);
   }
   if (!isReviewResult(parsed)) {
     throw new Error("Reviewer JSON does not match schema");
@@ -600,8 +1043,8 @@ function parseArbiterResult(raw) {
   let parsed;
   try {
     parsed = JSON.parse(extractJson(raw));
-  } catch (error) {
-    throw new Error(`Failed to parse arbiter JSON: ${error instanceof Error ? error.message : String(error)}`);
+  } catch (error2) {
+    throw new Error(`Failed to parse arbiter JSON: ${error2 instanceof Error ? error2.message : String(error2)}`);
   }
   if (!isArbiterResult(parsed)) {
     throw new Error("Arbiter JSON does not match schema");
@@ -650,11 +1093,11 @@ function isArbiterResult(value) {
   }
   return candidate.feedback_for_codex === void 0;
 }
-function getStatusCode(error) {
-  if (typeof error !== "object" || error === null) {
+function getStatusCode(error2) {
+  if (typeof error2 !== "object" || error2 === null) {
     return void 0;
   }
-  const candidate = error;
+  const candidate = error2;
   if (typeof candidate.status === "number") {
     return candidate.status;
   }
@@ -663,8 +1106,8 @@ function getStatusCode(error) {
   }
   return void 0;
 }
-function isRetryableError(error) {
-  const status = getStatusCode(error);
+function isRetryableError(error2) {
+  const status = getStatusCode(error2);
   if (status === 400 || status === 401 || status === 403) {
     return false;
   }
@@ -675,19 +1118,31 @@ function isRetryableError(error) {
 }
 
 // src/lib/codex.ts
-import { execFile as execFileCb } from "child_process";
+import { spawn } from "child_process";
 var CODEX_TIMEOUT_MS = 6e5;
-var VERBOSE_HEARTBEAT_MS = 15e3;
 var CodexError = class extends Error {
+  code;
   stdout;
   stderr;
   exitCode;
-  constructor(stdout, stderr, exitCode) {
-    super(`codex exec failed (exit ${String(exitCode)})`);
+  constructor(code, message, details) {
+    super(message);
     this.name = "CodexError";
-    this.stdout = stdout;
-    this.stderr = stderr;
-    this.exitCode = exitCode;
+    this.code = code;
+    this.stdout = details?.stdout ?? "";
+    this.stderr = details?.stderr ?? "";
+    this.exitCode = details?.exitCode ?? 1;
+  }
+};
+var CodexTimeoutError = class extends CodexError {
+  sessionId;
+  constructor(sessionId, timeoutMs) {
+    super(
+      "poll_timeout",
+      `Timed out waiting for codex cloud session ${sessionId} after ${String(timeoutMs)}ms. Check status with: codex cloud status ${sessionId}`
+    );
+    this.name = "CodexTimeoutError";
+    this.sessionId = sessionId;
   }
 };
 var CodexNotFoundError = class extends Error {
@@ -696,110 +1151,141 @@ var CodexNotFoundError = class extends Error {
     this.name = "CodexNotFoundError";
   }
 };
-function formatElapsed(startedAt) {
-  const seconds = Math.max(0, Math.round((Date.now() - startedAt) / 1e3));
-  return `${String(seconds)}s`;
+function runCodexCommand(args, opts) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("codex", args, {
+      cwd: opts?.cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    const timeout = setTimeout(() => {
+      child.kill("SIGTERM");
+      reject(new Error(`codex command timed out after ${String(opts?.timeoutMs ?? CODEX_TIMEOUT_MS)}ms`));
+    }, opts?.timeoutMs ?? CODEX_TIMEOUT_MS);
+    child.once("error", (error2) => {
+      clearTimeout(timeout);
+      reject(error2);
+    });
+    child.once("close", (code) => {
+      clearTimeout(timeout);
+      resolve({
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: code ?? 1
+      });
+    });
+  });
 }
-function buildVerboseStreamHandler(label) {
-  let partialLine = "";
-  return {
-    onData(chunk) {
-      partialLine += chunk.toString();
-      const lines = partialLine.split(/\r?\n/);
-      partialLine = lines.pop() ?? "";
-      for (const line of lines) {
-        if (!line) {
-          continue;
-        }
-        debug(`[codex:${label}] ${line}`);
-      }
-    },
-    flush() {
-      if (!partialLine) {
-        return;
+function parseSessionId(output2) {
+  const match = /session[_-]?id\s*[:=]\s*([A-Za-z0-9._-]+)/i.exec(output2);
+  if (match?.[1]) {
+    return match[1];
+  }
+  for (const line of output2.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (typeof parsed.session_id === "string" && parsed.session_id.length > 0) {
+        return parsed.session_id;
       }
-      debug(`[codex:${label}] ${partialLine}`);
-      partialLine = "";
+    } catch {
     }
-  };
+  }
+  return null;
+}
+function parseStatus(output2) {
+  const match = /\b(completed|failed)\b/i.exec(output2);
+  if (!match?.[1]) {
+    return null;
+  }
+  return match[1].toLowerCase();
 }
 async function checkCodexAvailable() {
-  await new Promise((resolve, reject) => {
-    execFileCb("codex", ["--version"], { timeout: CODEX_TIMEOUT_MS, encoding: "utf8" }, (error) => {
-      if (error) {
-        reject(new CodexNotFoundError());
-        return;
-      }
-      resolve();
+  try {
+    const result = await runCodexCommand(["--version"]);
+    if (result.exitCode !== 0) {
+      throw new CodexNotFoundError();
+    }
+  } catch {
+    throw new CodexNotFoundError();
+  }
+}
+async function submitTask(prompt, options) {
+  const args = ["cloud", "exec", prompt];
+  if (options?.cwd) {
+    args.push("-C", options.cwd);
+  }
+  const result = await runCodexCommand(args, { cwd: options?.cwd });
+  const sessionId = parseSessionId(result.stdout);
+  if (result.exitCode !== 0 || !sessionId) {
+    throw new CodexError("submit_failed", "Failed to submit task to codex cloud.", result);
+  }
+  return sessionId;
+}
+async function resumeTask(sessionId, feedback) {
+  const result = await runCodexCommand(["cloud", "exec", "resume", sessionId, feedback]);
+  const nextSessionId = parseSessionId(result.stdout);
+  if (result.exitCode !== 0 || !nextSessionId) {
+    throw new CodexError("resume_failed", `Failed to resume codex cloud session ${sessionId}.`, result);
+  }
+  return nextSessionId;
+}
+async function pollStatus(sessionId, opts) {
+  const startedAt = Date.now();
+  for (; ; ) {
+    const result = await runCodexCommand(["cloud", "status", sessionId]);
+    if (result.exitCode !== 0) {
+      throw new CodexError("poll_failed", `Failed to poll codex cloud status for session ${sessionId}.`, result);
+    }
+    const status = parseStatus(result.stdout);
+    if (status === "completed" || status === "failed") {
+      return status;
+    }
+    if (Date.now() - startedAt >= opts.timeoutMs) {
+      throw new CodexTimeoutError(sessionId, opts.timeoutMs);
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, opts.intervalMs);
     });
-  });
+  }
+}
+async function getDiff(sessionId) {
+  const result = await runCodexCommand(["cloud", "diff", sessionId]);
+  if (result.exitCode !== 0) {
+    throw new CodexError("poll_failed", `Failed to get diff for codex cloud session ${sessionId}.`, result);
+  }
+  if (!result.stdout.trim()) {
+    throw new CodexError("diff_empty", `Diff was empty for codex cloud session ${sessionId}.`, result);
+  }
+  return result.stdout;
+}
+async function applyDiff(sessionId) {
+  const result = await runCodexCommand(["cloud", "apply", sessionId]);
+  if (result.exitCode !== 0) {
+    throw new CodexError("apply_failed", `Failed to apply diff for codex cloud session ${sessionId}.`, result);
+  }
 }
 async function exec(opts) {
-  const args = ["exec", "--model", opts.model, "--full-auto", "--", opts.spec];
-  const startedAt = Date.now();
-  if (opts.verbose) {
-    debug(`[codex] starting (model=${opts.model}, cwd=${opts.cwd})`);
+  const sessionId = await submitTask(opts.spec, { cwd: opts.cwd });
+  const status = await pollStatus(sessionId, { intervalMs: 2e3, timeoutMs: CODEX_TIMEOUT_MS });
+  if (status !== "completed") {
+    throw new CodexError("submit_failed", `Codex cloud session ${sessionId} ended with status '${status}'.`);
   }
-  return await new Promise((resolve, reject) => {
-    let liveLogsAttached = false;
-    const stdoutHandler = buildVerboseStreamHandler("stdout");
-    const stderrHandler = buildVerboseStreamHandler("stderr");
-    const heartbeat = opts.verbose ? setInterval(() => {
-      debug(`[codex] still running (${formatElapsed(startedAt)})`);
-    }, VERBOSE_HEARTBEAT_MS) : null;
-    const child = execFileCb(
-      "codex",
-      args,
-      { cwd: opts.cwd, timeout: CODEX_TIMEOUT_MS, encoding: "utf8", maxBuffer: 10 * 1024 * 1024 },
-      (error, stdout, stderr) => {
-        if (heartbeat) {
-          clearInterval(heartbeat);
-        }
-        stdoutHandler.flush();
-        stderrHandler.flush();
-        const normalizedStdout = stdout.trimEnd();
-        const normalizedStderr = stderr.trimEnd();
-        if (opts.verbose) {
-          debug(`[codex] finished in ${formatElapsed(startedAt)}`);
-          if (!liveLogsAttached && normalizedStdout) {
-            debug(normalizedStdout);
-          }
-          if (!liveLogsAttached && normalizedStderr) {
-            debug(normalizedStderr);
-          }
-        }
-        if (error) {
-          const exitCode = typeof error.code === "number" ? error.code : 1;
-          if (opts.verbose) {
-            debug(`[codex] failed in ${formatElapsed(startedAt)} with exit ${String(exitCode)}`);
-          }
-          reject(new CodexError(normalizedStdout, normalizedStderr || error.message, exitCode));
-          return;
-        }
-        resolve({
-          stdout: normalizedStdout,
-          stderr: normalizedStderr,
-          exitCode: 0
-        });
-      }
-    );
-    if (opts.verbose) {
-      const stdout = child.stdout;
-      const stderr = child.stderr;
-      if (stdout) {
-        liveLogsAttached = true;
-        stdout.on("data", stdoutHandler.onData);
-      }
-      if (stderr) {
-        liveLogsAttached = true;
-        stderr.on("data", stderrHandler.onData);
-      }
-    }
-  });
+  await applyDiff(sessionId);
 }
 
 // src/lib/gh.ts
-import { execFile as execFileCb2 } from "child_process";
+import { execFile as execFileCb } from "child_process";
 var GH_TIMEOUT_MS = 3e4;
 var GIT_TIMEOUT_MS = 3e4;
 var GhNotFoundError = class extends Error {
@@ -820,36 +1306,36 @@ var GitCommandError = class extends Error {
 };
 async function execGit(args, cwd) {
   await new Promise((resolve, reject) => {
-    execFileCb2("git", args, { cwd, timeout: GIT_TIMEOUT_MS, encoding: "utf8" }, (error, _stdout, stderr) => {
-      if (error) {
-        const exitCode = typeof error.code === "number" ? error.code : -1;
-        reject(new GitCommandError(args, exitCode, (stderr || error.message).trim()));
+    execFileCb("git", args, { cwd, timeout: GIT_TIMEOUT_MS, encoding: "utf8" }, (error2, _stdout, stderr) => {
+      if (error2) {
+        const exitCode = typeof error2.code === "number" ? error2.code : -1;
+        reject(new GitCommandError(args, exitCode, (stderr || error2.message).trim()));
         return;
       }
       resolve();
     });
   });
 }
-function isNoUpstreamError(error) {
-  const text = error.stderr.toLowerCase();
+function isNoUpstreamError(error2) {
+  const text = error2.stderr.toLowerCase();
   return text.includes("no upstream configured for branch") || text.includes("has no upstream branch");
 }
 async function pushCurrentBranch(cwd) {
   try {
     await execGit(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], cwd);
     await execGit(["push"], cwd);
-  } catch (error) {
-    if (error instanceof GitCommandError && isNoUpstreamError(error)) {
+  } catch (error2) {
+    if (error2 instanceof GitCommandError && isNoUpstreamError(error2)) {
       await execGit(["push", "--set-upstream", "origin", "HEAD"], cwd);
       return;
     }
-    throw error;
+    throw error2;
   }
 }
 async function checkGhAvailable() {
   await new Promise((resolve, reject) => {
-    execFileCb2("gh", ["--version"], { timeout: GH_TIMEOUT_MS, encoding: "utf8" }, (error) => {
-      if (error) {
+    execFileCb("gh", ["--version"], { timeout: GH_TIMEOUT_MS, encoding: "utf8" }, (error2) => {
+      if (error2) {
         reject(new GhNotFoundError());
         return;
       }
@@ -861,17 +1347,17 @@ async function createPr(opts) {
   const base = opts.base ?? "main";
   try {
     await pushCurrentBranch(opts.cwd);
-  } catch (error) {
-    throw new Error(`Failed to push current branch before creating PR: ${error instanceof Error ? error.message : String(error)}`);
+  } catch (error2) {
+    throw new Error(`Failed to push current branch before creating PR: ${error2 instanceof Error ? error2.message : String(error2)}`);
   }
   return await new Promise((resolve, reject) => {
-    execFileCb2(
+    execFileCb(
       "gh",
       ["pr", "create", "--title", opts.title, "--body", opts.body, "--base", base],
       { cwd: opts.cwd, timeout: GH_TIMEOUT_MS, encoding: "utf8" },
-      (error, stdout, stderr) => {
-        if (error) {
-          reject(new Error((stderr || error.message).trim()));
+      (error2, stdout, stderr) => {
+        if (error2) {
+          reject(new Error((stderr || error2.message).trim()));
           return;
         }
         resolve(stdout.trim());
@@ -893,10 +1379,193 @@ async function requireGhAvailable() {
 }
 
 // src/lib/review-loop.ts
-import path5 from "path";
+import path6 from "path";
+
+// src/lib/copilot.ts
+import { spawn as spawn2 } from "child_process";
+var COPILOT_TIMEOUT_MS = 12e4;
+var CopilotReviewError = class extends Error {
+  code;
+  stdout;
+  stderr;
+  exitCode;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "CopilotReviewError";
+    this.code = code;
+    this.stdout = details?.stdout ?? "";
+    this.stderr = details?.stderr ?? "";
+    this.exitCode = details?.exitCode ?? 1;
+  }
+};
+var CopilotNotFoundError = class extends CopilotReviewError {
+  constructor() {
+    super("not_found", "copilot CLI not found. Install and authenticate GitHub Copilot CLI, then retry.");
+    this.name = "CopilotNotFoundError";
+  }
+};
+function runCopilotCommand(args, opts) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2("copilot", args, {
+      cwd: opts?.cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    const timeout = setTimeout(() => {
+      child.kill("SIGTERM");
+      reject(new Error(`copilot command timed out after ${String(opts?.timeoutMs ?? COPILOT_TIMEOUT_MS)}ms`));
+    }, opts?.timeoutMs ?? COPILOT_TIMEOUT_MS);
+    child.once("error", (error2) => {
+      clearTimeout(timeout);
+      reject(error2);
+    });
+    child.once("close", (code) => {
+      clearTimeout(timeout);
+      resolve({
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: code ?? 1
+      });
+    });
+  });
+}
+function normalizeSeverity(raw) {
+  const sev = typeof raw === "string" ? raw.toLowerCase() : "";
+  if (sev === "error" || sev === "high" || sev === "critical") {
+    return "critical";
+  }
+  if (sev === "warning" || sev === "medium") {
+    return "important";
+  }
+  if (sev === "info" || sev === "low") {
+    return "minor";
+  }
+  return "minor";
+}
+function maybeNumber(raw) {
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return Math.trunc(raw);
+  }
+  if (typeof raw === "string") {
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isNaN(n)) {
+      return n;
+    }
+  }
+  return void 0;
+}
+function collectParsedComments(value, comments) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectParsedComments(item, comments);
+    }
+    return;
+  }
+  if (!value || typeof value !== "object") {
+    return;
+  }
+  const record = value;
+  const message = [record.message, record.body, record.text].find((field) => typeof field === "string");
+  if (typeof message === "string" && message.trim()) {
+    comments.push({
+      message: message.trim(),
+      severity: record.severity ?? record.priority,
+      file: record.file ?? record.path,
+      line: record.line
+    });
+  }
+  for (const nested of Object.values(record)) {
+    collectParsedComments(nested, comments);
+  }
+}
+function parseReviewComments(stdout) {
+  const parsedObjects = [];
+  for (const line of stdout.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    try {
+      parsedObjects.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  const parsed = [];
+  for (const entry of parsedObjects) {
+    collectParsedComments(entry, parsed);
+  }
+  const deduped = /* @__PURE__ */ new Set();
+  const output2 = [];
+  for (const item of parsed) {
+    const file = typeof item.file === "string" && item.file.length > 0 ? item.file : void 0;
+    const line = maybeNumber(item.line);
+    const lineKey = line === void 0 ? "" : String(line);
+    const key = `${item.message}::${file ?? ""}::${lineKey}`;
+    if (deduped.has(key)) {
+      continue;
+    }
+    deduped.add(key);
+    output2.push({
+      severity: normalizeSeverity(item.severity),
+      file,
+      line,
+      comment: item.message
+    });
+  }
+  return output2;
+}
+async function checkCopilotAvailable() {
+  try {
+    const result = await runCopilotCommand(["--version"]);
+    if (result.exitCode !== 0) {
+      throw new CopilotNotFoundError();
+    }
+  } catch {
+    throw new CopilotNotFoundError();
+  }
+}
+async function runCopilotReview(spec, opts) {
+  const prompt = `Review the staged changes against the following spec.
+Report bugs, missing requirements, security issues, and logic errors.
+Ignore style issues.
+
+Spec:
+${spec}`;
+  let result;
+  try {
+    result = await runCopilotCommand(["-p", prompt, "--silent", "--output-format=json"], { cwd: opts?.cwd });
+  } catch (error2) {
+    throw new CopilotReviewError(
+      "review_failed",
+      `Failed to execute copilot review: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+  }
+  if (result.exitCode !== 0) {
+    throw new CopilotReviewError("review_failed", "Copilot review command failed.", result);
+  }
+  if (!result.stdout.trim()) {
+    throw new CopilotReviewError("review_failed", "Copilot review produced no output.", result);
+  }
+  try {
+    return parseReviewComments(result.stdout);
+  } catch (error2) {
+    throw new CopilotReviewError(
+      "parse_failed",
+      `Failed to parse Copilot review output: ${error2 instanceof Error ? error2.message : String(error2)}`,
+      result
+    );
+  }
+}
 
 // src/lib/git.ts
-import { execFile as execFileCb3 } from "child_process";
+import { execFile as execFileCb2 } from "child_process";
 var GIT_TIMEOUT_MS2 = 3e4;
 var GitError = class extends Error {
   command;
@@ -912,10 +1581,10 @@ var GitError = class extends Error {
 };
 async function exec2(args, cwd) {
   return new Promise((resolve, reject) => {
-    execFileCb3("git", args, { cwd, timeout: GIT_TIMEOUT_MS2, encoding: "utf8" }, (error, stdout, stderr) => {
-      if (error) {
-        const exitCode = typeof error.code === "number" ? error.code : -1;
-        reject(new GitError(args, exitCode, (stderr || error.message).trim()));
+    execFileCb2("git", args, { cwd, timeout: GIT_TIMEOUT_MS2, encoding: "utf8" }, (error2, stdout, stderr) => {
+      if (error2) {
+        const exitCode = typeof error2.code === "number" ? error2.code : -1;
+        reject(new GitError(args, exitCode, (stderr || error2.message).trim()));
         return;
       }
       resolve(stdout.trimEnd());
@@ -926,11 +1595,11 @@ async function branchExists(name, cwd) {
   try {
     await exec2(["rev-parse", "--verify", "--quiet", `refs/heads/${name}`], cwd);
     return true;
-  } catch (error) {
-    if (error instanceof GitError && error.exitCode === 1) {
+  } catch (error2) {
+    if (error2 instanceof GitError && error2.exitCode === 1) {
       return false;
     }
-    throw error;
+    throw error2;
   }
 }
 async function createBranch(name, cwd) {
@@ -942,7 +1611,7 @@ async function createBranch(name, cwd) {
 async function checkoutBranch(name, cwd) {
   await exec2(["checkout", name], cwd);
 }
-async function getDiff(cwd, base) {
+async function getDiff2(cwd, base) {
   if (base) {
     return exec2(["diff", `${base}..HEAD`], cwd);
   }
@@ -953,7 +1622,7 @@ function getBranchName(taskId, service) {
 }
 
 // src/lib/review-loop.ts
-function formatElapsed2(startedAt) {
+function formatElapsed(startedAt) {
   const seconds = Math.max(0, Math.round((Date.now() - startedAt) / 1e3));
   return `${String(seconds)}s`;
 }
@@ -975,12 +1644,12 @@ async function runReviewLoop(opts) {
   if (!serviceConfig) {
     throw new Error(`Unknown service in step: ${opts.step.service}`);
   }
-  const serviceRoot = path5.resolve(opts.projectRoot, serviceConfig.path);
+  const serviceRoot = path6.resolve(opts.projectRoot, serviceConfig.path);
   let iteration2 = opts.stepState.iteration;
   for (; ; ) {
     iteration(iteration2 + 1, opts.config.review.max_iterations);
     info(`Collecting git diff for service ${opts.step.service}`);
-    const diff = await getDiff(serviceRoot);
+    const diff = await getDiff2(serviceRoot);
     if (opts.verbose) {
       info(`Diff collected (${String(diff.length)} chars)`);
     }
@@ -999,23 +1668,20 @@ async function runReviewLoop(opts) {
     info(`Requesting reviewer analysis (model: ${opts.config.review.model})`);
     const reviewerStartedAt = Date.now();
     const reviewerHeartbeat = opts.verbose ? setInterval(() => {
-      info(`Waiting for reviewer response (${formatElapsed2(reviewerStartedAt)})`);
+      info(`Waiting for reviewer response (${formatElapsed(reviewerStartedAt)})`);
     }, 15e3) : null;
-    const review = await opts.claude.runReviewer({
-      spec: opts.step.spec,
-      diff,
-      model: opts.config.review.model
-    }).finally(() => {
+    const comments = await runCopilotReview(opts.step.spec, { cwd: serviceRoot }).finally(() => {
       if (reviewerHeartbeat) {
         clearInterval(reviewerHeartbeat);
       }
     });
-    info(`Reviewer response received in ${formatElapsed2(reviewerStartedAt)}`);
+    info(`Reviewer response received in ${formatElapsed(reviewerStartedAt)}`);
+    const review = { comments };
     reviewSummary(review.comments);
     info(`Requesting arbiter decision (model: ${opts.config.review.model})`);
     const arbiterStartedAt = Date.now();
     const arbiterHeartbeat = opts.verbose ? setInterval(() => {
-      info(`Waiting for arbiter response (${formatElapsed2(arbiterStartedAt)})`);
+      info(`Waiting for arbiter response (${formatElapsed(arbiterStartedAt)})`);
     }, 15e3) : null;
     const arbiter = await opts.claude.runArbiter({
       spec: opts.step.spec,
@@ -1027,7 +1693,7 @@ async function runReviewLoop(opts) {
         clearInterval(arbiterHeartbeat);
       }
     });
-    info(`Arbiter response received in ${formatElapsed2(arbiterStartedAt)}`);
+    info(`Arbiter response received in ${formatElapsed(arbiterStartedAt)}`);
     info(`Arbiter decision: ${arbiter.decision} (${arbiter.summary})`);
     saveIterationLog(opts.projectRoot, opts.taskId, opts.step.service, iteration2, {
       diff,
@@ -1089,7 +1755,7 @@ async function runReviewLoop(opts) {
 }
 
 // src/commands/fix.ts
-function fatalAndExit2(message) {
+function fatalAndExit3(message) {
   fatal(message);
   process.exit(1);
 }
@@ -1097,43 +1763,43 @@ async function runFix(feedback, options) {
   try {
     const projectRoot = findProjectRoot();
     if (!projectRoot) {
-      fatalAndExit2("Not inside a vexdo project.");
+      fatalAndExit3("Not inside a vexdo project.");
     }
     const config = loadConfig(projectRoot);
     const state = loadState(projectRoot);
     if (!state) {
-      fatalAndExit2("No active task.");
+      fatalAndExit3("No active task.");
     }
     if (!options.dryRun) {
       requireAnthropicApiKey();
       await checkCodexAvailable();
     }
-    const currentStep = state.steps.find((step3) => step3.status === "in_progress" || step3.status === "pending");
+    const currentStep = state.steps.find((step2) => step2.status === "in_progress" || step2.status === "pending");
     if (!currentStep) {
-      fatalAndExit2("No in-progress step found in active task.");
+      fatalAndExit3("No in-progress step found in active task.");
     }
     const task = loadAndValidateTask(state.taskPath, config);
-    const step2 = task.steps.find((item) => item.service === currentStep.service);
-    if (!step2) {
-      fatalAndExit2(`Could not locate task step for service '${currentStep.service}'.`);
+    const step = task.steps.find((item) => item.service === currentStep.service);
+    if (!step) {
+      fatalAndExit3(`Could not locate task step for service '${currentStep.service}'.`);
     }
     if (!options.dryRun) {
       const serviceConfig = config.services.find((service) => service.name === currentStep.service);
       if (!serviceConfig) {
-        fatalAndExit2(`Unknown service in step: ${currentStep.service}`);
+        fatalAndExit3(`Unknown service in step: ${currentStep.service}`);
       }
       await exec({
         spec: feedback,
         model: config.codex.model,
-        cwd: path6.resolve(projectRoot, serviceConfig.path),
+        cwd: path7.resolve(projectRoot, serviceConfig.path),
         verbose: options.verbose
       });
     }
-    info(`Running review loop for service ${step2.service}`);
+    info(`Running review loop for service ${step.service}`);
     const result = await runReviewLoop({
       taskId: task.id,
       task,
-      step: step2,
+      step,
       stepState: currentStep,
       projectRoot,
       config,
@@ -1156,8 +1822,8 @@ async function runFix(feedback, options) {
     if (!options.dryRun) {
       saveState(projectRoot, state);
     }
-  } catch (error) {
-    fatalAndExit2(error instanceof Error ? error.message : String(error));
+  } catch (error2) {
+    fatalAndExit3(error2 instanceof Error ? error2.message : String(error2));
   }
 }
 function registerFixCommand(program2) {
@@ -1168,8 +1834,8 @@ function registerFixCommand(program2) {
 }
 
 // src/commands/init.ts
-import fs5 from "fs";
-import path7 from "path";
+import fs6 from "fs";
+import path8 from "path";
 import { createInterface } from "readline/promises";
 import { stdin as input, stdout as output } from "process";
 import { stringify } from "yaml";
@@ -1198,24 +1864,24 @@ function parseMaxIterations(value) {
   return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_ITERATIONS2;
 }
 function ensureGitignoreEntry(gitignorePath, entry) {
-  if (!fs5.existsSync(gitignorePath)) {
-    fs5.writeFileSync(gitignorePath, `${entry}
+  if (!fs6.existsSync(gitignorePath)) {
+    fs6.writeFileSync(gitignorePath, `${entry}
 `, "utf8");
     return true;
   }
-  const content = fs5.readFileSync(gitignorePath, "utf8");
+  const content = fs6.readFileSync(gitignorePath, "utf8");
   const lines = content.split(/\r?\n/).map((line) => line.trim());
   if (lines.includes(entry)) {
     return false;
   }
   const suffix = content.endsWith("\n") || content.length === 0 ? "" : "\n";
-  fs5.appendFileSync(gitignorePath, `${suffix}${entry}
+  fs6.appendFileSync(gitignorePath, `${suffix}${entry}
 `, "utf8");
   return true;
 }
 async function runInit(projectRoot, prompt = defaultPrompt) {
-  const configPath = path7.join(projectRoot, ".vexdo.yml");
-  if (fs5.existsSync(configPath)) {
+  const configPath = path8.join(projectRoot, ".vexdo.yml");
+  if (fs6.existsSync(configPath)) {
     warn("Found existing .vexdo.yml.");
     const overwriteAnswer = await prompt("Overwrite existing .vexdo.yml? (y/N): ");
     if (!parseBoolean(overwriteAnswer)) {
@@ -1251,20 +1917,20 @@ async function runInit(projectRoot, prompt = defaultPrompt) {
       model: codexModelRaw.trim() || DEFAULT_CODEX_MODEL2
     }
   };
-  fs5.writeFileSync(configPath, stringify(config), "utf8");
+  fs6.writeFileSync(configPath, stringify(config), "utf8");
   const createdDirs = [];
   for (const taskDir of TASK_DIRS) {
-    const directory = path7.join(projectRoot, "tasks", taskDir);
-    fs5.mkdirSync(directory, { recursive: true });
-    createdDirs.push(path7.relative(projectRoot, directory));
-  }
-  const logDir = path7.join(projectRoot, ".vexdo", "logs");
-  fs5.mkdirSync(logDir, { recursive: true });
-  createdDirs.push(path7.relative(projectRoot, logDir));
-  const gitignorePath = path7.join(projectRoot, ".gitignore");
+    const directory = path8.join(projectRoot, "tasks", taskDir);
+    fs6.mkdirSync(directory, { recursive: true });
+    createdDirs.push(path8.relative(projectRoot, directory));
+  }
+  const logDir = path8.join(projectRoot, ".vexdo", "logs");
+  fs6.mkdirSync(logDir, { recursive: true });
+  createdDirs.push(path8.relative(projectRoot, logDir));
+  const gitignorePath = path8.join(projectRoot, ".gitignore");
   const gitignoreUpdated = ensureGitignoreEntry(gitignorePath, ".vexdo/");
   success("Initialized vexdo project.");
-  info(`Created: ${path7.relative(projectRoot, configPath)}`);
+  info(`Created: ${path8.relative(projectRoot, configPath)}`);
   info(`Created directories: ${createdDirs.join(", ")}`);
   if (gitignoreUpdated) {
     info("Updated .gitignore with .vexdo/");
@@ -1278,46 +1944,46 @@ function registerInitCommand(program2) {
 }
 
 // src/commands/logs.ts
-import fs6 from "fs";
-import path8 from "path";
-function fatalAndExit3(message) {
+import fs7 from "fs";
+import path9 from "path";
+function fatalAndExit4(message) {
   fatal(message);
   process.exit(1);
 }
 function runLogs(taskIdArg, options) {
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
-    fatalAndExit3("Not inside a vexdo project.");
+    fatalAndExit4("Not inside a vexdo project.");
   }
   const state = loadState(projectRoot);
   const taskId = taskIdArg ?? state?.taskId;
   if (!taskId) {
-    const base = path8.join(getStateDir(projectRoot), "logs");
-    if (!fs6.existsSync(base)) {
+    const base = path9.join(getStateDir(projectRoot), "logs");
+    if (!fs7.existsSync(base)) {
       info("No logs available.");
       return;
     }
-    const tasks = fs6.readdirSync(base, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+    const tasks = fs7.readdirSync(base, { withFileTypes: true }).filter((entry) => entry.isDirectory());
     for (const dir of tasks) {
       info(dir.name);
     }
     return;
   }
   const logsDir = getLogsDir(projectRoot, taskId);
-  if (!fs6.existsSync(logsDir)) {
-    fatalAndExit3(`No logs found for task '${taskId}'.`);
+  if (!fs7.existsSync(logsDir)) {
+    fatalAndExit4(`No logs found for task '${taskId}'.`);
   }
-  const files = fs6.readdirSync(logsDir).filter((name) => name.endsWith("-arbiter.json"));
+  const files = fs7.readdirSync(logsDir).filter((name) => name.endsWith("-arbiter.json"));
   for (const arbiterFile of files) {
     const base = arbiterFile.replace(/-arbiter\.json$/, "");
-    const arbiterPath = path8.join(logsDir, `${base}-arbiter.json`);
-    const reviewPath = path8.join(logsDir, `${base}-review.json`);
-    const diffPath = path8.join(logsDir, `${base}-diff.txt`);
-    const arbiter = JSON.parse(fs6.readFileSync(arbiterPath, "utf8"));
-    const review = JSON.parse(fs6.readFileSync(reviewPath, "utf8"));
+    const arbiterPath = path9.join(logsDir, `${base}-arbiter.json`);
+    const reviewPath = path9.join(logsDir, `${base}-review.json`);
+    const diffPath = path9.join(logsDir, `${base}-diff.txt`);
+    const arbiter = JSON.parse(fs7.readFileSync(arbiterPath, "utf8"));
+    const review = JSON.parse(fs7.readFileSync(reviewPath, "utf8"));
     info(`${base}: decision=${arbiter.decision}, comments=${String(review.comments?.length ?? 0)}, summary=${arbiter.summary}`);
     if (options?.full) {
-      console.log(fs6.readFileSync(diffPath, "utf8"));
+      console.log(fs7.readFileSync(diffPath, "utf8"));
       console.log(JSON.stringify(review, null, 2));
       console.log(JSON.stringify(arbiter, null, 2));
     }
@@ -1330,8 +1996,8 @@ function registerLogsCommand(program2) {
 }
 
 // src/commands/review.ts
-import fs7 from "fs";
-function fatalAndExit4(message) {
+import fs8 from "fs";
+function fatalAndExit5(message) {
   fatal(message);
   process.exit(1);
 }
@@ -1339,33 +2005,33 @@ async function runReview(options) {
   try {
     const projectRoot = findProjectRoot();
     if (!projectRoot) {
-      fatalAndExit4("Not inside a vexdo project.");
+      fatalAndExit5("Not inside a vexdo project.");
     }
     const config = loadConfig(projectRoot);
     const state = loadState(projectRoot);
     if (!state) {
-      fatalAndExit4("No active task.");
+      fatalAndExit5("No active task.");
     }
     if (!options.dryRun) {
       requireAnthropicApiKey();
     }
-    const currentStep = state.steps.find((step3) => step3.status === "in_progress" || step3.status === "pending");
+    const currentStep = state.steps.find((step2) => step2.status === "in_progress" || step2.status === "pending");
     if (!currentStep) {
-      fatalAndExit4("No in-progress step found in active task.");
+      fatalAndExit5("No in-progress step found in active task.");
     }
-    if (!fs7.existsSync(state.taskPath)) {
-      fatalAndExit4(`Task file not found: ${state.taskPath}`);
+    if (!fs8.existsSync(state.taskPath)) {
+      fatalAndExit5(`Task file not found: ${state.taskPath}`);
     }
     const task = loadAndValidateTask(state.taskPath, config);
-    const step2 = task.steps.find((item) => item.service === currentStep.service);
-    if (!step2) {
-      fatalAndExit4(`Could not locate task step for service '${currentStep.service}'.`);
+    const step = task.steps.find((item) => item.service === currentStep.service);
+    if (!step) {
+      fatalAndExit5(`Could not locate task step for service '${currentStep.service}'.`);
     }
-    info(`Running review loop for service ${step2.service}`);
+    info(`Running review loop for service ${step.service}`);
     const result = await runReviewLoop({
       taskId: task.id,
       task,
-      step: step2,
+      step,
       stepState: currentStep,
       projectRoot,
       config,
@@ -1376,9 +2042,9 @@ async function runReview(options) {
     if (result.decision === "escalate") {
       escalation({
         taskId: task.id,
-        service: step2.service,
+        service: step.service,
         iteration: result.finalIteration,
-        spec: step2.spec,
+        spec: step.spec,
         diff: "",
         reviewComments: result.lastReviewComments,
         arbiterReasoning: result.lastArbiterResult.reasoning,
@@ -1398,9 +2064,9 @@ async function runReview(options) {
     if (!options.dryRun) {
       saveState(projectRoot, state);
     }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    fatalAndExit4(message);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    fatalAndExit5(message);
   }
 }
 function registerReviewCommand(program2) {
@@ -1411,25 +2077,103 @@ function registerReviewCommand(program2) {
 }
 
 // src/commands/start.ts
-import path10 from "path";
+import path11 from "path";
+
+// src/lib/runner.ts
+async function runStepsConcurrently(steps, config, runStep) {
+  const maxConcurrent = config.maxConcurrent ?? Number.POSITIVE_INFINITY;
+  if (!Number.isFinite(maxConcurrent) && maxConcurrent !== Number.POSITIVE_INFINITY) {
+    throw new Error("maxConcurrent must be a finite number when specified");
+  }
+  if (Number.isFinite(maxConcurrent) && (!Number.isInteger(maxConcurrent) || maxConcurrent <= 0)) {
+    throw new Error("maxConcurrent must be a positive integer when specified");
+  }
+  const stepByService = new Map(steps.map((step) => [step.service, step]));
+  for (const step of steps) {
+    for (const dependency of step.depends_on ?? []) {
+      if (!stepByService.has(dependency)) {
+        throw new Error(`Unknown dependency '${dependency}' for service '${step.service}'`);
+      }
+    }
+  }
+  const results = /* @__PURE__ */ new Map();
+  const running = /* @__PURE__ */ new Map();
+  while (results.size < steps.length) {
+    let dispatched = false;
+    for (const step of steps) {
+      if (results.has(step.service) || running.has(step.service)) {
+        continue;
+      }
+      const dependencies = step.depends_on ?? [];
+      const depResults = dependencies.map((service) => results.get(service));
+      if (depResults.some((result) => result === void 0)) {
+        continue;
+      }
+      const blockedByDependencyFailure = depResults.some((result) => result?.status !== "done");
+      if (blockedByDependencyFailure) {
+        results.set(step.service, {
+          service: step.service,
+          status: "failed",
+          error: "dependency_failed"
+        });
+        dispatched = true;
+        continue;
+      }
+      if (running.size >= maxConcurrent) {
+        continue;
+      }
+      dispatched = true;
+      const runningPromise = runStep(step).then((result) => {
+        results.set(step.service, result);
+      }).catch((error2) => {
+        const message = error2 instanceof Error ? error2.message : String(error2);
+        results.set(step.service, {
+          service: step.service,
+          status: "failed",
+          error: message
+        });
+      }).finally(() => {
+        running.delete(step.service);
+      });
+      running.set(step.service, runningPromise);
+    }
+    if (!dispatched) {
+      if (running.size === 0) {
+        throw new Error("Unable to schedule all steps; dependency graph may contain a cycle.");
+      }
+      await Promise.race(running.values());
+    }
+  }
+  return steps.map((step) => {
+    const result = results.get(step.service);
+    if (!result) {
+      return {
+        service: step.service,
+        status: "failed",
+        error: "not_executed"
+      };
+    }
+    return result;
+  });
+}
 
 // src/lib/submit-task.ts
-import fs8 from "fs";
-import path9 from "path";
+import fs9 from "fs";
+import path10 from "path";
 async function submitActiveTask(projectRoot, config, state) {
-  for (const step2 of state.steps) {
-    if (step2.status !== "done" && step2.status !== "in_progress") {
+  for (const step of state.steps) {
+    if (step.status !== "done" && step.status !== "in_progress") {
       continue;
     }
-    const service = config.services.find((item) => item.name === step2.service);
+    const service = config.services.find((item) => item.name === step.service);
     if (!service) {
-      throw new Error(`Unknown service in state: ${step2.service}`);
+      throw new Error(`Unknown service in state: ${step.service}`);
     }
-    const servicePath = path9.resolve(projectRoot, service.path);
+    const servicePath = path10.resolve(projectRoot, service.path);
     const body = `Task: ${state.taskId}
-Service: ${step2.service}`;
+Service: ${step.service}`;
     const url = await createPr({
-      title: `${state.taskTitle} [${step2.service}]`,
+      title: `${state.taskTitle} [${step.service}]`,
       body,
       base: "main",
       cwd: servicePath
@@ -1439,7 +2183,7 @@ Service: ${step2.service}`;
   state.status = "done";
   saveState(projectRoot, state);
   const doneDir = ensureTaskDirectory(projectRoot, "done");
-  if (fs8.existsSync(state.taskPath)) {
+  if (fs9.existsSync(state.taskPath)) {
     state.taskPath = moveTaskFileAtomically(state.taskPath, doneDir);
     saveState(projectRoot, state);
   }
@@ -1447,7 +2191,9 @@ Service: ${step2.service}`;
 }
 
 // src/commands/start.ts
-function fatalAndExit5(message, hint) {
+var POLL_INTERVAL_MS = 5e3;
+var POLL_TIMEOUT_MS = 10 * 6e4;
+function fatalAndExit6(message, hint) {
   fatal(message, hint);
   process.exit(1);
 }
@@ -1455,17 +2201,18 @@ async function runStart(taskFile, options) {
   try {
     const projectRoot = findProjectRoot();
     if (!projectRoot) {
-      fatalAndExit5("Not inside a vexdo project. Could not find .vexdo.yml.");
+      fatalAndExit6("Not inside a vexdo project. Could not find .vexdo.yml.");
     }
     const config = loadConfig(projectRoot);
-    const taskPath = path10.resolve(taskFile);
+    const taskPath = path11.resolve(taskFile);
     const task = loadAndValidateTask(taskPath, config);
     if (hasActiveTask(projectRoot) && !options.resume) {
-      fatalAndExit5("An active task already exists.", "Use --resume to continue or 'vexdo abort' to cancel.");
+      fatalAndExit6("An active task already exists.", "Use --resume to continue or 'vexdo abort' to cancel.");
     }
     if (!options.dryRun) {
       requireAnthropicApiKey();
       await checkCodexAvailable();
+      await checkCopilotAvailable();
     }
     let state = loadState(projectRoot);
     if (!options.resume) {
@@ -1480,94 +2227,123 @@ async function runStart(taskFile, options) {
       }
     }
     if (!state) {
-      fatalAndExit5("No resumable task state found.");
+      fatalAndExit6("No resumable task state found.");
     }
     const claude = new ClaudeClient(process.env.ANTHROPIC_API_KEY ?? "");
-    const total = task.steps.length;
-    for (let i = 0; i < task.steps.length; i += 1) {
-      const step2 = task.steps[i];
-      const stepState = state.steps[i];
-      if (!step2 || !stepState) {
-        continue;
-      }
-      if (stepState.status === "done") {
-        continue;
-      }
-      if (step2.depends_on && step2.depends_on.length > 0) {
-        for (const depService of step2.depends_on) {
-          const depState = state.steps.find((item) => item.service === depService);
-          if (depState?.status !== "done") {
-            fatalAndExit5(`Step dependency '${depService}' for service '${step2.service}' is not done.`);
+    const stepResults = await runStepsConcurrently(
+      task.steps,
+      { maxConcurrent: config.maxConcurrent },
+      async (step) => {
+        const scopedLogger = withPrefix(`[${step.service}]`);
+        const latestState = options.dryRun ? state : loadState(projectRoot);
+        const stepState = latestState?.steps.find((item) => item.service === step.service);
+        if (!stepState) {
+          return { service: step.service, status: "failed", error: "step_state_missing" };
+        }
+        if (stepState.status === "done") {
+          return { service: step.service, status: "done", sessionId: stepState.session_id };
+        }
+        const serviceCfg = config.services.find((service) => service.name === step.service);
+        if (!serviceCfg) {
+          return { service: step.service, status: "failed", error: `Unknown service in step: ${step.service}` };
+        }
+        const serviceRoot = path11.resolve(projectRoot, serviceCfg.path);
+        const branch = stepState.branch ?? getBranchName(task.id, step.service);
+        try {
+          if (!options.dryRun) {
+            if (options.resume) {
+              if (stepState.branch) {
+                await checkoutBranch(stepState.branch, serviceRoot);
+              } else {
+                await createBranch(branch, serviceRoot);
+              }
+            } else {
+              await createBranch(branch, serviceRoot);
+            }
+            await updateStep(projectRoot, task.id, step.service, {
+              status: "in_progress",
+              branch
+            });
+          }
+          if (options.dryRun) {
+            scopedLogger.info(`[dry-run] Would run codex cloud implementation for service ${step.service}`);
+            return { service: step.service, status: "done" };
+          }
+          scopedLogger.info("Submitting to Codex Cloud...");
+          const submissionSession = stepState.session_id ?? await submitTask(step.spec, { cwd: serviceRoot });
+          await updateStep(projectRoot, task.id, step.service, { session_id: submissionSession });
+          const execution = await runCloudReviewLoop({
+            taskId: task.id,
+            service: step.service,
+            spec: step.spec,
+            sessionId: submissionSession,
+            stepState: {
+              iteration: stepState.iteration,
+              session_id: submissionSession
+            },
+            projectRoot,
+            config,
+            claude,
+            verbose: options.verbose,
+            log: scopedLogger,
+            serviceRoot
+          });
+          await updateStep(projectRoot, task.id, step.service, {
+            lastReviewComments: execution.lastReviewComments,
+            lastArbiterResult: execution.lastArbiterResult,
+            iteration: execution.finalIteration,
+            session_id: execution.sessionId
+          });
+          if (execution.lastArbiterResult.decision === "escalate") {
+            escalation({
+              taskId: task.id,
+              service: step.service,
+              iteration: execution.finalIteration,
+              spec: step.spec,
+              diff: "",
+              reviewComments: execution.lastReviewComments,
+              arbiterReasoning: execution.lastArbiterResult.reasoning,
+              summary: execution.lastArbiterResult.summary
+            });
+            await updateStep(projectRoot, task.id, step.service, { status: "escalated" });
+            return { service: step.service, status: "escalated", sessionId: execution.sessionId };
           }
+          await updateStep(projectRoot, task.id, step.service, { status: "done" });
+          scopedLogger.success("Review passed \u2014 ready for PR");
+          return { service: step.service, status: "done", sessionId: execution.sessionId };
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : String(error2);
+          if (!options.dryRun) {
+            await updateStep(projectRoot, task.id, step.service, { status: "failed" });
+          }
+          scopedLogger.error(message);
+          if (error2 instanceof CodexError) {
+            if (error2.stderr) scopedLogger.error(`stderr: ${error2.stderr}`);
+            if (error2.stdout) scopedLogger.debug(`stdout: ${error2.stdout}`);
+          }
+          return { service: step.service, status: "failed", error: message };
         }
       }
-      step(i + 1, total, `${step2.service}: ${task.title}`);
-      const serviceCfg = config.services.find((service) => service.name === step2.service);
-      if (!serviceCfg) {
-        fatalAndExit5(`Unknown service in step: ${step2.service}`);
-      }
-      const serviceRoot = path10.resolve(projectRoot, serviceCfg.path);
-      const branch = getBranchName(task.id, step2.service);
-      if (!options.dryRun) {
-        if (options.resume) {
-          await checkoutBranch(stepState.branch ?? branch, serviceRoot);
-        } else {
-          await createBranch(branch, serviceRoot);
+    );
+    if (!options.dryRun) {
+      for (const result of stepResults) {
+        if (result.status === "failed" && result.error === "dependency_failed") {
+          await updateStep(projectRoot, task.id, result.service, { status: "failed" });
         }
       }
-      stepState.status = "in_progress";
-      stepState.branch = branch;
+    }
+    const hasEscalation = stepResults.some((result) => result.status === "escalated");
+    const hasFailure = stepResults.some((result) => result.status === "failed");
+    state = loadState(projectRoot) ?? state;
+    if (hasEscalation || hasFailure) {
+      state.status = hasEscalation ? "escalated" : "blocked";
       if (!options.dryRun) {
         saveState(projectRoot, state);
-      }
-      if (!options.resume && !options.dryRun) {
-        info(`Running codex implementation for service ${step2.service}`);
-        await exec({
-          spec: step2.spec,
-          model: config.codex.model,
-          cwd: serviceRoot,
-          verbose: options.verbose
-        });
-      } else if (options.dryRun) {
-        info(`[dry-run] Would run codex for service ${step2.service}`);
-      }
-      info(`Starting review loop for service ${step2.service}`);
-      const result = await runReviewLoop({
-        taskId: task.id,
-        task,
-        step: step2,
-        stepState,
-        projectRoot,
-        config,
-        claude,
-        dryRun: options.dryRun,
-        verbose: options.verbose
-      });
-      if (result.decision === "escalate") {
-        escalation({
-          taskId: task.id,
-          service: step2.service,
-          iteration: result.finalIteration,
-          spec: step2.spec,
-          diff: "",
-          reviewComments: result.lastReviewComments,
-          arbiterReasoning: result.lastArbiterResult.reasoning,
-          summary: result.lastArbiterResult.summary
-        });
-        stepState.status = "escalated";
-        state.status = "escalated";
-        if (!options.dryRun) {
-          saveState(projectRoot, state);
-          const blockedDir = ensureTaskDirectory(projectRoot, "blocked");
-          state.taskPath = moveTaskFileAtomically(state.taskPath, blockedDir);
-          saveState(projectRoot, state);
-        }
-        process.exit(1);
-      }
-      stepState.status = "done";
-      if (!options.dryRun) {
+        const blockedDir = ensureTaskDirectory(projectRoot, "blocked");
+        state.taskPath = moveTaskFileAtomically(state.taskPath, blockedDir);
         saveState(projectRoot, state);
       }
+      process.exit(1);
     }
     state.status = "review";
     if (!options.dryRun) {
@@ -1580,9 +2356,94 @@ async function runStart(taskFile, options) {
       return;
     }
     success("Task ready for PR. Run 'vexdo submit' to create PR.");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    fatalAndExit5(message);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    fatalAndExit6(message);
+  }
+}
+async function runCloudReviewLoop(opts) {
+  let sessionId = opts.sessionId;
+  let iteration2 = opts.stepState.iteration;
+  for (; ; ) {
+    opts.log.iteration(iteration2 + 1, opts.config.review.max_iterations);
+    opts.log.info(`Polling codex cloud session ${sessionId}`);
+    const status = await pollStatus(sessionId, {
+      intervalMs: POLL_INTERVAL_MS,
+      timeoutMs: POLL_TIMEOUT_MS
+    });
+    if (status !== "completed") {
+      return {
+        sessionId,
+        finalIteration: iteration2,
+        lastReviewComments: [],
+        lastArbiterResult: {
+          decision: "escalate",
+          reasoning: `Codex Cloud session ended with status '${status}'.`,
+          summary: "Escalated due to codex cloud execution failure."
+        }
+      };
+    }
+    opts.log.success("Codex task completed");
+    opts.log.info(`Retrieving diff for session ${sessionId}`);
+    const diff = await getDiff(sessionId);
+    opts.log.info(`Running review (iteration ${String(iteration2 + 1)})...`);
+    await applyDiff(sessionId);
+    const comments = await runCopilotReview(opts.spec, { cwd: opts.serviceRoot }).finally(async () => {
+      await exec2(["checkout", "."], opts.serviceRoot);
+    });
+    const review = { comments };
+    opts.log.reviewSummary(review.comments);
+    opts.log.info(`Requesting arbiter decision (model: ${opts.config.review.model})`);
+    const arbiter = await opts.claude.runArbiter({
+      spec: opts.spec,
+      diff,
+      reviewComments: review.comments,
+      model: opts.config.review.model
+    });
+    saveIterationLog(opts.projectRoot, opts.taskId, opts.service, iteration2, {
+      diff,
+      review,
+      arbiter
+    });
+    opts.stepState.iteration = iteration2;
+    opts.stepState.session_id = sessionId;
+    if (arbiter.decision === "submit" || arbiter.decision === "escalate") {
+      return {
+        sessionId,
+        finalIteration: iteration2,
+        lastReviewComments: review.comments,
+        lastArbiterResult: arbiter
+      };
+    }
+    if (iteration2 >= opts.config.review.max_iterations) {
+      return {
+        sessionId,
+        finalIteration: iteration2,
+        lastReviewComments: review.comments,
+        lastArbiterResult: {
+          decision: "escalate",
+          reasoning: "Max review iterations reached while arbiter still requested fixes.",
+          summary: "Escalated because maximum iterations were exhausted."
+        }
+      };
+    }
+    if (!arbiter.feedback_for_codex) {
+      return {
+        sessionId,
+        finalIteration: iteration2,
+        lastReviewComments: review.comments,
+        lastArbiterResult: {
+          decision: "escalate",
+          reasoning: "Arbiter returned fix decision without feedback_for_codex.",
+          summary: "Escalated because fix instructions were missing."
+        }
+      };
+    }
+    opts.log.warn(`Review requested fixes (iteration ${String(iteration2 + 1)}/${String(opts.config.review.max_iterations)})`);
+    sessionId = await resumeTask(sessionId, arbiter.feedback_for_codex);
+    opts.stepState.session_id = sessionId;
+    iteration2 += 1;
+    opts.stepState.iteration = iteration2;
   }
 }
 function registerStartCommand(program2) {
@@ -1593,11 +2454,11 @@ function registerStartCommand(program2) {
 }
 
 // src/commands/status.ts
-function fatalAndExit6(message) {
+function fatalAndExit7(message) {
   fatal(message);
   process.exit(1);
 }
-function formatElapsed3(startedAt) {
+function formatElapsed2(startedAt) {
   const elapsedMs = Date.now() - new Date(startedAt).getTime();
   const minutes = Math.floor(elapsedMs / 1e3 / 60);
   const hours = Math.floor(minutes / 60);
@@ -1609,23 +2470,23 @@ function formatElapsed3(startedAt) {
 function runStatus() {
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
-    fatalAndExit6("Not inside a vexdo project.");
+    fatalAndExit7("Not inside a vexdo project.");
   }
   const state = loadState(projectRoot);
   if (!state) {
-    fatalAndExit6("No active task.");
+    fatalAndExit7("No active task.");
   }
   info(`Task: ${state.taskId} \u2014 ${state.taskTitle}`);
   info(`Status: ${state.status}`);
   console.log("service | status | iteration | branch");
-  for (const step2 of state.steps) {
-    console.log(`${step2.service} | ${step2.status} | ${String(step2.iteration)} | ${step2.branch ?? "-"}`);
+  for (const step of state.steps) {
+    console.log(`${step.service} | ${step.status} | ${String(step.iteration)} | ${step.branch ?? "-"}`);
   }
-  const inProgress = state.steps.find((step2) => step2.status === "in_progress");
+  const inProgress = state.steps.find((step) => step.status === "in_progress");
   if (inProgress?.lastArbiterResult?.summary) {
     info(`Last arbiter summary: ${inProgress.lastArbiterResult.summary}`);
   }
-  info(`Elapsed: ${formatElapsed3(state.startedAt)}`);
+  info(`Elapsed: ${formatElapsed2(state.startedAt)}`);
 }
 function registerStatusCommand(program2) {
   program2.command("status").description("Print active task status").action(() => {
@@ -1634,7 +2495,7 @@ function registerStatusCommand(program2) {
 }
 
 // src/commands/submit.ts
-function fatalAndExit7(message) {
+function fatalAndExit8(message) {
   fatal(message);
   process.exit(1);
 }
@@ -1642,17 +2503,17 @@ async function runSubmit() {
   try {
     const projectRoot = findProjectRoot();
     if (!projectRoot) {
-      fatalAndExit7("Not inside a vexdo project.");
+      fatalAndExit8("Not inside a vexdo project.");
     }
     const config = loadConfig(projectRoot);
     const state = loadState(projectRoot);
     if (!state) {
-      fatalAndExit7("No active task.");
+      fatalAndExit8("No active task.");
     }
     await requireGhAvailable();
     await submitActiveTask(projectRoot, config, state);
-  } catch (error) {
-    fatalAndExit7(error instanceof Error ? error.message : String(error));
+  } catch (error2) {
+    fatalAndExit8(error2 instanceof Error ? error2.message : String(error2));
   }
 }
 function registerSubmitCommand(program2) {
@@ -1662,8 +2523,8 @@ function registerSubmitCommand(program2) {
 }
 
 // src/index.ts
-var packageJsonPath = path11.resolve(path11.dirname(new URL(import.meta.url).pathname), "..", "package.json");
-var packageJson = JSON.parse(fs9.readFileSync(packageJsonPath, "utf8"));
+var packageJsonPath = path12.resolve(path12.dirname(new URL(import.meta.url).pathname), "..", "package.json");
+var packageJson = JSON.parse(fs10.readFileSync(packageJsonPath, "utf8"));
 var program = new Command();
 program.name("vexdo").description("Vexdo CLI").version(packageJson.version).option("--verbose", "Enable verbose logs").option("--dry-run", "Print plan without making changes");
 program.hook("preAction", (_thisCommand, actionCommand) => {
@@ -1678,4 +2539,5 @@ registerSubmitCommand(program);
 registerStatusCommand(program);
 registerAbortCommand(program);
 registerLogsCommand(program);
+registerBoardCommand(program);
 program.parse(process.argv);