GitHub workflow

const args: string[] = [];
const isClaudeProvider = providerId === 'claude';

if (isClaudeProvider) {
  // Use -p (print/non-interactive) mode with JSON output
  args.push('-p', prompt, '--output-format', 'json');
  if (provider!.autoApproveFlag) {
    args.push(provider!.autoApproveFlag);
  }
} else {
  // Standard agent invocation
  if (provider!.defaultArgs?.length) {
    args.push(...provider!.defaultArgs);
  }
  if (provider!.autoApproveFlag) {
    args.push(provider!.autoApproveFlag);
  }
  if (provider!.initialPromptFlag !== undefined) {
    if (provider!.initialPromptFlag) {
      args.push(provider!.initialPromptFlag);
    }
    args.push(prompt);
  }
}

const child = spawn(cliCommand, args, { cwd: taskPath });

Generate a concise PR title and description based on these changes:

Commits:
- feat: add dark mode toggle
- fix: theme persistence bug

Diff summary:
 src/theme.ts     | 45 +++++++++++++++++++++++++++--
 src/components/  | 12 +++++---
 2 files changed, 52 insertions(+), 5 deletions(-)

Respond with ONLY valid JSON:
{
  "title": "feat: add dark mode",
  "description": "## Changes\n- Added theme toggle\n- Fixed persistence"
}

private generateHeuristicContent(
  diff: string,
  commits: string[],
  changedFiles: string[]
): GeneratedPrContent {
  let title = 'chore: update code';
  if (commits.length > 0) {
    title = commits[0]; // Most recent commit
    if (title.length > 72) {
      title = title.substring(0, 69) + '...';
    }
  }

  const descriptionParts: string[] = [];
  if (commits.length > 0) {
    descriptionParts.push('## Changes');
    commits.forEach((commit) => {
      descriptionParts.push(`- ${commit}`);
    });
  }

  if (changedFiles.length > 0) {
    descriptionParts.push('\n## Files Changed');
    changedFiles.slice(0, 20).forEach((file) => {
      descriptionParts.push(`- \`${file}\``);
    });
  }

  return { title, description: descriptionParts.join('\n') };
}

// From GitHubService.ts:763-802
async getPullRequests(projectPath: string): Promise<GitHubPullRequest[]> {
  const fields = [
    'number',
    'title',
    'headRefName',
    'baseRefName',
    'url',
    'isDraft',
    'updatedAt',
    'headRefOid',
    'author',
  ];
  const { stdout } = await this.execGH(
    `gh pr list --state open --json ${fields.join(',')}`,
    { cwd: projectPath }
  );
  return JSON.parse(stdout || '[]');
}

// From GitHubService.ts:808-845
async ensurePullRequestBranch(
  projectPath: string,
  prNumber: number,
  branchName: string
): Promise<string> {
  await this.execGH(
    `gh pr checkout ${prNumber} --branch ${branchName} --force`,
    { cwd: projectPath }
  );
  return branchName;
}

gh pr merge <pr-number> --merge  # Standard merge
gh pr merge <pr-number> --squash # Squash merge
gh pr merge <pr-number> --rebase # Rebase merge

## Summary
- Implemented feature X
- Fixed bug Y

**Related**: Fixes #123

gh pr create --draft --title "WIP: add feature" --body "..."

// From GitHubService.ts:965-1001
async createRepository(params: {
  name: string;
  description?: string;
  owner: string;
  isPrivate: boolean;
}): Promise<{ url: string; defaultBranch: string; fullName: string }> {
  const { name, description, owner, isPrivate } = params;
  const visibilityFlag = isPrivate ? '--private' : '--public';
  let command = `gh repo create ${owner}/${name} ${visibilityFlag} --confirm`;

  if (description && description.trim()) {
    command += ` --description ${JSON.stringify(description)}`;
  }

  await this.execGH(command);

  const { stdout } = await this.execGH(
    `gh repo view ${owner}/${name} --json name,nameWithOwner,url,defaultBranchRef`
  );
  const repoInfo = JSON.parse(stdout);

  return {
    url: repoInfo.url,
    defaultBranch: repoInfo.defaultBranchRef?.name || 'main',
    fullName: repoInfo.nameWithOwner,
  };
}

// From GitHubService.ts:460-488
private async execGH(command: string, options?: any) {
  try {
    return await execAsync(command, { encoding: 'utf8', ...options });
  } catch (error: any) {
    if (error.message && error.message.includes('not authenticated')) {
      // Re-authenticate gh CLI with stored token
      const token = await this.getStoredToken();
      if (token) {
        await this.authenticateGHCLI(token);
        // Retry command
        return await execAsync(command, { encoding: 'utf8', ...options });
      }
    }
    throw error;
  }
}