tlc-claude-code 2.2.1 → 2.3.0

package/server/lib/orchestration/worktree-manager.js

@@ -108,6 +108,139 @@ export function removeWorktree(name, { exec } = {}) {
   exec(`git branch -D ${branch}`);
 }
 
+/**
+ * Create an integration branch for a phase.
+ * All worktrees for this phase branch off and merge back into this branch,
+ * producing a single clean PR to main.
+ * @param {number} phase - Phase number
+ * @param {{ exec: Function, baseBranch?: string }} options
+ * @returns {{ branch: string, phase: number }}
+ */
+export function createIntegrationBranch(phase, { exec, baseBranch = 'main' } = {}) {
+  const branch = `phase/${phase}`;
+
+  try {
+    exec(`git checkout -b ${branch} ${baseBranch}`);
+  } catch (err) {
+    // Only fall back if branch already exists — surface other errors
+    const msg = err && err.message ? err.message : String(err);
+    if (msg.includes('already exists')) {
+      exec(`git checkout ${branch}`);
+    } else {
+      throw err;
+    }
+  }
+
+  return { branch, phase };
+}
+
+/**
+ * Get the list of files changed by a branch relative to a base.
+ * @param {string} branch - Branch to check
+ * @param {string} baseBranch - Base branch to diff against
+ * @param {{ exec: Function }} options
+ * @returns {string[]} List of changed file paths
+ */
+export function getChangedFiles(branch, baseBranch, { exec } = {}) {
+  const output = exec(`git diff --name-only ${baseBranch}...${branch}`);
+  return output.split('\n').filter(f => f.trim() !== '');
+}
+
+/**
+ * Merge all worktrees into the integration branch sequentially.
+ * After each merge, rebases remaining worktrees onto the updated integration branch.
+ * Orders worktrees by file overlap — disjoint worktrees merge first to minimize conflicts.
+ * @param {Array<{ name: string, branch: string, path: string }>} worktrees
+ * @param {string} integrationBranch
+ * @param {{ exec: Function }} options
+ * @returns {{ merged: string[], conflicts: string[], integrationBranch: string }}
+ */
+export function mergeAllWorktrees(worktrees, integrationBranch, { exec } = {}) {
+  const merged = [];
+  const conflicts = [];
+
+  if (worktrees.length === 0) {
+    return { merged, conflicts, integrationBranch };
+  }
+
+  // Collect changed files per worktree for overlap analysis
+  const fileMap = new Map();
+  for (const wt of worktrees) {
+    try {
+      const files = getChangedFiles(wt.branch, integrationBranch, { exec });
+      fileMap.set(wt.name, new Set(files));
+    } catch {
+      fileMap.set(wt.name, new Set());
+    }
+  }
+
+  // Sort: worktrees with fewer file overlaps with others merge first
+  const sorted = [...worktrees].sort((a, b) => {
+    const aFiles = fileMap.get(a.name) || new Set();
+    const bFiles = fileMap.get(b.name) || new Set();
+    const allOtherFiles = new Set();
+    for (const [name, files] of fileMap) {
+      if (name !== a.name && name !== b.name) {
+        for (const f of files) allOtherFiles.add(f);
+      }
+    }
+    const aOverlap = [...aFiles].filter(f => allOtherFiles.has(f)).length;
+    const bOverlap = [...bFiles].filter(f => allOtherFiles.has(f)).length;
+    return aOverlap - bOverlap;
+  });
+
+  for (let i = 0; i < sorted.length; i++) {
+    const wt = sorted[i];
+    const remaining = sorted.slice(i + 1);
+
+    // Merge this worktree into the integration branch
+    let mergeSuccess = false;
+    try {
+      exec(`git checkout ${integrationBranch}`);
+    } catch (checkoutErr) {
+      // Checkout failure is an operational error, not a merge conflict — rethrow
+      throw new Error(`Failed to checkout ${integrationBranch}: ${checkoutErr.message || checkoutErr}`);
+    }
+
+    try {
+      exec(`git merge ${wt.branch}`);
+      mergeSuccess = true;
+    } catch (mergeErr) {
+      const msg = mergeErr && mergeErr.message ? mergeErr.message : String(mergeErr);
+      if (msg.includes('CONFLICT') || msg.includes('conflict') || msg.includes('Merge conflict')) {
+        // Content conflict — abort and skip this worktree
+        try { exec('git merge --abort'); } catch { /* already clean */ }
+        conflicts.push(wt.name);
+      } else {
+        // Operational error (dirty tree, wrong branch name, etc.) — rethrow
+        try { exec('git merge --abort'); } catch { /* best effort */ }
+        throw new Error(`Failed to merge ${wt.branch}: ${msg}`);
+      }
+    }
+
+    if (mergeSuccess) {
+      // Clean up the merged worktree — use --force to handle untracked artifacts
+      try { exec(`git worktree remove --force "${wt.path}"`); } catch { /* best effort */ }
+      try { exec(`git branch -D ${wt.branch}`); } catch { /* best effort */ }
+      merged.push(wt.name);
+
+      // Rebase remaining worktrees onto the updated integration branch
+      // Must use git -C <worktree-path> because the branch is checked out there
+      // Quote paths to handle spaces/special characters
+      for (const rem of remaining) {
+        try {
+          exec(`git -C "${rem.path}" rebase ${integrationBranch}`);
+        } catch {
+          // Rebase conflict — abort and let it be handled when this worktree's turn comes
+          try { exec(`git -C "${rem.path}" rebase --abort`); } catch { /* already clean */ }
+        }
+      }
+    }
+  }
+
+  return { merged, conflicts, integrationBranch };
+}
+
 /**
  * Remove worktrees whose last commit is older than maxAge milliseconds.
  * @param {{ exec: Function, maxAge?: number }} options

package/server/lib/orchestration/worktree-manager.test.js

@@ -6,6 +6,9 @@ import {
   removeWorktree,
   cleanupStale,
   sanitizeName,
+  createIntegrationBranch,
+  mergeAllWorktrees,
+  getChangedFiles,
 } from './worktree-manager.js';
 
 describe('worktree-manager', () => {
@@ -126,4 +129,199 @@ describe('worktree-manager', () => {
       expect(removed).not.toContain('new-task');
     });
   });
+
+  describe('createIntegrationBranch', () => {
+    it('creates branch off base and returns branch name', () => {
+      exec.mockReturnValue('');
+      const result = createIntegrationBranch(42, { exec });
+      expect(result.branch).toBe('phase/42');
+      expect(result.phase).toBe(42);
+      const cmds = exec.mock.calls.map(c => c[0]);
+      expect(cmds.some(c => c.includes('git checkout -b phase/42'))).toBe(true);
+    });
+
+    it('uses custom base branch', () => {
+      exec.mockReturnValue('');
+      const result = createIntegrationBranch(5, { exec, baseBranch: 'develop' });
+      expect(result.branch).toBe('phase/5');
+      const cmds = exec.mock.calls.map(c => c[0]);
+      expect(cmds.some(c => c.includes('develop'))).toBe(true);
+    });
+
+    it('checks out existing integration branch if it already exists', () => {
+      exec.mockImplementation((cmd) => {
+        if (cmd.includes('git checkout -b')) throw new Error('fatal: a branch named phase/42 already exists');
+        return '';
+      });
+      const result = createIntegrationBranch(42, { exec });
+      expect(result.branch).toBe('phase/42');
+      const cmds = exec.mock.calls.map(c => c[0]);
+      expect(cmds.some(c => c === 'git checkout phase/42')).toBe(true);
+    });
+
+    it('throws on non-exists errors (e.g., missing base branch)', () => {
+      exec.mockImplementation((cmd) => {
+        if (cmd.includes('git checkout -b')) throw new Error('fatal: not a valid object name: nonexistent');
+        return '';
+      });
+      expect(() => createIntegrationBranch(42, { exec, baseBranch: 'nonexistent' }))
+        .toThrow('not a valid object name');
+    });
+  });
+
+  describe('getChangedFiles', () => {
+    it('returns list of files changed by a branch', () => {
+      exec.mockReturnValue('src/auth.ts\nsrc/user.ts\n');
+      const files = getChangedFiles('worktree-task-1', 'phase/42', { exec });
+      expect(files).toEqual(['src/auth.ts', 'src/user.ts']);
+    });
+
+    it('returns empty array when no changes', () => {
+      exec.mockReturnValue('');
+      const files = getChangedFiles('worktree-task-1', 'phase/42', { exec });
+      expect(files).toEqual([]);
+    });
+  });
+
+  describe('mergeAllWorktrees', () => {
+    it('merges worktrees sequentially into integration branch', () => {
+      const worktrees = [
+        { name: 'task-1', branch: 'worktree-task-1', path: '/repo/.claude/worktrees/task-1' },
+        { name: 'task-2', branch: 'worktree-task-2', path: '/repo/.claude/worktrees/task-2' },
+      ];
+      exec.mockReturnValue('');
+
+      const result = mergeAllWorktrees(worktrees, 'phase/42', { exec });
+
+      expect(result.merged).toEqual(['task-1', 'task-2']);
+      expect(result.conflicts).toEqual([]);
+      expect(result.integrationBranch).toBe('phase/42');
+    });
+
+    it('rebases remaining worktrees after each merge', () => {
+      const worktrees = [
+        { name: 'task-1', branch: 'worktree-task-1', path: '/repo/.claude/worktrees/task-1' },
+        { name: 'task-2', branch: 'worktree-task-2', path: '/repo/.claude/worktrees/task-2' },
+        { name: 'task-3', branch: 'worktree-task-3', path: '/repo/.claude/worktrees/task-3' },
+      ];
+      exec.mockReturnValue('');
+
+      mergeAllWorktrees(worktrees, 'phase/42', { exec });
+
+      // After merging task-1, should rebase task-2 and task-3 using git -C <path>
+      const cmds = exec.mock.calls.map(c => c[0]);
+      const rebaseCmds = cmds.filter(c => c.includes('rebase'));
+      expect(rebaseCmds.length).toBeGreaterThanOrEqual(2);
+      // Must use git -C to rebase within the worktree (branch is checked out there)
+      expect(rebaseCmds.every(c => c.includes('git -C'))).toBe(true);
+    });
+
+    it('continues merging others when one worktree conflicts', () => {
+      const worktrees = [
+        { name: 'task-1', branch: 'worktree-task-1', path: '/repo/.claude/worktrees/task-1' },
+        { name: 'task-2', branch: 'worktree-task-2', path: '/repo/.claude/worktrees/task-2' },
+        { name: 'task-3', branch: 'worktree-task-3', path: '/repo/.claude/worktrees/task-3' },
+      ];
+
+      exec.mockImplementation((cmd) => {
+        // task-2 merge conflicts
+        if (cmd.includes('git merge worktree-task-2')) throw new Error('CONFLICT');
+        // task-2 rebase also fails (expected after conflict)
+        if (cmd.includes('git rebase') && cmd.includes('worktree-task-2')) throw new Error('CONFLICT');
+        return '';
+      });
+
+      const result = mergeAllWorktrees(worktrees, 'phase/42', { exec });
+
+      expect(result.merged).toContain('task-1');
+      expect(result.merged).toContain('task-3');
+      expect(result.conflicts).toContain('task-2');
+    });
+
+    it('cleans up worktrees after successful merge', () => {
+      const worktrees = [
+        { name: 'task-1', branch: 'worktree-task-1', path: '/repo/.claude/worktrees/task-1' },
+      ];
+      exec.mockReturnValue('');
+
+      mergeAllWorktrees(worktrees, 'phase/42', { exec });
+
+      const cmds = exec.mock.calls.map(c => c[0]);
+      expect(cmds.some(c => c.includes('git worktree remove'))).toBe(true);
+      expect(cmds.some(c => c.includes('git branch -D worktree-task-1'))).toBe(true);
+    });
+
+    it('preserves conflicting worktrees for manual resolution', () => {
+      const worktrees = [
+        { name: 'task-1', branch: 'worktree-task-1', path: '/repo/.claude/worktrees/task-1' },
+      ];
+
+      exec.mockImplementation((cmd) => {
+        if (cmd.includes('git merge')) throw new Error('CONFLICT');
+        return '';
+      });
+
+      mergeAllWorktrees(worktrees, 'phase/42', { exec });
+
+      const cmds = exec.mock.calls.map(c => c[0]);
+      expect(cmds.some(c => c.includes('git worktree remove'))).toBe(false);
+    });
+
+    it('throws on non-conflict merge errors (dirty tree, wrong branch)', () => {
+      const worktrees = [
+        { name: 'task-1', branch: 'worktree-task-1', path: '/repo/.claude/worktrees/task-1' },
+      ];
+
+      exec.mockImplementation((cmd) => {
+        if (cmd.includes('git merge')) throw new Error('fatal: not something we can merge');
+        return '';
+      });
+
+      expect(() => mergeAllWorktrees(worktrees, 'phase/42', { exec }))
+        .toThrow('Failed to merge');
+    });
+
+    it('orders worktrees by file overlap — disjoint first', () => {
+      const worktrees = [
+        { name: 'task-1', branch: 'worktree-task-1', path: '/repo/.claude/worktrees/task-1' },
+        { name: 'task-2', branch: 'worktree-task-2', path: '/repo/.claude/worktrees/task-2' },
+        { name: 'task-3', branch: 'worktree-task-3', path: '/repo/.claude/worktrees/task-3' },
+      ];
+
+      exec.mockImplementation((cmd) => {
+        // task-1 and task-3 touch the same file, task-2 is disjoint
+        if (cmd.includes('diff --name-only') && cmd.includes('worktree-task-1')) return 'src/shared.ts\nsrc/a.ts\n';
+        if (cmd.includes('diff --name-only') && cmd.includes('worktree-task-2')) return 'src/b.ts\n';
+        if (cmd.includes('diff --name-only') && cmd.includes('worktree-task-3')) return 'src/shared.ts\nsrc/c.ts\n';
+        return '';
+      });
+
+      const result = mergeAllWorktrees(worktrees, 'phase/42', { exec });
+
+      // task-2 (disjoint) should merge before task-1 or task-3 (overlapping)
+      const mergeOrder = result.merged;
+      const task2Index = mergeOrder.indexOf('task-2');
+      expect(task2Index).toBeLessThan(mergeOrder.length - 1);
+    });
+
+    it('returns empty result for empty worktree list', () => {
+      const result = mergeAllWorktrees([], 'phase/42', { exec });
+      expect(result.merged).toEqual([]);
+      expect(result.conflicts).toEqual([]);
+    });
+
+    it('handles single worktree without rebase', () => {
+      const worktrees = [
+        { name: 'task-1', branch: 'worktree-task-1', path: '/repo/.claude/worktrees/task-1' },
+      ];
+      exec.mockReturnValue('');
+
+      const result = mergeAllWorktrees(worktrees, 'phase/42', { exec });
+
+      expect(result.merged).toEqual(['task-1']);
+      const cmds = exec.mock.calls.map(c => c[0]);
+      // No rebase needed for a single worktree
+      expect(cmds.some(c => c.includes('git rebase'))).toBe(false);
+    });
+  });
 });

package/server/lib/overdrive-command.js

@@ -10,7 +10,7 @@
  * Use --agents N to limit parallelism to specific number
  *
  * Opus 4.6 Multi-Agent Features:
- * - Model selection per agent (opus/sonnet/haiku) based on task complexity
+ * - Model selection per agent (always opus for quality)
  * - Agent resumption via `resume` parameter for retry/continuation
  * - TaskOutput for non-blocking progress checks on background agents
  * - TaskStop for cancelling stuck agents
@@ -32,13 +32,13 @@ const AGENT_TYPES = {
 };
 
 /**
- * Model tiers for cost/capability optimization (Opus 4.6)
- * Agents are assigned models based on task complexity.
+ * Model tiers (Opus 4.6)
+ * All tasks use opus — cheaper models produce lower quality that costs more in fix cycles.
  */
 const MODEL_TIERS = {
-  HEAVY: 'opus',    // Complex multi-file features, architectural work
-  STANDARD: 'sonnet', // Normal implementation tasks (default)
-  LIGHT: 'haiku',   // Simple tasks: config, boilerplate, single-file changes
+  HEAVY: 'opus',
+  STANDARD: 'opus',
+  LIGHT: 'opus',
 };
 
 /**
@@ -79,7 +79,7 @@ function estimateTaskComplexity(task) {
  * Get model for a task based on its complexity
  * @param {Object} task - Task object
  * @param {string} [modelOverride] - Force a specific model
- * @returns {string} Model name (opus, sonnet, haiku)
+ * @returns {string} Model name (always opus)
  */
 function getModelForTask(task, modelOverride) {
   if (modelOverride) {
@@ -127,7 +127,7 @@ function parseOverdriveArgs(args = '') {
       options.mode = parts[++i];
     } else if (part === '--model' && parts[i + 1]) {
       const model = parts[++i].toLowerCase();
-      if (['opus', 'sonnet', 'haiku'].includes(model)) {
+      if (['opus'].includes(model)) {
         options.model = model;
       }
     } else if (part === '--max-turns' && parts[i + 1]) {
@@ -305,8 +305,15 @@ function formatOverdrivePlan(plan) {
   lines.push('All agents spawned simultaneously via Task tool (Opus 4.6 multi-agent).');
   lines.push('Each agent works independently until completion.');
   lines.push('');
+  lines.push('**Integration Branch:**');
+  lines.push(`- All worktrees branch off \`phase/${plan.phase}\` (not main)`);
+  lines.push('- After all agents complete, worktrees merge sequentially into the integration branch');
+  lines.push('- Disjoint worktrees merge first, overlapping ones last');
+  lines.push('- Remaining worktrees rebase onto integration branch after each merge');
+  lines.push('- Single PR from integration branch to main');
+  lines.push('');
   lines.push('**Capabilities:**');
-  lines.push('- Model selection per task complexity (opus/sonnet/haiku)');
+  lines.push('- All agents use opus for maximum quality');
   lines.push('- Agent resumption for failed tasks (resume parameter)');
   lines.push('- Non-blocking progress checks (TaskOutput block=false)');
   lines.push('- Agent cancellation (TaskStop) for stuck agents');
@@ -448,12 +455,21 @@ async function executeOverdriveCommand(args = '', context = {}) {
   const allPrompts = agentAssignments.flatMap(a => a.prompts);
   const taskCalls = generateTaskCalls(allPrompts);
 
+  // Integration branch name for this phase
+  const integrationBranch = `phase/${options.phase}`;
+
   return {
     success: true,
     plan,
     taskCalls,
+    integrationBranch,
     output: formatOverdrivePlan(plan),
     instructions: `
+BEFORE SPAWNING AGENTS:
+1. Create integration branch: git checkout -b ${integrationBranch} main
+   (If it already exists: git checkout ${integrationBranch})
+2. All worktrees will branch from ${integrationBranch}, not main.
+
 EXECUTE NOW: Spawn ${agentCount} agents in parallel using the Task tool (Opus 4.6).
 
 ${taskCalls.map((tc, i) => `
@@ -471,6 +487,12 @@ Task(
 CRITICAL: Call ALL Task tools in a SINGLE message to run them in parallel.
 Do NOT wait between spawns. Fire them all at once.
 
+AFTER ALL AGENTS COMPLETE:
+1. List worktrees for THIS phase only (filter by "phase-${options.phase}-task")
+2. Merge all worktrees into ${integrationBranch} using mergeAllWorktrees()
+3. Run full test suite on ${integrationBranch}
+4. Create single PR from ${integrationBranch} to main
+
 MONITORING: Use TaskOutput(task_id, block=false) to check progress.
 STUCK AGENT: Use TaskStop(task_id) to cancel, then resume with Task(resume=agent_id).
 FAILED AGENT: Use Task(resume=agent_id) to continue from where it left off.

package/server/lib/overdrive-command.test.js

@@ -75,11 +75,11 @@ describe('overdrive-command', () => {
 
     it('parses --model flag', () => {
       expect(parseOverdriveArgs('--model opus').model).toBe('opus');
-      expect(parseOverdriveArgs('--model sonnet').model).toBe('sonnet');
-      expect(parseOverdriveArgs('--model haiku').model).toBe('haiku');
     });
 
-    it('ignores invalid model values', () => {
+    it('ignores non-opus model values', () => {
+      expect(parseOverdriveArgs('--model sonnet').model).toBeNull();
+      expect(parseOverdriveArgs('--model haiku').model).toBeNull();
       expect(parseOverdriveArgs('--model gpt4').model).toBeNull();
     });
 
@@ -89,12 +89,12 @@ describe('overdrive-command', () => {
     });
 
     it('parses multiple flags including new ones', () => {
-      const options = parseOverdriveArgs('5 --agents 2 --mode test --model sonnet --max-turns 25 --dry-run');
+      const options = parseOverdriveArgs('5 --agents 2 --mode test --model opus --max-turns 25 --dry-run');
 
       expect(options.phase).toBe(5);
       expect(options.agents).toBe(2);
       expect(options.mode).toBe('test');
-      expect(options.model).toBe('sonnet');
+      expect(options.model).toBe('opus');
       expect(options.maxTurns).toBe(25);
       expect(options.dryRun).toBe(true);
     });
@@ -152,7 +152,7 @@ describe('overdrive-command', () => {
       expect(prompts[0].prompt).toContain('Fix any failing tests');
     });
 
-    it('assigns model based on task complexity', () => {
+    it('assigns opus for all task complexities', () => {
       const tasks = [
         { id: 1, title: 'Refactor authentication system' },
         { id: 2, title: 'Add helper function' },
@@ -163,9 +163,9 @@ describe('overdrive-command', () => {
         mode: 'build', projectDir: '/p', phase: 1,
       });
 
-      expect(prompts[0].model).toBe('opus');    // refactor = heavy
-      expect(prompts[1].model).toBe('sonnet');   // default = standard
-      expect(prompts[2].model).toBe('haiku');    // enum = light
+      expect(prompts[0].model).toBe('opus');
+      expect(prompts[1].model).toBe('opus');
+      expect(prompts[2].model).toBe('opus');
     });
 
     it('respects model override', () => {
@@ -176,11 +176,11 @@ describe('overdrive-command', () => {
 
       const prompts = generateAgentPrompts(tasks, {
         mode: 'build', projectDir: '/p', phase: 1,
-        model: 'haiku',
+        model: 'opus',
       });
 
-      expect(prompts[0].model).toBe('haiku');
-      expect(prompts[1].model).toBe('haiku');
+      expect(prompts[0].model).toBe('opus');
+      expect(prompts[1].model).toBe('opus');
     });
 
     it('respects maxTurns override', () => {
@@ -286,8 +286,8 @@ describe('overdrive-command', () => {
   describe('generateTaskCalls', () => {
     it('generates task tool calls with model and max_turns', () => {
       const prompts = [
-        { taskId: 1, taskTitle: 'Test', prompt: 'Do task 1', agentType: 'general-purpose', model: 'sonnet', maxTurns: 50 },
-        { taskId: 2, taskTitle: 'Test 2', prompt: 'Do task 2', agentType: 'general-purpose', model: 'haiku', maxTurns: 30 },
+        { taskId: 1, taskTitle: 'Test', prompt: 'Do task 1', agentType: 'general-purpose', model: 'opus', maxTurns: 50 },
+        { taskId: 2, taskTitle: 'Test 2', prompt: 'Do task 2', agentType: 'general-purpose', model: 'opus', maxTurns: 30 },
       ];
 
       const calls = generateTaskCalls(prompts);
@@ -297,9 +297,9 @@ describe('overdrive-command', () => {
       expect(calls[0].params.description).toContain('Agent 1');
       expect(calls[0].params.run_in_background).toBe(true);
       expect(calls[0].params.subagent_type).toBe('general-purpose');
-      expect(calls[0].params.model).toBe('sonnet');
+      expect(calls[0].params.model).toBe('opus');
       expect(calls[0].params.max_turns).toBe(50);
-      expect(calls[1].params.model).toBe('haiku');
+      expect(calls[1].params.model).toBe('opus');
       expect(calls[1].params.max_turns).toBe(30);
     });
   });
@@ -497,16 +497,16 @@ Blocked by Task 1
       expect(getModelForTask({ title: 'Refactor auth' })).toBe('opus');
     });
 
-    it('returns sonnet for standard tasks', () => {
-      expect(getModelForTask({ title: 'Add endpoint' })).toBe('sonnet');
+    it('returns opus for standard tasks', () => {
+      expect(getModelForTask({ title: 'Add endpoint' })).toBe('opus');
     });
 
-    it('returns haiku for light tasks', () => {
-      expect(getModelForTask({ title: 'Create enum' })).toBe('haiku');
+    it('returns opus for light tasks', () => {
+      expect(getModelForTask({ title: 'Create enum' })).toBe('opus');
     });
 
     it('respects model override', () => {
-      expect(getModelForTask({ title: 'Refactor auth' }, 'haiku')).toBe('haiku');
+      expect(getModelForTask({ title: 'Refactor auth' }, 'opus')).toBe('opus');
       expect(getModelForTask({ title: 'Create enum' }, 'opus')).toBe('opus');
     });
   });
@@ -533,10 +533,10 @@ Blocked by Task 1
       expect(AGENT_TYPES.PLAN).toBe('Plan');
     });
 
-    it('exports valid model tiers', () => {
+    it('exports valid model tiers (all opus)', () => {
       expect(MODEL_TIERS.HEAVY).toBe('opus');
-      expect(MODEL_TIERS.STANDARD).toBe('sonnet');
-      expect(MODEL_TIERS.LIGHT).toBe('haiku');
+      expect(MODEL_TIERS.STANDARD).toBe('opus');
+      expect(MODEL_TIERS.LIGHT).toBe('opus');
     });
 
     it('exports default max turns', () => {
@@ -562,8 +562,7 @@ Blocked by Task 1
 
       expect(output).toContain('Opus 4.6');
       expect(output).toContain('[opus]');
-      expect(output).toContain('[haiku]');
-      expect(output).toContain('Model selection per task complexity');
+      expect(output).toContain('All agents use opus');
       expect(output).toContain('Agent resumption');
       expect(output).toContain('TaskOutput');
       expect(output).toContain('TaskStop');