tlc-claude-code 2.2.1 → 2.4.0

package/server/lib/field-report.test.js

@@ -0,0 +1,195 @@
+/**
+ * Field Report Tests
+ *
+ * Tests for agent self-rating field report module.
+ * Reports are filed when quality is below threshold.
+ */
+
+import { describe, it, expect } from 'vitest';
+
+import {
+  shouldFileReport,
+  createFieldReport,
+  formatReportEntry,
+  appendReport,
+} from './field-report.js';
+
+const FIXED_DATE = '2026-03-26T12:00:00.000Z';
+const nowFn = () => new Date(FIXED_DATE);
+
+describe('field-report', () => {
+  describe('shouldFileReport', () => {
+    it('returns false for rating 10', () => {
+      expect(shouldFileReport(10)).toBe(false);
+    });
+
+    it('returns false for rating 9', () => {
+      expect(shouldFileReport(9)).toBe(false);
+    });
+
+    it('returns false for rating 8', () => {
+      expect(shouldFileReport(8)).toBe(false);
+    });
+
+    it('returns true for rating 7', () => {
+      expect(shouldFileReport(7)).toBe(true);
+    });
+
+    it('returns true for rating 0', () => {
+      expect(shouldFileReport(0)).toBe(true);
+    });
+
+    it('returns true for rating 1', () => {
+      expect(shouldFileReport(1)).toBe(true);
+    });
+
+    it('returns true for rating 5', () => {
+      expect(shouldFileReport(5)).toBe(true);
+    });
+  });
+
+  describe('createFieldReport', () => {
+    it('returns markdown with all fields', () => {
+      const report = createFieldReport({
+        skill: 'tlc:build',
+        rating: 5,
+        issue: 'Tests were flaky',
+        suggestion: 'Add retry logic',
+        now: nowFn,
+      });
+
+      expect(report).toContain('tlc:build');
+      expect(report).toContain('5/10');
+      expect(report).toContain('Tests were flaky');
+      expect(report).toContain('Add retry logic');
+      expect(report).toContain('**Suggestion:**');
+    });
+
+    it('includes CRITICAL marker for rating 0', () => {
+      const report = createFieldReport({
+        skill: 'tlc:review',
+        rating: 0,
+        issue: 'Complete failure',
+        suggestion: 'Start over',
+        now: nowFn,
+      });
+
+      expect(report).toContain('CRITICAL');
+      expect(report).toContain('0/10');
+    });
+
+    it('does not include CRITICAL marker for rating above 0', () => {
+      const report = createFieldReport({
+        skill: 'tlc:build',
+        rating: 3,
+        issue: 'Poor quality',
+        suggestion: 'Improve',
+        now: nowFn,
+      });
+
+      expect(report).not.toContain('CRITICAL');
+    });
+
+    it('includes ISO date string', () => {
+      const report = createFieldReport({
+        skill: 'tlc:build',
+        rating: 5,
+        issue: 'Flaky',
+        suggestion: 'Fix it',
+        now: nowFn,
+      });
+
+      expect(report).toContain('2026-03-26');
+    });
+
+    it('follows expected heading format', () => {
+      const report = createFieldReport({
+        skill: 'tlc:build',
+        rating: 5,
+        issue: 'Tests were flaky',
+        suggestion: 'Add retry logic',
+        now: nowFn,
+      });
+
+      expect(report).toMatch(
+        /^## 2026-03-26T12:00:00\.000Z tlc:build 5\/10 — Tests were flaky/
+      );
+    });
+  });
+
+  describe('formatReportEntry', () => {
+    it('returns properly formatted markdown section', () => {
+      const report = createFieldReport({
+        skill: 'tlc:build',
+        rating: 4,
+        issue: 'Slow tests',
+        suggestion: 'Parallelize',
+        now: nowFn,
+      });
+
+      const entry = formatReportEntry(report);
+
+      expect(entry).toContain('## 2026-03-26');
+      expect(entry).toContain('tlc:build');
+      expect(entry).toContain('4/10');
+      expect(entry).toContain('Slow tests');
+      expect(entry).toContain('**Suggestion:** Parallelize');
+      // Entry should end with a newline
+      expect(entry.endsWith('\n')).toBe(true);
+    });
+
+    it('returns the report unchanged if already formatted', () => {
+      const report = createFieldReport({
+        skill: 'tlc:build',
+        rating: 6,
+        issue: 'Minor issue',
+        suggestion: 'Tweak config',
+        now: nowFn,
+      });
+
+      const entry = formatReportEntry(report);
+      // formatReportEntry should ensure trailing newline
+      expect(entry).toBe(report.trimEnd() + '\n');
+    });
+  });
+
+  describe('appendReport', () => {
+    it('appends to existing content with separator', () => {
+      const report = createFieldReport({
+        skill: 'tlc:build',
+        rating: 5,
+        issue: 'Flaky tests',
+        suggestion: 'Add retries',
+        now: nowFn,
+      });
+
+      const result = appendReport('existing content', report);
+
+      expect(result).toContain('existing content');
+      expect(result).toContain(report.trim());
+      // Existing content comes first
+      expect(result.indexOf('existing content')).toBeLessThan(
+        result.indexOf('tlc:build')
+      );
+      // Has separator between existing and new
+      expect(result).toMatch(/existing content\n\n---\n\n/);
+    });
+
+    it('creates fresh content with header when existing is empty', () => {
+      const report = createFieldReport({
+        skill: 'tlc:review',
+        rating: 3,
+        issue: 'Missed edge case',
+        suggestion: 'Check boundaries',
+        now: nowFn,
+      });
+
+      const result = appendReport('', report);
+
+      expect(result).toContain('# Field Reports');
+      expect(result).toContain(report.trim());
+      // No separator before first report
+      expect(result).not.toMatch(/---\n\n##/);
+    });
+  });
+});

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.