@vexdo/cli 0.1.0 → 0.1.1

package/test/unit/git.test.ts

@@ -1,120 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-const { execFileMock } = vi.hoisted(() => ({
-  execFileMock: vi.fn(),
-}));
-
-vi.mock('node:child_process', () => ({
-  execFile: execFileMock,
-}));
-
-import {
-  GitError,
-  branchExists,
-  checkoutBranch,
-  commit,
-  createBranch,
-  exec,
-  getBranchName,
-  getCurrentBranch,
-  getDiff,
-  getStatus,
-  hasUncommittedChanges,
-  stageAll,
-} from '../../src/lib/git.js';
-
-beforeEach(() => {
-  execFileMock.mockReset();
-});
-
-describe('git.exec', () => {
-  it('resolves stdout on success', async () => {
-    execFileMock.mockImplementation((_cmd, _args, _opts, cb) => cb(null, 'hello\n', ''));
-
-    await expect(exec(['status'], '/repo')).resolves.toBe('hello');
-  });
-
-  it('throws GitError on non-zero exit with fields', async () => {
-    const error = Object.assign(new Error('failed'), { code: 2 });
-    execFileMock.mockImplementation((_cmd, _args, _opts, cb) => cb(error, '', 'bad things'));
-
-    await expect(exec(['status'], '/repo')).rejects.toMatchObject({
-      name: 'GitError',
-      command: 'git status',
-      exitCode: 2,
-      stderr: 'bad things',
-      message: 'git status failed (exit 2): bad things',
-    });
-  });
-});
-
-describe('git helpers', () => {
-  it('getBranchName returns expected format', () => {
-    expect(getBranchName('task-1', 'api')).toBe('vexdo/task-1/api');
-  });
-
-  it('getDiff returns empty string when no changes', async () => {
-    execFileMock.mockImplementation((_cmd, _args, _opts, cb) => cb(null, '', ''));
-
-    await expect(getDiff('/repo')).resolves.toBe('');
-  });
-
-  it('hasUncommittedChanges returns true/false from porcelain status', async () => {
-    execFileMock.mockImplementationOnce((_cmd, _args, _opts, cb) => cb(null, ' M file.ts\n', ''));
-    await expect(hasUncommittedChanges('/repo')).resolves.toBe(true);
-
-    execFileMock.mockImplementationOnce((_cmd, _args, _opts, cb) => cb(null, '', ''));
-    await expect(hasUncommittedChanges('/repo')).resolves.toBe(false);
-  });
-
-  it('runs all helper functions with git args', async () => {
-    execFileMock.mockImplementation((_cmd, args, _opts, cb) => {
-      if (args[0] === 'rev-parse' && args[3] === 'refs/heads/feature') {
-        const error = Object.assign(new Error('missing'), { code: 1 });
-        cb(error, '', '');
-        return;
-      }
-      cb(null, 'main\n', '');
-    });
-
-    await expect(getCurrentBranch('/repo')).resolves.toBe('main');
-    await expect(branchExists('main', '/repo')).resolves.toBe(true);
-    await expect(createBranch('feature', '/repo')).resolves.toBeUndefined();
-    await expect(checkoutBranch('main', '/repo')).resolves.toBeUndefined();
-    await expect(getStatus('/repo')).resolves.toBe('main');
-    await expect(stageAll('/repo')).resolves.toBeUndefined();
-    await expect(commit('msg', '/repo')).resolves.toBeUndefined();
-
-    expect(execFileMock).toHaveBeenCalledWith('git', ['rev-parse', '--abbrev-ref', 'HEAD'], expect.any(Object), expect.any(Function));
-    expect(execFileMock).toHaveBeenCalledWith(
-      'git',
-      ['rev-parse', '--verify', '--quiet', 'refs/heads/main'],
-      expect.any(Object),
-      expect.any(Function),
-    );
-    expect(execFileMock).toHaveBeenCalledWith('git', ['checkout', '-b', 'feature'], expect.any(Object), expect.any(Function));
-    expect(execFileMock).toHaveBeenCalledWith('git', ['checkout', 'main'], expect.any(Object), expect.any(Function));
-    expect(execFileMock).toHaveBeenCalledWith('git', ['status', '--porcelain'], expect.any(Object), expect.any(Function));
-    expect(execFileMock).toHaveBeenCalledWith('git', ['add', '-A'], expect.any(Object), expect.any(Function));
-    expect(execFileMock).toHaveBeenCalledWith('git', ['commit', '-m', 'msg'], expect.any(Object), expect.any(Function));
-  });
-
-  it('branchExists returns false on exit code 1', async () => {
-    const error = Object.assign(new Error('not found'), { code: 1 });
-    execFileMock.mockImplementation((_cmd, _args, _opts, cb) => cb(error, '', ''));
-
-    await expect(branchExists('missing', '/repo')).resolves.toBe(false);
-  });
-
-  it('createBranch throws if branch exists', async () => {
-    execFileMock.mockImplementation((_cmd, args, _opts, cb) => {
-      if (args[0] === 'rev-parse') {
-        cb(null, 'hash', '');
-        return;
-      }
-      cb(null, '', '');
-    });
-
-    await expect(createBranch('existing', '/repo')).rejects.toBeInstanceOf(GitError);
-  });
-});

package/test/unit/review-loop.test.ts

@@ -1,198 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-const { getDiffMock, codexExecMock, saveIterationLogMock, reviewSummaryMock, infoMock, iterationMock } = vi.hoisted(() => ({
-  getDiffMock: vi.fn(),
-  codexExecMock: vi.fn(),
-  saveIterationLogMock: vi.fn(),
-  reviewSummaryMock: vi.fn(),
-  infoMock: vi.fn(),
-  iterationMock: vi.fn(),
-}));
-
-vi.mock('../../src/lib/git.js', () => ({
-  getDiff: getDiffMock,
-}));
-
-vi.mock('../../src/lib/codex.js', () => ({
-  exec: codexExecMock,
-}));
-
-vi.mock('../../src/lib/state.js', () => ({
-  saveIterationLog: saveIterationLogMock,
-}));
-
-vi.mock('../../src/lib/logger.js', () => ({
-  reviewSummary: reviewSummaryMock,
-  info: infoMock,
-  iteration: iterationMock,
-}));
-
-import { runReviewLoop } from '../../src/lib/review-loop.js';
-import type { ArbiterResult, ReviewResult, StepState, Task, TaskStep, VexdoConfig } from '../../src/types/index.js';
-
-describe('runReviewLoop', () => {
-  const task: Task = { id: 't1', title: 'Task', steps: [] };
-  const step: TaskStep = { service: 'svc', spec: 'spec text' };
-  const config: VexdoConfig = {
-    version: 1,
-    services: [{ name: 'svc', path: '.' }],
-    review: { model: 'claude-sonnet', max_iterations: 2, auto_submit: false },
-    codex: { model: 'gpt-5' },
-  };
-  let stepState: StepState;
-
-  beforeEach(() => {
-    getDiffMock.mockReset();
-    codexExecMock.mockReset();
-    saveIterationLogMock.mockReset();
-    reviewSummaryMock.mockReset();
-    infoMock.mockReset();
-    iterationMock.mockReset();
-
-    stepState = { service: 'svc', status: 'in_progress', iteration: 0 };
-  });
-
-  it('Empty diff returns submit immediately without calling Claude', async () => {
-    getDiffMock.mockResolvedValue('');
-
-    const claude = {
-      runReviewer: vi.fn(),
-      runArbiter: vi.fn(),
-    };
-
-    const result = await runReviewLoop({
-      taskId: 'task-1',
-      task,
-      step,
-      stepState,
-      projectRoot: '/repo',
-      config,
-      claude: claude as never,
-    });
-
-    expect(result.decision).toBe('submit');
-    expect(claude.runReviewer).not.toHaveBeenCalled();
-    expect(claude.runArbiter).not.toHaveBeenCalled();
-  });
-
-  it('submit decision returns correct ReviewLoopResult', async () => {
-    getDiffMock.mockResolvedValue('diff');
-    const review: ReviewResult = { comments: [{ severity: 'minor', comment: 'small' }] };
-    const arbiter: ArbiterResult = { decision: 'submit', reasoning: 'ok', summary: 'ok' };
-    const claude = {
-      runReviewer: vi.fn().mockResolvedValue(review),
-      runArbiter: vi.fn().mockResolvedValue(arbiter),
-    };
-
-    const result = await runReviewLoop({
-      taskId: 'task-1',
-      task,
-      step,
-      stepState,
-      projectRoot: '/repo',
-      config,
-      claude: claude as never,
-    });
-
-    expect(result).toEqual({
-      decision: 'submit',
-      finalIteration: 0,
-      lastReviewComments: review.comments,
-      lastArbiterResult: arbiter,
-    });
-    expect(saveIterationLogMock).toHaveBeenCalledTimes(1);
-  });
-
-  it('escalate decision returns correct ReviewLoopResult', async () => {
-    getDiffMock.mockResolvedValue('diff');
-    const review: ReviewResult = { comments: [{ severity: 'critical', comment: 'broken' }] };
-    const arbiter: ArbiterResult = { decision: 'escalate', reasoning: 'conflict', summary: 'escalate' };
-    const claude = {
-      runReviewer: vi.fn().mockResolvedValue(review),
-      runArbiter: vi.fn().mockResolvedValue(arbiter),
-    };
-
-    const result = await runReviewLoop({ taskId: 'task-1', task, step, stepState, projectRoot: '/repo', config, claude: claude as never });
-
-    expect(result.decision).toBe('escalate');
-    expect(result.lastArbiterResult).toEqual(arbiter);
-  });
-
-  it('fix decision calls codex then loops', async () => {
-    getDiffMock.mockResolvedValueOnce('diff-1').mockResolvedValueOnce('diff-2');
-    const claude = {
-      runReviewer: vi
-        .fn()
-        .mockResolvedValueOnce({ comments: [{ severity: 'important', comment: 'fix me' }] })
-        .mockResolvedValueOnce({ comments: [] }),
-      runArbiter: vi
-        .fn()
-        .mockResolvedValueOnce({ decision: 'fix', reasoning: 'needs fix', summary: 'fix', feedback_for_codex: 'edit file' })
-        .mockResolvedValueOnce({ decision: 'submit', reasoning: 'done', summary: 'submit' }),
-    };
-
-    const result = await runReviewLoop({ taskId: 'task-1', task, step, stepState, projectRoot: '/repo', config, claude: claude as never });
-
-    expect(codexExecMock).toHaveBeenCalledTimes(1);
-    expect(result.decision).toBe('submit');
-    expect(result.finalIteration).toBe(1);
-  });
-
-  it('After max_iterations with fix: escalates', async () => {
-    stepState.iteration = 2;
-    getDiffMock.mockResolvedValue('diff');
-    const claude = {
-      runReviewer: vi.fn().mockResolvedValue({ comments: [{ severity: 'important', comment: 'still bad' }] }),
-      runArbiter: vi.fn().mockResolvedValue({ decision: 'fix', reasoning: 'still broken', summary: 'fix again', feedback_for_codex: 'more' }),
-    };
-
-    const result = await runReviewLoop({ taskId: 'task-1', task, step, stepState, projectRoot: '/repo', config, claude: claude as never });
-
-    expect(result.decision).toBe('escalate');
-    expect(codexExecMock).not.toHaveBeenCalled();
-  });
-
-  it('dryRun skips all external calls', async () => {
-    const claude = {
-      runReviewer: vi.fn(),
-      runArbiter: vi.fn(),
-    };
-
-    const result = await runReviewLoop({
-      taskId: 'task-1',
-      task,
-      step,
-      stepState,
-      projectRoot: '/repo',
-      config,
-      claude: claude as never,
-      dryRun: true,
-    });
-
-    expect(result.decision).toBe('submit');
-    expect(getDiffMock).not.toHaveBeenCalled();
-    expect(codexExecMock).not.toHaveBeenCalled();
-    expect(claude.runReviewer).not.toHaveBeenCalled();
-    expect(claude.runArbiter).not.toHaveBeenCalled();
-  });
-
-  it('Iteration logs are saved on each iteration', async () => {
-    getDiffMock.mockResolvedValueOnce('d1').mockResolvedValueOnce('d2').mockResolvedValueOnce('d3');
-    const claude = {
-      runReviewer: vi
-        .fn()
-        .mockResolvedValueOnce({ comments: [{ severity: 'important', comment: '1' }] })
-        .mockResolvedValueOnce({ comments: [{ severity: 'important', comment: '2' }] })
-        .mockResolvedValueOnce({ comments: [] }),
-      runArbiter: vi
-        .fn()
-        .mockResolvedValueOnce({ decision: 'fix', reasoning: '1', summary: '1', feedback_for_codex: 'a' })
-        .mockResolvedValueOnce({ decision: 'fix', reasoning: '2', summary: '2', feedback_for_codex: 'b' })
-        .mockResolvedValueOnce({ decision: 'submit', reasoning: '3', summary: '3' }),
-    };
-
-    await runReviewLoop({ taskId: 'task-1', task, step, stepState, projectRoot: '/repo', config: { ...config, review: { ...config.review, max_iterations: 5 } }, claude: claude as never });
-
-    expect(saveIterationLogMock).toHaveBeenCalledTimes(3);
-  });
-});

package/tests/integration/review.test.ts

@@ -1,137 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-const mocks = vi.hoisted(() => ({
-  runReviewLoop: vi.fn(),
-  ClaudeClient: vi.fn(() => ({})),
-  codexCheck: vi.fn(),
-  codexExec: vi.fn(),
-  ghCheck: vi.fn(),
-  ghCreate: vi.fn(),
-  gitCreateBranch: vi.fn(),
-  gitCheckoutBranch: vi.fn(),
-  gitBranchName: vi.fn(),
-}));
-
-vi.mock('../../src/lib/review-loop.js', () => ({ runReviewLoop: mocks.runReviewLoop }));
-vi.mock('../../src/lib/claude.js', () => ({ ClaudeClient: mocks.ClaudeClient }));
-vi.mock('../../src/lib/codex.js', () => ({ checkCodexAvailable: mocks.codexCheck, exec: mocks.codexExec }));
-vi.mock('../../src/lib/gh.js', () => ({ checkGhAvailable: mocks.ghCheck, createPr: mocks.ghCreate }));
-vi.mock('../../src/lib/git.js', () => ({ createBranch: mocks.gitCreateBranch, checkoutBranch: mocks.gitCheckoutBranch, getBranchName: mocks.gitBranchName }));
-
-import { runReview } from '../../src/commands/review.js';
-
-const tempDirs: string[] = [];
-
-function tmpDir(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'vexdo-review-'));
-  tempDirs.push(dir);
-  return dir;
-}
-
-function setupProject(root: string): void {
-  fs.mkdirSync(path.join(root, 'tasks', 'in_progress'), { recursive: true });
-  fs.writeFileSync(
-    path.join(root, '.vexdo.yml'),
-    `version: 1
-services:
-  - name: api
-    path: ./services/api
-review:
-  model: m
-  max_iterations: 3
-  auto_submit: false
-codex:
-  model: c
-`,
-  );
-  const taskPath = path.join(root, 'tasks', 'in_progress', 'task.yml');
-  fs.writeFileSync(taskPath, 'id: t1\ntitle: Demo\nsteps:\n  - service: api\n    spec: do work\n');
-  fs.mkdirSync(path.join(root, '.vexdo'), { recursive: true });
-  fs.writeFileSync(
-    path.join(root, '.vexdo', 'state.json'),
-    JSON.stringify({
-      taskId: 't1',
-      taskTitle: 'Demo',
-      taskPath,
-      status: 'in_progress',
-      steps: [{ service: 'api', status: 'in_progress', iteration: 0, branch: 'vexdo/t1/api' }],
-      startedAt: 'a',
-      updatedAt: 'a',
-    }),
-  );
-}
-
-beforeEach(() => {
-  process.env.ANTHROPIC_API_KEY = 'k';
-  mocks.runReviewLoop.mockReset();
-  mocks.runReviewLoop.mockResolvedValue({
-    decision: 'submit',
-    finalIteration: 0,
-    lastReviewComments: [],
-    lastArbiterResult: { decision: 'submit', reasoning: 'ok', summary: 'ok' },
-  });
-});
-
-afterEach(() => {
-  delete process.env.ANTHROPIC_API_KEY;
-  for (const dir of tempDirs.splice(0)) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe('review integration', () => {
-  it('No active task -> fatal', async () => {
-    const root = tmpDir();
-    fs.writeFileSync(path.join(root, '.vexdo.yml'), 'version: 1\nservices:\n  - name: api\n    path: ./services/api\n');
-    process.chdir(root);
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
-      throw new Error('exit');
-    }) as never);
-    await expect(runReview({})).rejects.toThrow('exit');
-    exitSpy.mockRestore();
-  });
-
-  it('Runs review loop on current step', async () => {
-    const root = tmpDir();
-    setupProject(root);
-    process.chdir(root);
-
-    await runReview({});
-
-    expect(mocks.runReviewLoop).toHaveBeenCalledTimes(1);
-  });
-
-  it('Handles submit', async () => {
-    const root = tmpDir();
-    setupProject(root);
-    process.chdir(root);
-
-    await runReview({});
-
-    const state = JSON.parse(fs.readFileSync(path.join(root, '.vexdo', 'state.json'), 'utf8')) as { steps: Array<{ status: string }> };
-    expect(state.steps[0]?.status).toBe('done');
-  });
-
-  it('Handles escalate', async () => {
-    const root = tmpDir();
-    setupProject(root);
-    process.chdir(root);
-    mocks.runReviewLoop.mockResolvedValueOnce({
-      decision: 'escalate',
-      finalIteration: 0,
-      lastReviewComments: [],
-      lastArbiterResult: { decision: 'escalate', reasoning: 'x', summary: 'x' },
-    });
-
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
-      throw new Error('exit');
-    }) as never);
-    await expect(runReview({})).rejects.toThrow('exit');
-    expect(fs.existsSync(path.join(root, 'tasks', 'blocked', 'task.yml'))).toBe(true);
-    exitSpy.mockRestore();
-  });
-});

package/tests/integration/start.test.ts

@@ -1,220 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-const mocks = vi.hoisted(() => ({
-  checkCodexAvailable: vi.fn(),
-  codexExec: vi.fn(),
-  createBranch: vi.fn(),
-  checkoutBranch: vi.fn(),
-  getBranchName: vi.fn((taskId: string, service: string) => `vexdo/${taskId}/${service}`),
-  runReviewLoop: vi.fn(),
-  checkGhAvailable: vi.fn(),
-  createPr: vi.fn(),
-  ClaudeClient: vi.fn(() => ({})),
-}));
-
-vi.mock('../../src/lib/codex.js', () => ({
-  checkCodexAvailable: mocks.checkCodexAvailable,
-  exec: mocks.codexExec,
-}));
-vi.mock('../../src/lib/git.js', () => ({
-  createBranch: mocks.createBranch,
-  checkoutBranch: mocks.checkoutBranch,
-  getBranchName: mocks.getBranchName,
-}));
-vi.mock('../../src/lib/review-loop.js', () => ({
-  runReviewLoop: mocks.runReviewLoop,
-}));
-vi.mock('../../src/lib/gh.js', () => ({
-  checkGhAvailable: mocks.checkGhAvailable,
-  createPr: mocks.createPr,
-}));
-vi.mock('../../src/lib/claude.js', () => ({
-  ClaudeClient: mocks.ClaudeClient,
-}));
-
-import { runStart } from '../../src/commands/start.js';
-import { loadState } from '../../src/lib/state.js';
-
-const tempDirs: string[] = [];
-
-function tmpDir(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'vexdo-start-'));
-  tempDirs.push(dir);
-  return dir;
-}
-
-function setupProject(root: string): void {
-  fs.mkdirSync(path.join(root, 'services', 'api'), { recursive: true });
-  fs.writeFileSync(
-    path.join(root, '.vexdo.yml'),
-    `version: 1
-services:
-  - name: api
-    path: ./services/api
-review:
-  model: m
-  max_iterations: 3
-  auto_submit: false
-codex:
-  model: c
-`,
-  );
-}
-
-beforeEach(() => {
-  process.env.ANTHROPIC_API_KEY = 'test-key';
-  for (const fn of Object.values(mocks)) {
-    if (typeof fn === 'function' && 'mockReset' in fn) {
-      (fn as unknown as { mockReset: () => void }).mockReset();
-    }
-  }
-  mocks.getBranchName.mockImplementation((taskId: string, service: string) => `vexdo/${taskId}/${service}`);
-  mocks.runReviewLoop.mockResolvedValue({
-    decision: 'submit',
-    finalIteration: 0,
-    lastReviewComments: [],
-    lastArbiterResult: { decision: 'submit', reasoning: 'ok', summary: 'ok' },
-  });
-});
-
-afterEach(() => {
-  delete process.env.ANTHROPIC_API_KEY;
-  for (const dir of tempDirs.splice(0)) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe('start integration', () => {
-  it('Creates branch, moves task to in_progress then review on success', async () => {
-    const root = tmpDir();
-    setupProject(root);
-    const taskPath = path.join(root, 'task.yml');
-    fs.writeFileSync(taskPath, 'id: t1\ntitle: Demo\nsteps:\n  - service: api\n    spec: do work\n');
-    process.chdir(root);
-
-    await runStart(taskPath, {});
-
-    expect(mocks.createBranch).toHaveBeenCalledWith('vexdo/t1/api', path.join(root, 'services', 'api'));
-    expect(fs.existsSync(path.join(root, 'tasks', 'in_progress', 'task.yml'))).toBe(false);
-    expect(fs.existsSync(path.join(root, 'tasks', 'review', 'task.yml'))).toBe(true);
-  });
-
-  it('Stops and moves to blocked on escalation', async () => {
-    const root = tmpDir();
-    setupProject(root);
-    const taskPath = path.join(root, 'task.yml');
-    fs.writeFileSync(taskPath, 'id: t1\ntitle: Demo\nsteps:\n  - service: api\n    spec: do work\n');
-    process.chdir(root);
-    mocks.runReviewLoop.mockResolvedValueOnce({
-      decision: 'escalate',
-      finalIteration: 0,
-      lastReviewComments: [],
-      lastArbiterResult: { decision: 'escalate', reasoning: 'no', summary: 'blocked' },
-    });
-
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
-      throw new Error('exit');
-    }) as never);
-
-    await expect(runStart(taskPath, {})).rejects.toThrow('exit');
-    expect(fs.existsSync(path.join(root, 'tasks', 'blocked', 'task.yml'))).toBe(true);
-    exitSpy.mockRestore();
-  });
-
-  it('Fatal with hint if active task exists and no --resume', async () => {
-    const root = tmpDir();
-    setupProject(root);
-    fs.mkdirSync(path.join(root, '.vexdo'), { recursive: true });
-    fs.writeFileSync(
-      path.join(root, '.vexdo', 'state.json'),
-      JSON.stringify({ taskId: 'x', taskTitle: 'X', taskPath: 'x', status: 'in_progress', steps: [], startedAt: 'a', updatedAt: 'a' }),
-    );
-    const taskPath = path.join(root, 'task.yml');
-    fs.writeFileSync(taskPath, 'id: t1\ntitle: Demo\nsteps:\n  - service: api\n    spec: do work\n');
-    process.chdir(root);
-
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
-      throw new Error('exit');
-    }) as never);
-
-    await expect(runStart(taskPath, {})).rejects.toThrow('exit');
-    exitSpy.mockRestore();
-  });
-
-  it('--resume skips codex for done steps', async () => {
-    const root = tmpDir();
-    setupProject(root);
-    const inProgressDir = path.join(root, 'tasks', 'in_progress');
-    fs.mkdirSync(inProgressDir, { recursive: true });
-    const taskPath = path.join(inProgressDir, 'task.yml');
-    fs.writeFileSync(taskPath, 'id: t1\ntitle: Demo\nsteps:\n  - service: api\n    spec: do work\n');
-    fs.mkdirSync(path.join(root, '.vexdo'), { recursive: true });
-    fs.writeFileSync(
-      path.join(root, '.vexdo', 'state.json'),
-      JSON.stringify({
-        taskId: 't1',
-        taskTitle: 'Demo',
-        taskPath,
-        status: 'in_progress',
-        steps: [{ service: 'api', status: 'done', iteration: 0, branch: 'vexdo/t1/api' }],
-        startedAt: 'a',
-        updatedAt: 'a',
-      }),
-    );
-    process.chdir(root);
-
-    await runStart(taskPath, { resume: true });
-
-    expect(mocks.codexExec).not.toHaveBeenCalled();
-  });
-
-  it('--dry-run logs plan without codex/review calls and no file moves', async () => {
-    const root = tmpDir();
-    setupProject(root);
-    const taskPath = path.join(root, 'task.yml');
-    fs.writeFileSync(taskPath, 'id: t1\ntitle: Demo\nsteps:\n  - service: api\n    spec: do work\n');
-    process.chdir(root);
-
-    await runStart(taskPath, { dryRun: true });
-
-    expect(mocks.codexExec).not.toHaveBeenCalled();
-    expect(mocks.runReviewLoop).toHaveBeenCalled();
-    expect(fs.existsSync(taskPath)).toBe(true);
-    expect(loadState(root)).toBeNull();
-  });
-
-  it('Invalid task YAML (missing id) fatals and no state created', async () => {
-    const root = tmpDir();
-    setupProject(root);
-    const taskPath = path.join(root, 'task.yml');
-    fs.writeFileSync(taskPath, 'title: Demo\nsteps:\n  - service: api\n    spec: do work\n');
-    process.chdir(root);
-
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
-      throw new Error('exit');
-    }) as never);
-
-    await expect(runStart(taskPath, {})).rejects.toThrow('exit');
-    expect(loadState(root)).toBeNull();
-    exitSpy.mockRestore();
-  });
-
-  it('Service not in config fatals', async () => {
-    const root = tmpDir();
-    setupProject(root);
-    const taskPath = path.join(root, 'task.yml');
-    fs.writeFileSync(taskPath, 'id: t1\ntitle: Demo\nsteps:\n  - service: web\n    spec: do work\n');
-    process.chdir(root);
-
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
-      throw new Error('exit');
-    }) as never);
-
-    await expect(runStart(taskPath, {})).rejects.toThrow('exit');
-    exitSpy.mockRestore();
-  });
-});