@vexdo/cli 0.1.0 → 0.1.2

package/dist/index.js

@@ -0,0 +1,1597 @@
+// src/index.ts
+import fs9 from "fs";
+import path11 from "path";
+import { Command } from "commander";
+
+// src/commands/abort.ts
+import fs4 from "fs";
+import path4 from "path";
+import readline from "readline/promises";
+
+// src/lib/config.ts
+import fs from "fs";
+import path from "path";
+import { parse } from "yaml";
+var DEFAULT_REVIEW_MODEL = "claude-haiku-4-5-20251001";
+var DEFAULT_MAX_ITERATIONS = 3;
+var DEFAULT_AUTO_SUBMIT = false;
+var DEFAULT_CODEX_MODEL = "gpt-4o";
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readObjectField(obj, fieldPath) {
+  return obj[fieldPath];
+}
+function requireString(value, fieldPath) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${fieldPath} must be a non-empty string`);
+  }
+  return value;
+}
+function parseServices(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error("services must be a non-empty array");
+  }
+  return value.map((service, index) => {
+    if (!isRecord(service)) {
+      throw new Error(`services[${String(index)}] must be an object`);
+    }
+    const name = requireString(readObjectField(service, "name"), `services[${String(index)}].name`);
+    const servicePath = requireString(readObjectField(service, "path"), `services[${String(index)}].path`);
+    return {
+      name,
+      path: servicePath
+    };
+  });
+}
+function parseReview(value) {
+  if (value === void 0) {
+    return {
+      model: DEFAULT_REVIEW_MODEL,
+      max_iterations: DEFAULT_MAX_ITERATIONS,
+      auto_submit: DEFAULT_AUTO_SUBMIT
+    };
+  }
+  if (!isRecord(value)) {
+    throw new Error("review must be an object");
+  }
+  const modelRaw = readObjectField(value, "model");
+  const iterationsRaw = readObjectField(value, "max_iterations");
+  const autoSubmitRaw = readObjectField(value, "auto_submit");
+  const model = modelRaw === void 0 ? DEFAULT_REVIEW_MODEL : requireString(modelRaw, "review.model");
+  let max_iterations = DEFAULT_MAX_ITERATIONS;
+  if (iterationsRaw !== void 0) {
+    if (typeof iterationsRaw !== "number" || !Number.isInteger(iterationsRaw) || iterationsRaw <= 0) {
+      throw new Error("review.max_iterations must be a positive integer");
+    }
+    max_iterations = iterationsRaw;
+  }
+  let auto_submit = DEFAULT_AUTO_SUBMIT;
+  if (autoSubmitRaw !== void 0) {
+    if (typeof autoSubmitRaw !== "boolean") {
+      throw new Error("review.auto_submit must be a boolean");
+    }
+    auto_submit = autoSubmitRaw;
+  }
+  return {
+    model,
+    max_iterations,
+    auto_submit
+  };
+}
+function parseCodex(value) {
+  if (value === void 0) {
+    return { model: DEFAULT_CODEX_MODEL };
+  }
+  if (!isRecord(value)) {
+    throw new Error("codex must be an object");
+  }
+  const modelRaw = readObjectField(value, "model");
+  const model = modelRaw === void 0 ? DEFAULT_CODEX_MODEL : requireString(modelRaw, "codex.model");
+  return { model };
+}
+function findProjectRoot(startDir = process.cwd()) {
+  let current = path.resolve(startDir);
+  let reachedRoot = false;
+  while (!reachedRoot) {
+    const candidate = path.join(current, ".vexdo.yml");
+    if (fs.existsSync(candidate)) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    reachedRoot = parent === current;
+    current = parent;
+  }
+  return null;
+}
+function loadConfig(projectRoot) {
+  const configPath = path.join(projectRoot, ".vexdo.yml");
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}`);
+  }
+  const configRaw = fs.readFileSync(configPath, "utf8");
+  let parsed;
+  try {
+    parsed = parse(configRaw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid YAML in .vexdo.yml: ${message}`);
+  }
+  if (!isRecord(parsed)) {
+    throw new Error("config must be an object");
+  }
+  const versionRaw = readObjectField(parsed, "version");
+  if (versionRaw !== 1) {
+    throw new Error("version must be 1");
+  }
+  const services = parseServices(readObjectField(parsed, "services"));
+  const review = parseReview(readObjectField(parsed, "review"));
+  const codex = parseCodex(readObjectField(parsed, "codex"));
+  return {
+    version: 1,
+    services,
+    review,
+    codex
+  };
+}
+
+// src/lib/logger.ts
+import ora from "ora";
+import pc from "picocolors";
+var verboseEnabled = false;
+function safeLog(method, message) {
+  try {
+    if (method === "error") {
+      console.error(message);
+    } else {
+      console.log(message);
+    }
+  } catch {
+  }
+}
+function setVerbose(enabled) {
+  verboseEnabled = enabled;
+}
+function info(message) {
+  safeLog("log", `${pc.cyan("\u2192")} ${message}`);
+}
+function success(message) {
+  safeLog("log", `${pc.green("\u2713")} ${message}`);
+}
+function warn(message) {
+  safeLog("log", `${pc.yellow("\u26A0")} ${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)}`));
+}
+function fatal(message, hint) {
+  safeLog("error", `${pc.bold(pc.red("Error:"))} ${message}`);
+  if (hint) {
+    safeLog("error", `${pc.gray("Hint:")} ${hint}`);
+  }
+}
+function escalation(context) {
+  const lines = [
+    pc.bold(pc.red("Escalation triggered")),
+    `${pc.gray("Task:")} ${context.taskId}`,
+    `${pc.gray("Service:")} ${context.service}`,
+    `${pc.gray("Iteration:")} ${String(context.iteration)}`,
+    `${pc.gray("Summary:")} ${context.summary}`,
+    "",
+    pc.bold("Spec:"),
+    context.spec,
+    "",
+    pc.bold("Arbiter reasoning:"),
+    context.arbiterReasoning,
+    "",
+    pc.bold("Review comments:")
+  ];
+  for (const comment of context.reviewComments) {
+    const sevColor = comment.severity === "critical" ? pc.red : comment.severity === "important" ? pc.yellow : comment.severity === "minor" ? pc.cyan : pc.gray;
+    const location = comment.file ? ` (${comment.file}${comment.line ? `:${String(comment.line)}` : ""})` : "";
+    lines.push(`- ${sevColor(comment.severity.toUpperCase())}${location}: ${comment.comment}`);
+    if (comment.suggestion) {
+      lines.push(`  ${pc.gray(`Suggestion: ${comment.suggestion}`)}`);
+    }
+  }
+  lines.push("", pc.bold("Diff:"), context.diff, "", pc.gray("Hint: run `vexdo abort` to clear state."));
+  safeLog("error", lines.join("\n"));
+}
+function reviewSummary(comments) {
+  const counts = {
+    critical: 0,
+    important: 0,
+    minor: 0,
+    noise: 0
+  };
+  for (const comment of comments) {
+    counts[comment.severity] += 1;
+  }
+  safeLog(
+    "log",
+    `${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", `- ${comment.severity}${location}: ${comment.comment}`);
+  }
+}
+
+// src/lib/state.ts
+import fs2 from "fs";
+import path2 from "path";
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function getStateDir(projectRoot) {
+  return path2.join(projectRoot, ".vexdo");
+}
+function getStatePath(projectRoot) {
+  return path2.join(getStateDir(projectRoot), "state.json");
+}
+function getLogsDir(projectRoot, taskId) {
+  return path2.join(getStateDir(projectRoot), "logs", taskId);
+}
+function ensureLogsDir(projectRoot, taskId) {
+  const logsDir = getLogsDir(projectRoot, taskId);
+  fs2.mkdirSync(logsDir, { recursive: true });
+  return logsDir;
+}
+function loadState(projectRoot) {
+  const statePath = getStatePath(projectRoot);
+  if (!fs2.existsSync(statePath)) {
+    return null;
+  }
+  const raw = fs2.readFileSync(statePath, "utf8");
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Corrupt state file at ${statePath}: ${message}`);
+  }
+}
+function saveState(projectRoot, state) {
+  const stateDir = getStateDir(projectRoot);
+  fs2.mkdirSync(stateDir, { recursive: true });
+  const nextState = {
+    ...state,
+    updatedAt: nowIso()
+  };
+  fs2.writeFileSync(getStatePath(projectRoot), JSON.stringify(nextState, null, 2) + "\n", "utf8");
+}
+function clearState(projectRoot) {
+  const statePath = getStatePath(projectRoot);
+  if (fs2.existsSync(statePath)) {
+    fs2.rmSync(statePath);
+  }
+}
+function hasActiveTask(projectRoot) {
+  const state = loadState(projectRoot);
+  return state?.status === "in_progress" || state?.status === "review";
+}
+function createState(taskId, taskTitle, taskPath, steps) {
+  const timestamp = nowIso();
+  return {
+    taskId,
+    taskTitle,
+    taskPath,
+    status: "in_progress",
+    steps: [...steps],
+    startedAt: timestamp,
+    updatedAt: timestamp
+  };
+}
+function saveIterationLog(projectRoot, taskId, service, iteration2, payload) {
+  const logsDir = ensureLogsDir(projectRoot, taskId);
+  const base = `${service}-iteration-${String(iteration2)}`;
+  fs2.writeFileSync(path2.join(logsDir, `${base}-diff.txt`), payload.diff, "utf8");
+  fs2.writeFileSync(path2.join(logsDir, `${base}-review.json`), JSON.stringify(payload.review, null, 2) + "\n", "utf8");
+  fs2.writeFileSync(
+    path2.join(logsDir, `${base}-arbiter.json`),
+    JSON.stringify(payload.arbiter, null, 2) + "\n",
+    "utf8"
+  );
+}
+
+// src/lib/tasks.ts
+import fs3 from "fs";
+import path3 from "path";
+import { load as parseYaml } from "js-yaml";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function requireString2(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${field} must be a non-empty string`);
+  }
+  return value;
+}
+function parseTaskStep(value, index, config) {
+  if (!isRecord2(value)) {
+    throw new Error(`steps[${String(index)}] must be an object`);
+  }
+  const service = requireString2(value.service, `steps[${String(index)}].service`);
+  const spec = requireString2(value.spec, `steps[${String(index)}].spec`);
+  if (!config.services.some((item) => item.name === service)) {
+    throw new Error(`steps[${String(index)}].service references unknown service '${service}'`);
+  }
+  const dependsOnRaw = value.depends_on;
+  let depends_on;
+  if (dependsOnRaw !== void 0) {
+    if (!Array.isArray(dependsOnRaw) || !dependsOnRaw.every((dep) => typeof dep === "string" && dep.trim().length > 0)) {
+      throw new Error(`steps[${String(index)}].depends_on must be an array of non-empty strings`);
+    }
+    depends_on = dependsOnRaw;
+  }
+  return {
+    service,
+    spec,
+    depends_on
+  };
+}
+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);
+    throw new Error(`Invalid task YAML: ${message}`);
+  }
+  if (!isRecord2(parsed)) {
+    throw new Error("task must be a YAML object");
+  }
+  const id = requireString2(parsed.id, "id");
+  const title = requireString2(parsed.title, "title");
+  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));
+  return { id, title, steps };
+}
+function buildInitialStepState(task) {
+  return task.steps.map((step2) => ({
+    service: step2.service,
+    status: "pending",
+    iteration: 0
+  }));
+}
+function ensureTaskDirectory(projectRoot, taskState) {
+  const dir = path3.join(projectRoot, "tasks", taskState);
+  fs3.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function moveTaskFileAtomically(taskPath, destinationDir) {
+  const destinationPath = path3.join(destinationDir, path3.basename(taskPath));
+  fs3.renameSync(taskPath, destinationPath);
+  return destinationPath;
+}
+
+// src/commands/abort.ts
+function fatalAndExit(message) {
+  fatal(message);
+  process.exit(1);
+}
+async function promptConfirmation(taskId) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(`Abort task ${taskId}? Branches will be kept. [y/N] `);
+    return answer.trim().toLowerCase() === "y";
+  } finally {
+    rl.close();
+  }
+}
+async function runAbort(options) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    fatalAndExit("Not inside a vexdo project.");
+  }
+  const state = loadState(projectRoot);
+  if (!state) {
+    fatalAndExit("No active task.");
+  }
+  if (!options.force) {
+    const confirmed = await promptConfirmation(state.taskId);
+    if (!confirmed) {
+      info("Abort cancelled.");
+      return;
+    }
+  }
+  const inProgressDir = path4.join(projectRoot, "tasks", "in_progress");
+  if (state.taskPath.startsWith(inProgressDir) && fs4.existsSync(state.taskPath)) {
+    const backlogDir = ensureTaskDirectory(projectRoot, "backlog");
+    moveTaskFileAtomically(state.taskPath, backlogDir);
+  }
+  clearState(projectRoot);
+  info("Task aborted. Branches preserved for manual review.");
+}
+function registerAbortCommand(program2) {
+  program2.command("abort").description("Abort active task").option("--force", "Skip confirmation prompt").action(async (options) => {
+    await runAbort(options);
+  });
+}
+
+// src/commands/fix.ts
+import path6 from "path";
+
+// src/lib/claude.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/prompts/arbiter.ts
+var ARBITER_SYSTEM_PROMPT = `You are a technical arbiter receiving: spec, diff, and reviewer comments.
+
+Rules:
+- Treat the spec as the single source of truth, not reviewer opinion.
+- Explicitly check each reviewer comment against the spec:
+  - If a comment correctly identifies a spec violation, include it in the decision.
+  - If a comment conflicts with the spec or invents requirements, flag it and escalate.
+  - If comments are ambiguous, escalate.
+- Never resolve architectural decisions autonomously; escalate instead.
+- When decision is fix, feedback_for_codex must be concrete and actionable: what to change, where, and how.
+
+Decision rules:
+- submit: no critical/important comments that reflect real spec violations.
+- fix: clear spec violations with actionable fixes; include feedback_for_codex.
+- escalate: any reviewer/spec conflict, architectural ambiguity, or if max-iteration-like uncertainty would require escalation.
+
+Output requirements:
+- Output ONLY valid JSON with schema:
+  { "decision", "reasoning", "feedback_for_codex", "summary" }
+- feedback_for_codex is required when decision="fix" and must be omitted otherwise.
+- Never output prose outside the JSON.`;
+
+// src/prompts/reviewer.ts
+var REVIEWER_SYSTEM_PROMPT = `You are a strict code reviewer evaluating a git diff against a provided spec.
+
+Rules:
+- Treat the spec (acceptance criteria + architectural constraints) as the ONLY source of truth.
+- Never invent requirements that are not explicitly present in the spec.
+- Evaluate whether the diff violates the spec; distinguish real violations from stylistic preferences.
+- For each issue, provide exact file and line number when visible in the diff.
+- Severity definitions (strict):
+  - critical: breaks an acceptance criterion or architectural constraint.
+  - important: likely to cause bugs or maintenance issues directly related to the spec.
+  - minor: code quality issue not blocking the spec.
+  - noise: style/preference, spec-neutral.
+- If the diff fully satisfies the spec, return no comments.
+
+Output requirements:
+- Output ONLY valid JSON.
+- JSON schema:
+  { "comments": [ { "severity", "file", "line", "comment", "suggestion" } ] }
+- If no issues: { "comments": [] }
+- Never output prose outside the JSON.`;
+
+// src/lib/claude.ts
+var REVIEWER_MAX_TOKENS_DEFAULT = 4096;
+var ARBITER_MAX_TOKENS_DEFAULT = 2048;
+var MAX_ATTEMPTS = 3;
+var ClaudeError = class extends Error {
+  attempt;
+  cause;
+  constructor(attempt, cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    super(`Claude API failed after ${String(attempt)} attempts: ${message}`);
+    this.name = "ClaudeError";
+    this.attempt = attempt;
+    this.cause = cause;
+  }
+};
+async function sleep(ms) {
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+var ClaudeClient = class {
+  client;
+  constructor(apiKey) {
+    this.client = new Anthropic({ apiKey });
+  }
+  async runReviewer(opts) {
+    return this.runWithRetry(async () => {
+      const response = await this.client.messages.create({
+        model: opts.model,
+        max_tokens: opts.maxTokens ?? REVIEWER_MAX_TOKENS_DEFAULT,
+        system: REVIEWER_SYSTEM_PROMPT,
+        messages: [
+          {
+            role: "user",
+            content: `SPEC:
+${opts.spec}
+
+DIFF:
+${opts.diff}`
+          }
+        ]
+      });
+      return parseReviewerResult(extractTextFromResponse(response));
+    });
+  }
+  async runArbiter(opts) {
+    return this.runWithRetry(async () => {
+      const response = await this.client.messages.create({
+        model: opts.model,
+        max_tokens: opts.maxTokens ?? ARBITER_MAX_TOKENS_DEFAULT,
+        system: ARBITER_SYSTEM_PROMPT,
+        messages: [
+          {
+            role: "user",
+            content: `SPEC:
+${opts.spec}
+
+DIFF:
+${opts.diff}
+
+REVIEWER COMMENTS:
+${JSON.stringify(opts.reviewComments)}`
+          }
+        ]
+      });
+      return parseArbiterResult(extractTextFromResponse(response));
+    });
+  }
+  async runWithRetry(fn) {
+    let lastError = new Error("Unknown Claude failure");
+    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);
+        }
+        const backoffMs = 1e3 * 2 ** (attempt - 1);
+        warn(
+          `Claude API error on attempt ${String(attempt)}/${String(MAX_ATTEMPTS)}. Retrying in ${String(Math.round(backoffMs / 1e3))}s...`
+        );
+        await sleep(backoffMs);
+      }
+    }
+    throw new ClaudeError(MAX_ATTEMPTS, lastError);
+  }
+};
+function extractTextFromResponse(response) {
+  const content = typeof response === "object" && response !== null && "content" in response ? response.content : null;
+  if (!Array.isArray(content)) {
+    throw new Error("Claude response missing content array");
+  }
+  const text = content.filter((block) => typeof block === "object" && block !== null && "type" in block).filter((block) => block.type === "text").map((block) => typeof block.text === "string" ? block.text : "").join("\n").trim();
+  if (!text) {
+    throw new Error("Claude response had no text content");
+  }
+  return text;
+}
+function extractJson(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("```")) {
+    return trimmed;
+  }
+  const fenced = /^```(?:json)?\s*([\s\S]*?)\s*```$/i.exec(trimmed);
+  if (fenced && fenced[1]) {
+    return fenced[1].trim();
+  }
+  return trimmed;
+}
+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)}`);
+  }
+  if (!isReviewResult(parsed)) {
+    throw new Error("Reviewer JSON does not match schema");
+  }
+  return parsed;
+}
+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)}`);
+  }
+  if (!isArbiterResult(parsed)) {
+    throw new Error("Arbiter JSON does not match schema");
+  }
+  return parsed;
+}
+function isReviewComment(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  if (!["critical", "important", "minor", "noise"].includes(String(candidate.severity))) {
+    return false;
+  }
+  if (typeof candidate.comment !== "string") {
+    return false;
+  }
+  if (candidate.file !== void 0 && typeof candidate.file !== "string") {
+    return false;
+  }
+  if (candidate.line !== void 0 && typeof candidate.line !== "number") {
+    return false;
+  }
+  return !(candidate.suggestion !== void 0 && typeof candidate.suggestion !== "string");
+}
+function isReviewResult(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const comments = value.comments;
+  return Array.isArray(comments) && comments.every((comment) => isReviewComment(comment));
+}
+function isArbiterResult(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  if (!["fix", "submit", "escalate"].includes(String(candidate.decision))) {
+    return false;
+  }
+  if (typeof candidate.reasoning !== "string" || typeof candidate.summary !== "string") {
+    return false;
+  }
+  if (candidate.decision === "fix") {
+    return typeof candidate.feedback_for_codex === "string" && candidate.feedback_for_codex.length > 0;
+  }
+  return candidate.feedback_for_codex === void 0;
+}
+function getStatusCode(error) {
+  if (typeof error !== "object" || error === null) {
+    return void 0;
+  }
+  const candidate = error;
+  if (typeof candidate.status === "number") {
+    return candidate.status;
+  }
+  if (typeof candidate.statusCode === "number") {
+    return candidate.statusCode;
+  }
+  return void 0;
+}
+function isRetryableError(error) {
+  const status = getStatusCode(error);
+  if (status === 400 || status === 401 || status === 403) {
+    return false;
+  }
+  if (status === 429 || status !== void 0 && status >= 500 && status <= 599) {
+    return true;
+  }
+  return true;
+}
+
+// src/lib/codex.ts
+import { execFile as execFileCb } from "child_process";
+var CODEX_TIMEOUT_MS = 6e5;
+var VERBOSE_HEARTBEAT_MS = 15e3;
+var CodexError = class extends Error {
+  stdout;
+  stderr;
+  exitCode;
+  constructor(stdout, stderr, exitCode) {
+    super(`codex exec failed (exit ${String(exitCode)})`);
+    this.name = "CodexError";
+    this.stdout = stdout;
+    this.stderr = stderr;
+    this.exitCode = exitCode;
+  }
+};
+var CodexNotFoundError = class extends Error {
+  constructor() {
+    super("codex CLI not found. Install it: npm install -g @openai/codex");
+    this.name = "CodexNotFoundError";
+  }
+};
+function formatElapsed(startedAt) {
+  const seconds = Math.max(0, Math.round((Date.now() - startedAt) / 1e3));
+  return `${String(seconds)}s`;
+}
+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();
+    });
+  });
+}
+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})`);
+  }
+  return await new Promise((resolve, reject) => {
+    const heartbeat = opts.verbose ? setInterval(() => {
+      debug(`[codex] still running (${formatElapsed(startedAt)})`);
+    }, VERBOSE_HEARTBEAT_MS) : null;
+    execFileCb(
+      "codex",
+      args,
+      { cwd: opts.cwd, timeout: CODEX_TIMEOUT_MS, encoding: "utf8", maxBuffer: 10 * 1024 * 1024 },
+      (error, stdout, stderr) => {
+        if (heartbeat) {
+          clearInterval(heartbeat);
+        }
+        const normalizedStdout = stdout.trimEnd();
+        const normalizedStderr = stderr.trimEnd();
+        if (opts.verbose) {
+          debug(`[codex] finished in ${formatElapsed(startedAt)}`);
+          if (normalizedStdout) {
+            debug(normalizedStdout);
+          }
+          if (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
+        });
+      }
+    );
+  });
+}
+
+// src/lib/gh.ts
+import { execFile as execFileCb2 } from "child_process";
+var GH_TIMEOUT_MS = 3e4;
+var GhNotFoundError = class extends Error {
+  constructor() {
+    super("gh CLI not found. Install it: https://cli.github.com");
+    this.name = "GhNotFoundError";
+  }
+};
+async function checkGhAvailable() {
+  await new Promise((resolve, reject) => {
+    execFileCb2("gh", ["--version"], { timeout: GH_TIMEOUT_MS, encoding: "utf8" }, (error) => {
+      if (error) {
+        reject(new GhNotFoundError());
+        return;
+      }
+      resolve();
+    });
+  });
+}
+async function createPr(opts) {
+  const base = opts.base ?? "main";
+  return await new Promise((resolve, reject) => {
+    execFileCb2(
+      "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()));
+          return;
+        }
+        resolve(stdout.trim());
+      }
+    );
+  });
+}
+
+// src/lib/requirements.ts
+function requireAnthropicApiKey() {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    throw new Error("ANTHROPIC_API_KEY is required");
+  }
+  return apiKey;
+}
+async function requireGhAvailable() {
+  await checkGhAvailable();
+}
+
+// src/lib/review-loop.ts
+import path5 from "path";
+
+// src/lib/git.ts
+import { execFile as execFileCb3 } from "child_process";
+var GIT_TIMEOUT_MS = 3e4;
+var GitError = class extends Error {
+  command;
+  exitCode;
+  stderr;
+  constructor(args, exitCode, stderr) {
+    super(`git ${args.join(" ")} failed (exit ${String(exitCode)}): ${stderr}`);
+    this.name = "GitError";
+    this.command = `git ${args.join(" ")}`;
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+  }
+};
+async function exec2(args, cwd) {
+  return new Promise((resolve, reject) => {
+    execFileCb3("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 GitError(args, exitCode, (stderr || error.message).trim()));
+        return;
+      }
+      resolve(stdout.trimEnd());
+    });
+  });
+}
+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) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function createBranch(name, cwd) {
+  if (await branchExists(name, cwd)) {
+    throw new GitError(["checkout", "-b", name], 128, `branch '${name}' already exists`);
+  }
+  await exec2(["checkout", "-b", name], cwd);
+}
+async function checkoutBranch(name, cwd) {
+  await exec2(["checkout", name], cwd);
+}
+async function getDiff(cwd, base) {
+  if (base) {
+    return exec2(["diff", `${base}..HEAD`], cwd);
+  }
+  return exec2(["diff", "HEAD"], cwd);
+}
+function getBranchName(taskId, service) {
+  return `vexdo/${taskId}/${service}`;
+}
+
+// src/lib/review-loop.ts
+function formatElapsed2(startedAt) {
+  const seconds = Math.max(0, Math.round((Date.now() - startedAt) / 1e3));
+  return `${String(seconds)}s`;
+}
+async function runReviewLoop(opts) {
+  if (opts.dryRun) {
+    info(`[dry-run] Would run review loop for service ${opts.step.service}`);
+    return {
+      decision: "submit",
+      finalIteration: opts.stepState.iteration,
+      lastReviewComments: [],
+      lastArbiterResult: {
+        decision: "submit",
+        reasoning: "Dry run: skipped reviewer and arbiter calls.",
+        summary: "Dry run mode; submitting without external calls."
+      }
+    };
+  }
+  const serviceConfig = opts.config.services.find((service) => service.name === opts.step.service);
+  if (!serviceConfig) {
+    throw new Error(`Unknown service in step: ${opts.step.service}`);
+  }
+  const serviceRoot = path5.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);
+    if (opts.verbose) {
+      info(`Diff collected (${String(diff.length)} chars)`);
+    }
+    if (!diff.trim()) {
+      return {
+        decision: "submit",
+        finalIteration: iteration2,
+        lastReviewComments: [],
+        lastArbiterResult: {
+          decision: "submit",
+          reasoning: "No changes in git diff for service directory.",
+          summary: "No diff detected, nothing to review."
+        }
+      };
+    }
+    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)})`);
+    }, 15e3) : null;
+    const review = await opts.claude.runReviewer({
+      spec: opts.step.spec,
+      diff,
+      model: opts.config.review.model
+    }).finally(() => {
+      if (reviewerHeartbeat) {
+        clearInterval(reviewerHeartbeat);
+      }
+    });
+    info(`Reviewer response received in ${formatElapsed2(reviewerStartedAt)}`);
+    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)})`);
+    }, 15e3) : null;
+    const arbiter = await opts.claude.runArbiter({
+      spec: opts.step.spec,
+      diff,
+      reviewComments: review.comments,
+      model: opts.config.review.model
+    }).finally(() => {
+      if (arbiterHeartbeat) {
+        clearInterval(arbiterHeartbeat);
+      }
+    });
+    info(`Arbiter response received in ${formatElapsed2(arbiterStartedAt)}`);
+    info(`Arbiter decision: ${arbiter.decision} (${arbiter.summary})`);
+    saveIterationLog(opts.projectRoot, opts.taskId, opts.step.service, iteration2, {
+      diff,
+      review,
+      arbiter
+    });
+    opts.stepState.lastReviewComments = review.comments;
+    opts.stepState.lastArbiterResult = arbiter;
+    if (arbiter.decision === "submit") {
+      return {
+        decision: "submit",
+        finalIteration: iteration2,
+        lastReviewComments: review.comments,
+        lastArbiterResult: arbiter
+      };
+    }
+    if (arbiter.decision === "escalate") {
+      return {
+        decision: "escalate",
+        finalIteration: iteration2,
+        lastReviewComments: review.comments,
+        lastArbiterResult: arbiter
+      };
+    }
+    if (iteration2 >= opts.config.review.max_iterations) {
+      return {
+        decision: "escalate",
+        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 {
+        decision: "escalate",
+        finalIteration: iteration2,
+        lastReviewComments: review.comments,
+        lastArbiterResult: {
+          decision: "escalate",
+          reasoning: "Arbiter returned fix decision without feedback_for_codex.",
+          summary: "Escalated because fix instructions were missing."
+        }
+      };
+    }
+    info("Applying arbiter feedback with codex");
+    await exec({
+      spec: arbiter.feedback_for_codex,
+      model: opts.config.codex.model,
+      cwd: serviceRoot,
+      verbose: opts.verbose
+    });
+    iteration2 += 1;
+    opts.stepState.iteration = iteration2;
+  }
+}
+
+// src/commands/fix.ts
+function fatalAndExit2(message) {
+  fatal(message);
+  process.exit(1);
+}
+async function runFix(feedback, options) {
+  try {
+    const projectRoot = findProjectRoot();
+    if (!projectRoot) {
+      fatalAndExit2("Not inside a vexdo project.");
+    }
+    const config = loadConfig(projectRoot);
+    const state = loadState(projectRoot);
+    if (!state) {
+      fatalAndExit2("No active task.");
+    }
+    if (!options.dryRun) {
+      requireAnthropicApiKey();
+      await checkCodexAvailable();
+    }
+    const currentStep = state.steps.find((step3) => step3.status === "in_progress" || step3.status === "pending");
+    if (!currentStep) {
+      fatalAndExit2("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}'.`);
+    }
+    if (!options.dryRun) {
+      const serviceConfig = config.services.find((service) => service.name === currentStep.service);
+      if (!serviceConfig) {
+        fatalAndExit2(`Unknown service in step: ${currentStep.service}`);
+      }
+      await exec({
+        spec: feedback,
+        model: config.codex.model,
+        cwd: path6.resolve(projectRoot, serviceConfig.path),
+        verbose: options.verbose
+      });
+    }
+    info(`Running review loop for service ${step2.service}`);
+    const result = await runReviewLoop({
+      taskId: task.id,
+      task,
+      step: step2,
+      stepState: currentStep,
+      projectRoot,
+      config,
+      claude: new ClaudeClient(process.env.ANTHROPIC_API_KEY ?? ""),
+      dryRun: options.dryRun,
+      verbose: options.verbose
+    });
+    if (result.decision === "escalate") {
+      currentStep.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);
+    }
+    currentStep.status = "done";
+    if (!options.dryRun) {
+      saveState(projectRoot, state);
+    }
+  } catch (error) {
+    fatalAndExit2(error instanceof Error ? error.message : String(error));
+  }
+}
+function registerFixCommand(program2) {
+  program2.command("fix").description("Provide feedback to codex and rerun review").argument("<feedback>").option("--verbose", "Enable verbose logs").option("--dry-run", "Print plan without making changes").action(async (feedback, options, command) => {
+    const merged = command.optsWithGlobals();
+    await runFix(feedback, { ...options, ...merged });
+  });
+}
+
+// src/commands/init.ts
+import fs5 from "fs";
+import path7 from "path";
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+import { stringify } from "yaml";
+var DEFAULT_REVIEW_MODEL2 = "claude-haiku-4-5-20251001";
+var DEFAULT_MAX_ITERATIONS2 = 3;
+var DEFAULT_CODEX_MODEL2 = "gpt-4o";
+var TASK_DIRS = ["backlog", "in_progress", "review", "done", "blocked"];
+async function defaultPrompt(question) {
+  const rl = createInterface({ input, output });
+  try {
+    return await rl.question(question);
+  } finally {
+    rl.close();
+  }
+}
+function parseServices2(value) {
+  const parsed = value.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+  return Array.from(new Set(parsed));
+}
+function parseBoolean(value) {
+  const normalized = value.trim().toLowerCase();
+  return normalized === "y" || normalized === "yes";
+}
+function parseMaxIterations(value) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_ITERATIONS2;
+}
+function ensureGitignoreEntry(gitignorePath, entry) {
+  if (!fs5.existsSync(gitignorePath)) {
+    fs5.writeFileSync(gitignorePath, `${entry}
+`, "utf8");
+    return true;
+  }
+  const content = fs5.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}
+`, "utf8");
+  return true;
+}
+async function runInit(projectRoot, prompt = defaultPrompt) {
+  const configPath = path7.join(projectRoot, ".vexdo.yml");
+  if (fs5.existsSync(configPath)) {
+    warn("Found existing .vexdo.yml.");
+    const overwriteAnswer = await prompt("Overwrite existing .vexdo.yml? (y/N): ");
+    if (!parseBoolean(overwriteAnswer)) {
+      info("Initialization cancelled.");
+      return;
+    }
+  }
+  let services = parseServices2(await prompt("Project services (comma-separated names, e.g. api,web): "));
+  if (services.length === 0) {
+    services = ["api"];
+  }
+  const serviceConfigs = [];
+  for (const name of services) {
+    const answer = await prompt(`Path for ${name} (default: ./${name}): `);
+    serviceConfigs.push({
+      name,
+      path: answer.trim().length > 0 ? answer.trim() : `./${name}`
+    });
+  }
+  const reviewModelRaw = await prompt(`Review model (default: ${DEFAULT_REVIEW_MODEL2}): `);
+  const maxIterationsRaw = await prompt(`Max review iterations (default: ${String(DEFAULT_MAX_ITERATIONS2)}): `);
+  const autoSubmitRaw = await prompt("Auto-submit PRs? (y/N): ");
+  const codexModelRaw = await prompt(`Codex model (default: ${DEFAULT_CODEX_MODEL2}): `);
+  const config = {
+    version: 1,
+    services: serviceConfigs,
+    review: {
+      model: reviewModelRaw.trim() || DEFAULT_REVIEW_MODEL2,
+      max_iterations: maxIterationsRaw.trim() ? parseMaxIterations(maxIterationsRaw.trim()) : DEFAULT_MAX_ITERATIONS2,
+      auto_submit: parseBoolean(autoSubmitRaw)
+    },
+    codex: {
+      model: codexModelRaw.trim() || DEFAULT_CODEX_MODEL2
+    }
+  };
+  fs5.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 gitignoreUpdated = ensureGitignoreEntry(gitignorePath, ".vexdo/");
+  success("Initialized vexdo project.");
+  info(`Created: ${path7.relative(projectRoot, configPath)}`);
+  info(`Created directories: ${createdDirs.join(", ")}`);
+  if (gitignoreUpdated) {
+    info("Updated .gitignore with .vexdo/");
+  }
+  info("Next: create a task file in tasks/backlog/ and run 'vexdo start tasks/backlog/my-task.yml'");
+}
+function registerInitCommand(program2) {
+  program2.command("init").description("Initialize vexdo in the current project").action(async () => {
+    await runInit(process.cwd());
+  });
+}
+
+// src/commands/logs.ts
+import fs6 from "fs";
+import path8 from "path";
+function fatalAndExit3(message) {
+  fatal(message);
+  process.exit(1);
+}
+function runLogs(taskIdArg, options) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    fatalAndExit3("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)) {
+      info("No logs available.");
+      return;
+    }
+    const tasks = fs6.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}'.`);
+  }
+  const files = fs6.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"));
+    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(JSON.stringify(review, null, 2));
+      console.log(JSON.stringify(arbiter, null, 2));
+    }
+  }
+}
+function registerLogsCommand(program2) {
+  program2.command("logs").description("Show iteration logs").argument("[task-id]").option("--full", "Print full diff and comments").action((taskId, options) => {
+    runLogs(taskId, options);
+  });
+}
+
+// src/commands/review.ts
+import fs7 from "fs";
+function fatalAndExit4(message) {
+  fatal(message);
+  process.exit(1);
+}
+async function runReview(options) {
+  try {
+    const projectRoot = findProjectRoot();
+    if (!projectRoot) {
+      fatalAndExit4("Not inside a vexdo project.");
+    }
+    const config = loadConfig(projectRoot);
+    const state = loadState(projectRoot);
+    if (!state) {
+      fatalAndExit4("No active task.");
+    }
+    if (!options.dryRun) {
+      requireAnthropicApiKey();
+    }
+    const currentStep = state.steps.find((step3) => step3.status === "in_progress" || step3.status === "pending");
+    if (!currentStep) {
+      fatalAndExit4("No in-progress step found in active task.");
+    }
+    if (!fs7.existsSync(state.taskPath)) {
+      fatalAndExit4(`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}'.`);
+    }
+    info(`Running review loop for service ${step2.service}`);
+    const result = await runReviewLoop({
+      taskId: task.id,
+      task,
+      step: step2,
+      stepState: currentStep,
+      projectRoot,
+      config,
+      claude: new ClaudeClient(process.env.ANTHROPIC_API_KEY ?? ""),
+      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
+      });
+      currentStep.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);
+    }
+    currentStep.status = "done";
+    if (!options.dryRun) {
+      saveState(projectRoot, state);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    fatalAndExit4(message);
+  }
+}
+function registerReviewCommand(program2) {
+  program2.command("review").description("Run review loop for the current step").option("--verbose", "Enable verbose logs").option("--dry-run", "Print plan without making changes").action(async (options, command) => {
+    const merged = command.optsWithGlobals();
+    await runReview({ ...options, ...merged });
+  });
+}
+
+// src/commands/start.ts
+import path10 from "path";
+
+// src/lib/submit-task.ts
+import fs8 from "fs";
+import path9 from "path";
+async function submitActiveTask(projectRoot, config, state) {
+  for (const step2 of state.steps) {
+    if (step2.status !== "done" && step2.status !== "in_progress") {
+      continue;
+    }
+    const service = config.services.find((item) => item.name === step2.service);
+    if (!service) {
+      throw new Error(`Unknown service in state: ${step2.service}`);
+    }
+    const servicePath = path9.resolve(projectRoot, service.path);
+    const body = `Task: ${state.taskId}
+Service: ${step2.service}`;
+    const url = await createPr({
+      title: `${state.taskTitle} [${step2.service}]`,
+      body,
+      base: "main",
+      cwd: servicePath
+    });
+    success(`PR created: ${url}`);
+  }
+  state.status = "done";
+  saveState(projectRoot, state);
+  const doneDir = ensureTaskDirectory(projectRoot, "done");
+  if (fs8.existsSync(state.taskPath)) {
+    state.taskPath = moveTaskFileAtomically(state.taskPath, doneDir);
+    saveState(projectRoot, state);
+  }
+  clearState(projectRoot);
+}
+
+// src/commands/start.ts
+function fatalAndExit5(message, hint) {
+  fatal(message, hint);
+  process.exit(1);
+}
+async function runStart(taskFile, options) {
+  try {
+    const projectRoot = findProjectRoot();
+    if (!projectRoot) {
+      fatalAndExit5("Not inside a vexdo project. Could not find .vexdo.yml.");
+    }
+    const config = loadConfig(projectRoot);
+    const taskPath = path10.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.");
+    }
+    if (!options.dryRun) {
+      requireAnthropicApiKey();
+      await checkCodexAvailable();
+    }
+    let state = loadState(projectRoot);
+    if (!options.resume) {
+      let taskPathInProgress = taskPath;
+      if (!options.dryRun) {
+        const inProgressDir = ensureTaskDirectory(projectRoot, "in_progress");
+        taskPathInProgress = moveTaskFileAtomically(taskPath, inProgressDir);
+      }
+      state = createState(task.id, task.title, taskPathInProgress, buildInitialStepState(task));
+      if (!options.dryRun) {
+        saveState(projectRoot, state);
+      }
+    }
+    if (!state) {
+      fatalAndExit5("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.`);
+          }
+        }
+      }
+      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);
+        }
+      }
+      stepState.status = "in_progress";
+      stepState.branch = branch;
+      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) {
+        saveState(projectRoot, state);
+      }
+    }
+    state.status = "review";
+    if (!options.dryRun) {
+      const reviewDir = ensureTaskDirectory(projectRoot, "review");
+      state.taskPath = moveTaskFileAtomically(state.taskPath, reviewDir);
+      saveState(projectRoot, state);
+    }
+    if (config.review.auto_submit && !options.dryRun) {
+      await submitActiveTask(projectRoot, config, state);
+      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);
+  }
+}
+function registerStartCommand(program2) {
+  program2.command("start").description("Start a task from a YAML file").argument("<task-file>").option("--verbose", "Enable verbose logs").option("--dry-run", "Print plan without making changes").option("--resume", "Resume an existing active task").action(async (taskFile, options, command) => {
+    const merged = command.optsWithGlobals();
+    await runStart(taskFile, { ...options, ...merged });
+  });
+}
+
+// src/commands/status.ts
+function fatalAndExit6(message) {
+  fatal(message);
+  process.exit(1);
+}
+function formatElapsed3(startedAt) {
+  const elapsedMs = Date.now() - new Date(startedAt).getTime();
+  const minutes = Math.floor(elapsedMs / 1e3 / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) {
+    return `${String(hours)}h ${String(minutes % 60)}m`;
+  }
+  return `${String(minutes)}m`;
+}
+function runStatus() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    fatalAndExit6("Not inside a vexdo project.");
+  }
+  const state = loadState(projectRoot);
+  if (!state) {
+    fatalAndExit6("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 ?? "-"}`);
+  }
+  const inProgress = state.steps.find((step2) => step2.status === "in_progress");
+  if (inProgress?.lastArbiterResult?.summary) {
+    info(`Last arbiter summary: ${inProgress.lastArbiterResult.summary}`);
+  }
+  info(`Elapsed: ${formatElapsed3(state.startedAt)}`);
+}
+function registerStatusCommand(program2) {
+  program2.command("status").description("Print active task status").action(() => {
+    runStatus();
+  });
+}
+
+// src/commands/submit.ts
+function fatalAndExit7(message) {
+  fatal(message);
+  process.exit(1);
+}
+async function runSubmit() {
+  try {
+    const projectRoot = findProjectRoot();
+    if (!projectRoot) {
+      fatalAndExit7("Not inside a vexdo project.");
+    }
+    const config = loadConfig(projectRoot);
+    const state = loadState(projectRoot);
+    if (!state) {
+      fatalAndExit7("No active task.");
+    }
+    await requireGhAvailable();
+    await submitActiveTask(projectRoot, config, state);
+  } catch (error) {
+    fatalAndExit7(error instanceof Error ? error.message : String(error));
+  }
+}
+function registerSubmitCommand(program2) {
+  program2.command("submit").description("Create PRs for active task").action(async () => {
+    await runSubmit();
+  });
+}
+
+// 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 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) => {
+  const globalOpts = actionCommand.optsWithGlobals();
+  setVerbose(Boolean(globalOpts.verbose));
+});
+registerInitCommand(program);
+registerStartCommand(program);
+registerReviewCommand(program);
+registerFixCommand(program);
+registerSubmitCommand(program);
+registerStatusCommand(program);
+registerAbortCommand(program);
+registerLogsCommand(program);
+program.parse(process.argv);