@meistrari/tela-cli 0.1.0

package/src/commands/feedback.ts

@@ -0,0 +1,701 @@
+import { basename } from 'node:path'
+import type { AgentFeedbackItem, TelaCliConfig } from '../types.ts'
+import { fetchCommitFeedback, fetchRepositoryLookup } from '../agent-api.ts'
+import {
+    ensureConfigInteractive,
+    type Option,
+    type PromptModule as ConfigPromptModule,
+} from '../config.ts'
+import { createUserFacingError } from '../errors.ts'
+import { getDiffStatAgainstHead, getHeadCommitHash, getOriginUrl } from '../git.ts'
+import { CommandError, commandExists, runInteractiveCommand } from '../process.ts'
+
+export interface ConfirmOptions {
+    message: string
+    active?: string
+    inactive?: string
+    initialValue?: boolean
+}
+
+export interface GroupMultiSelectOptions<T> {
+    message: string
+    options: Record<string, Array<Option<T>>>
+    cursorAt?: T
+}
+
+export interface PromptModule extends ConfigPromptModule {
+    log: {
+        success(message: string): void
+    }
+    note(message: string, title?: string): void
+    confirm(options: ConfirmOptions): Promise<boolean | symbol>
+    groupMultiselect<T>(options: GroupMultiSelectOptions<T>): Promise<T[] | symbol>
+}
+
+export interface FeedbackCommandFlags {
+    list?: boolean
+    apply?: 'all' | 'select'
+}
+
+export interface FeedbackEntry {
+    id: string
+    number: number
+    feedback: AgentFeedbackItem
+    actionable: boolean
+}
+
+export interface FeedbackData {
+    repoRoot: string
+    organizationName: string
+    repository: string
+    commitHash: string
+    entries: FeedbackEntry[]
+    actionableEntries: FeedbackEntry[]
+}
+
+export type FeedbackEmptyState = 'none' | 'no_feedback' | 'informational_only'
+export type FeedbackSelectionMode = 'list' | 'all' | 'select' | 'default'
+
+export interface FeedbackSummary {
+    organizationName: string
+    repository: string
+    commitHash: string
+    totalFeedbacks: number
+    actionableCount: number
+    informationalCount: number
+}
+
+export interface FeedbackGroupedEntries {
+    actionable: FeedbackEntry[]
+    informational: FeedbackEntry[]
+}
+
+export interface FeedbackReviewModel {
+    summary: FeedbackSummary
+    groupedEntries: FeedbackGroupedEntries
+    emptyState: FeedbackEmptyState
+}
+
+export interface FeedbackRunResult {
+    ok: true
+    organizationName: string
+    repository: string
+    commitHash: string
+    summary: FeedbackSummary
+    emptyState: FeedbackEmptyState
+    selectionMode: FeedbackSelectionMode
+    feedbacks: Array<{
+        id: string
+        number: number
+        status: AgentFeedbackItem['status']
+        reason: string
+        suggestion: string
+        actionable: boolean
+    }>
+    selectedIds?: string[]
+    launchedClaude: boolean
+    diffStat?: string
+    nextActions: string[]
+}
+
+export interface RunFeedbackCommandOptions extends FeedbackCommandFlags {
+    cwd?: string
+    prompts: PromptModule
+    ensureConfigInteractive?: typeof ensureConfigInteractive
+    fetchRepositoryLookup?: typeof fetchRepositoryLookup
+    fetchCommitFeedback?: typeof fetchCommitFeedback
+    getOriginUrl?: typeof getOriginUrl
+    getHeadCommitHash?: typeof getHeadCommitHash
+    getDiffStatAgainstHead?: typeof getDiffStatAgainstHead
+    commandExists?: typeof commandExists
+    runInteractiveCommand?: typeof runInteractiveCommand
+}
+
+function promptValue<T>(value: T | symbol): T {
+    return value as T
+}
+
+function truncate(value: string, maxLength: number): string {
+    if (value.length <= maxLength) {
+        return value
+    }
+
+    return `${value.slice(0, Math.max(0, maxLength - 1)).trimEnd()}...`
+}
+
+function firstMeaningfulLine(value: string): string {
+    return value
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .find(Boolean) ?? ''
+}
+
+function parseRepositoryNameFromOrigin(originUrl: string): string | null {
+    const trimmed = originUrl.trim()
+    if (!trimmed) {
+        return null
+    }
+
+    if (trimmed.includes('://')) {
+        try {
+            const url = new URL(trimmed)
+            const segments = url.pathname.split('/').filter(Boolean)
+            const lastSegment = segments.at(-1)
+            return lastSegment ? lastSegment.replace(/\.git$/i, '') : null
+        }
+        catch {
+            return null
+        }
+    }
+
+    const scpMatch = trimmed.match(/^[^@]+@[^:]+:(.+)$/)
+    if (scpMatch?.[1]) {
+        return basename(scpMatch[1]).replace(/\.git$/i, '') || null
+    }
+
+    return basename(trimmed).replace(/\.git$/i, '') || null
+}
+
+async function resolveRepositoryName(
+    cwd: string,
+    getOriginUrlFn: typeof getOriginUrl,
+): Promise<string> {
+    try {
+        const originUrl = await getOriginUrlFn(cwd)
+        return parseRepositoryNameFromOrigin(originUrl) ?? basename(cwd)
+    }
+    catch {
+        return basename(cwd)
+    }
+}
+
+function buildFeedbackEntries(feedbacks: AgentFeedbackItem[]): FeedbackEntry[] {
+    return feedbacks.map((feedback, index) => ({
+        id: String(index + 1),
+        number: index + 1,
+        feedback,
+        actionable: feedback.suggestion.trim().length > 0,
+    }))
+}
+
+export function getFeedbackEntryTitle(entry: FeedbackEntry): string {
+    return firstMeaningfulLine(entry.feedback.suggestion)
+        || firstMeaningfulLine(entry.feedback.reason)
+        || `Feedback #${entry.number}`
+}
+
+export function describeFeedbackSelectionMode(mode: FeedbackSelectionMode): string {
+    switch (mode) {
+        case 'list':
+            return 'Review only'
+        case 'all':
+            return 'Apply all actionable suggestions'
+        case 'select':
+            return 'Choose actionable suggestions'
+        case 'default':
+            return 'Review and edit the actionable selection'
+    }
+}
+
+export function describeFeedbackEmptyState(emptyState: FeedbackEmptyState): string {
+    switch (emptyState) {
+        case 'no_feedback':
+            return 'No feedback was returned for this commit.'
+        case 'informational_only':
+            return 'Only informational feedback is available for this commit.'
+        case 'none':
+            return 'Actionable feedback is available.'
+    }
+}
+
+export function getFeedbackSelectionMode(options: FeedbackCommandFlags): FeedbackSelectionMode {
+    if (options.list) {
+        return 'list'
+    }
+
+    if (options.apply === 'all') {
+        return 'all'
+    }
+
+    if (options.apply === 'select') {
+        return 'select'
+    }
+
+    return 'default'
+}
+
+export function buildFeedbackReviewModel(data: FeedbackData): FeedbackReviewModel {
+    const groupedEntries: FeedbackGroupedEntries = {
+        actionable: data.entries.filter(entry => entry.actionable),
+        informational: data.entries.filter(entry => !entry.actionable),
+    }
+    const summary: FeedbackSummary = {
+        organizationName: data.organizationName,
+        repository: data.repository,
+        commitHash: data.commitHash,
+        totalFeedbacks: data.entries.length,
+        actionableCount: groupedEntries.actionable.length,
+        informationalCount: groupedEntries.informational.length,
+    }
+
+    return {
+        summary,
+        groupedEntries,
+        emptyState: summary.totalFeedbacks === 0
+            ? 'no_feedback'
+            : summary.actionableCount === 0
+                ? 'informational_only'
+                : 'none',
+    }
+}
+
+function formatFeedbackEntryLine(entry: FeedbackEntry): string {
+    return `#${entry.number} [${entry.feedback.status}] ${truncate(getFeedbackEntryTitle(entry), 88)}`
+}
+
+export function formatFeedbackSummary(summary: FeedbackSummary, emptyState: FeedbackEmptyState): string {
+    return [
+        `Organization: ${summary.organizationName}`,
+        `Repository: ${summary.repository}`,
+        `Commit: ${summary.commitHash}`,
+        `Feedbacks: ${summary.totalFeedbacks}`,
+        `Actionable suggestions: ${summary.actionableCount}`,
+        `Informational items: ${summary.informationalCount}`,
+        `Review state: ${describeFeedbackEmptyState(emptyState)}`,
+    ].join('\n')
+}
+
+export function formatFeedbackCatalog(entries: FeedbackEntry[]): string {
+    if (entries.length === 0) {
+        return 'No feedback returned for this commit.'
+    }
+
+    const groupedEntries = {
+        actionable: entries.filter(entry => entry.actionable),
+        informational: entries.filter(entry => !entry.actionable),
+    }
+    const lines: string[] = []
+
+    if (groupedEntries.actionable.length > 0) {
+        lines.push('Actionable')
+        for (const entry of groupedEntries.actionable) {
+            lines.push(`- ${formatFeedbackEntryLine(entry)}`)
+            lines.push(`  reason: ${entry.feedback.reason || '<empty>'}`)
+        }
+    }
+
+    if (groupedEntries.informational.length > 0) {
+        if (lines.length > 0) {
+            lines.push('')
+        }
+
+        lines.push('Informational')
+        for (const entry of groupedEntries.informational) {
+            lines.push(`- ${formatFeedbackEntryLine(entry)}`)
+            lines.push(`  reason: ${entry.feedback.reason || '<empty>'}`)
+        }
+    }
+
+    return lines.join('\n')
+}
+
+function buildFeedbackSelectionGroups(entries: FeedbackEntry[]): Record<string, Array<Option<string>>> {
+    const groupedEntries = {
+        actionable: entries.filter(entry => entry.actionable),
+        informational: entries.filter(entry => !entry.actionable),
+    }
+    const groups: Record<string, Array<Option<string>>> = {}
+
+    if (groupedEntries.actionable.length > 0) {
+        groups.Actionable = groupedEntries.actionable.map(entry => ({
+            value: entry.id,
+            label: `#${entry.number} ${truncate(getFeedbackEntryTitle(entry), 80)}`,
+            hint: truncate(entry.feedback.reason || '<empty>', 60),
+        }))
+    }
+
+    if (groupedEntries.informational.length > 0) {
+        groups.Informational = groupedEntries.informational.map(entry => ({
+            value: entry.id,
+            label: `#${entry.number} ${truncate(getFeedbackEntryTitle(entry), 80)}`,
+            hint: truncate(entry.feedback.reason || 'No suggestion text', 60),
+        }))
+    }
+
+    return groups
+}
+
+export function formatFeedbackSelectionSummary(input: {
+    selectionMode: FeedbackSelectionMode
+    selectedFeedbacks: FeedbackEntry[]
+}): string {
+    return [
+        `Mode: ${describeFeedbackSelectionMode(input.selectionMode)}`,
+        `Selected suggestions: ${input.selectedFeedbacks.length}`,
+        `Selected IDs: ${input.selectedFeedbacks.length > 0 ? input.selectedFeedbacks.map(entry => `#${entry.number}`).join(', ') : '<none>'}`,
+        ...input.selectedFeedbacks.map(entry => `- ${formatFeedbackEntryLine(entry)}`),
+    ].join('\n')
+}
+
+export function formatFeedbackOutcomeSummary(input: {
+    commitHash: string
+    selectionMode: FeedbackSelectionMode
+    selectedFeedbacks: FeedbackEntry[]
+}): string {
+    return [
+        `Commit: ${input.commitHash}`,
+        `Mode: ${describeFeedbackSelectionMode(input.selectionMode)}`,
+        `Selected suggestions: ${input.selectedFeedbacks.length}`,
+        ...input.selectedFeedbacks.map(entry => `- ${formatFeedbackEntryLine(entry)}`),
+    ].join('\n')
+}
+
+export function buildClaudeFeedbackPrompt(input: {
+    repoRoot: string
+    organizationName: string
+    repository: string
+    commitHash: string
+    selectedFeedbacks: FeedbackEntry[]
+}): string {
+    const feedbackBlocks = input.selectedFeedbacks
+        .map(entry => [
+            `Feedback #${entry.number}`,
+            `Status: ${entry.feedback.status}`,
+            `Reason: ${entry.feedback.reason}`,
+            `Suggestion: ${entry.feedback.suggestion}`,
+        ].join('\n'))
+        .join('\n\n')
+
+    return [
+        'You are working inside a local git repository.',
+        '',
+        `Repository root: ${input.repoRoot}`,
+        `Repository: ${input.organizationName}/${input.repository}`,
+        `Feedback commit hash: ${input.commitHash}`,
+        '',
+        'Address the selected feedback suggestions below.',
+        '- Inspect the repository and make the code changes that best address the selected suggestions.',
+        '- Run relevant verification when practical and mention what you checked.',
+        '- If a suggestion should not be implemented as written, explain why in your final summary.',
+        '- Do not create a git commit or push changes unless explicitly asked.',
+        '',
+        'Selected feedback:',
+        feedbackBlocks,
+    ].join('\n')
+}
+
+function serializeFeedbackEntries(entries: FeedbackEntry[]): FeedbackRunResult['feedbacks'] {
+    return entries.map(entry => ({
+        id: entry.id,
+        number: entry.number,
+        status: entry.feedback.status,
+        reason: entry.feedback.reason,
+        suggestion: entry.feedback.suggestion,
+        actionable: entry.actionable,
+    }))
+}
+
+export function buildFeedbackNextActions(input: {
+    launchedClaude: boolean
+    actionableCount: number
+    emptyState: FeedbackEmptyState
+}): string[] {
+    if (!input.launchedClaude) {
+        if (input.emptyState === 'no_feedback') {
+            return ['Push a feedback-producing commit or choose another checkout, then rerun `tela feedback --list`.']
+        }
+
+        if (input.emptyState === 'informational_only') {
+            return [
+                'Review the informational feedback above for context.',
+                'Rerun `tela feedback --list` after a later push if you want a fresh snapshot.',
+            ]
+        }
+
+        return input.actionableCount > 0
+            ? ['Run `tela feedback --apply all` or `tela feedback --apply select` when you are ready to address suggestions.']
+            : ['No follow-up action is required for this commit.']
+    }
+
+    return [
+        'Review the local diff before committing the Claude changes.',
+        'Run `tela push` after the feedback-driven changes look correct.',
+        'Rerun `tela feedback --list` after the next push if you want another feedback snapshot.',
+    ]
+}
+
+export function hasActionableFeedback(entries: FeedbackEntry[]): boolean {
+    return entries.some(entry => entry.actionable)
+}
+
+export function buildFeedbackRunResult(input: {
+    data: FeedbackData
+    selectionMode: FeedbackSelectionMode
+    launchedClaude: boolean
+    selectedFeedbacks?: FeedbackEntry[]
+    diffStat?: string
+}): FeedbackRunResult {
+    const review = buildFeedbackReviewModel(input.data)
+    const selectedFeedbacks = input.selectedFeedbacks ?? []
+
+    return {
+        ok: true,
+        organizationName: input.data.organizationName,
+        repository: input.data.repository,
+        commitHash: input.data.commitHash,
+        summary: review.summary,
+        emptyState: review.emptyState,
+        selectionMode: input.selectionMode,
+        feedbacks: serializeFeedbackEntries(input.data.entries),
+        selectedIds: selectedFeedbacks.length > 0 ? selectedFeedbacks.map(entry => entry.id) : undefined,
+        launchedClaude: input.launchedClaude,
+        diffStat: input.diffStat,
+        nextActions: buildFeedbackNextActions({
+            launchedClaude: input.launchedClaude,
+            actionableCount: review.summary.actionableCount,
+            emptyState: review.emptyState,
+        }),
+    }
+}
+
+export async function loadFeedbackData(options: {
+    cwd?: string
+    config: TelaCliConfig
+    fetchRepositoryLookup?: typeof fetchRepositoryLookup
+    fetchCommitFeedback?: typeof fetchCommitFeedback
+    getOriginUrl?: typeof getOriginUrl
+    getHeadCommitHash?: typeof getHeadCommitHash
+}): Promise<FeedbackData> {
+    const repoRoot = options.cwd ?? process.cwd()
+    const fetchRepositoryLookupFn = options.fetchRepositoryLookup ?? fetchRepositoryLookup
+    const fetchCommitFeedbackFn = options.fetchCommitFeedback ?? fetchCommitFeedback
+    const getOriginUrlFn = options.getOriginUrl ?? getOriginUrl
+    const getHeadCommitHashFn = options.getHeadCommitHash ?? getHeadCommitHash
+
+    const derivedRepository = await resolveRepositoryName(repoRoot, getOriginUrlFn)
+    const repoDetails = await fetchRepositoryLookupFn(derivedRepository, options.config)
+    const commitHash = await getHeadCommitHashFn(repoRoot)
+    const feedbackResponse = await fetchCommitFeedbackFn(
+        repoDetails.organization.name,
+        repoDetails.agentRepo.repository,
+        commitHash,
+        options.config,
+    )
+
+    const entries = buildFeedbackEntries(feedbackResponse.feedbacks)
+    const actionableEntries = entries.filter(entry => entry.actionable)
+
+    return {
+        repoRoot,
+        organizationName: repoDetails.organization.name,
+        repository: repoDetails.agentRepo.repository,
+        commitHash: feedbackResponse.commitHash,
+        entries,
+        actionableEntries,
+    }
+}
+
+export async function launchFeedbackClaude(options: {
+    repoRoot: string
+    prompt: string
+    runInteractiveCommand?: typeof runInteractiveCommand
+}): Promise<void> {
+    const runInteractiveCommandFn = options.runInteractiveCommand ?? runInteractiveCommand
+
+    try {
+        await runInteractiveCommandFn(['claude', options.prompt], { cwd: options.repoRoot })
+    }
+    catch (error) {
+        if (error instanceof CommandError) {
+            const stdout = error.result.stdout.trim()
+            const stderr = error.result.stderr.trim()
+            throw createUserFacingError({
+                code: 'feedback_claude_failed',
+                summary: 'Claude exited before completing the feedback review.',
+                details: stderr || stdout || `Claude exited with code ${error.result.exitCode}.`,
+                fixes: ['Review the Claude session output above, then rerun `tela feedback` when you are ready.'],
+                evidence: [
+                    `Command: ${error.result.command.join(' ')}`,
+                    stdout ? `stdout: ${stdout}` : '',
+                    stderr ? `stderr: ${stderr}` : '',
+                ].filter(Boolean),
+                cause: error,
+            })
+        }
+
+        throw error
+    }
+}
+
+export async function runFeedbackCommand(options: RunFeedbackCommandOptions): Promise<FeedbackRunResult> {
+    const repoRoot = options.cwd ?? process.cwd()
+    const prompts = options.prompts
+    const ensureConfig = options.ensureConfigInteractive ?? ensureConfigInteractive
+    const fetchRepositoryLookupFn = options.fetchRepositoryLookup ?? fetchRepositoryLookup
+    const fetchCommitFeedbackFn = options.fetchCommitFeedback ?? fetchCommitFeedback
+    const getOriginUrlFn = options.getOriginUrl ?? getOriginUrl
+    const getHeadCommitHashFn = options.getHeadCommitHash ?? getHeadCommitHash
+    const getDiffStatAgainstHeadFn = options.getDiffStatAgainstHead ?? getDiffStatAgainstHead
+    const commandExistsFn = options.commandExists ?? commandExists
+    const runInteractiveCommandFn = options.runInteractiveCommand ?? runInteractiveCommand
+    const selectionMode = getFeedbackSelectionMode(options)
+
+    const config: TelaCliConfig = await ensureConfig({ prompts })
+    const data = await loadFeedbackData({
+        cwd: repoRoot,
+        config,
+        fetchRepositoryLookup: fetchRepositoryLookupFn,
+        fetchCommitFeedback: fetchCommitFeedbackFn,
+        getOriginUrl: getOriginUrlFn,
+        getHeadCommitHash: getHeadCommitHashFn,
+    })
+    const review = buildFeedbackReviewModel(data)
+    const feedbackEntries = data.entries
+    const actionableFeedbacks = data.actionableEntries
+
+    prompts.note(formatFeedbackSummary(review.summary, review.emptyState), 'Feedback summary')
+    prompts.note(formatFeedbackCatalog(feedbackEntries), 'Feedback catalog')
+
+    if (selectionMode === 'list' || review.emptyState !== 'none') {
+        return buildFeedbackRunResult({
+            data,
+            selectionMode,
+            launchedClaude: false,
+        })
+    }
+
+    if (!await commandExistsFn('claude')) {
+        throw createUserFacingError({
+            code: 'feedback_claude_missing',
+            summary: 'Claude CLI is not available on PATH.',
+            fixes: ['Install the Claude CLI before using `tela feedback --apply ...`.'],
+        })
+    }
+
+    let selectedFeedbacks = selectionMode === 'select' ? [] : actionableFeedbacks
+    if (selectionMode === 'select') {
+        const selectedIds = await prompts.groupMultiselect({
+            message: 'Select the suggestions to address with Claude',
+            options: buildFeedbackSelectionGroups(feedbackEntries),
+            cursorAt: actionableFeedbacks[0]?.id,
+        })
+
+        if (prompts.isCancel(selectedIds)) {
+            prompts.cancel('Feedback selection cancelled.')
+            return buildFeedbackRunResult({
+                data,
+                selectionMode,
+                launchedClaude: false,
+            })
+        }
+
+        const selectedIdSet = new Set(promptValue(selectedIds))
+        selectedFeedbacks = actionableFeedbacks.filter(entry => selectedIdSet.has(entry.id))
+    }
+    else if (selectionMode === 'default') {
+        const selectionChoice = await prompts.select<'all' | 'manual' | 'cancel'>({
+            message: 'Which suggestions do you want to review with Claude?',
+            options: [
+                { value: 'all', label: 'Apply all actionable suggestions' },
+                { value: 'manual', label: 'Choose suggestions individually' },
+                { value: 'cancel', label: 'Finish review without launching Claude' },
+            ],
+            initialValue: 'all',
+        })
+
+        if (prompts.isCancel(selectionChoice) || promptValue(selectionChoice) === 'cancel') {
+            prompts.cancel('Feedback application cancelled.')
+            return buildFeedbackRunResult({
+                data,
+                selectionMode,
+                launchedClaude: false,
+            })
+        }
+
+        if (promptValue(selectionChoice) === 'manual') {
+            const selectedIds = await prompts.groupMultiselect({
+                message: 'Select the suggestions to address with Claude',
+                options: buildFeedbackSelectionGroups(feedbackEntries),
+                cursorAt: actionableFeedbacks[0]?.id,
+            })
+
+            if (prompts.isCancel(selectedIds)) {
+                prompts.cancel('Feedback selection cancelled.')
+                return buildFeedbackRunResult({
+                    data,
+                    selectionMode,
+                    launchedClaude: false,
+                })
+            }
+
+            const selectedIdSet = new Set(promptValue(selectedIds))
+            selectedFeedbacks = actionableFeedbacks.filter(entry => selectedIdSet.has(entry.id))
+        }
+    }
+
+    prompts.note(formatFeedbackSelectionSummary({
+        selectionMode,
+        selectedFeedbacks,
+    }), 'Selection summary')
+
+    if (selectedFeedbacks.length === 0) {
+        prompts.cancel('Feedback review finished without launching Claude.')
+        return buildFeedbackRunResult({
+            data,
+            selectionMode,
+            launchedClaude: false,
+        })
+    }
+
+    const prompt = buildClaudeFeedbackPrompt({
+        repoRoot: data.repoRoot,
+        organizationName: data.organizationName,
+        repository: data.repository,
+        commitHash: data.commitHash,
+        selectedFeedbacks,
+    })
+
+    prompts.note(prompt, 'Claude task')
+
+    if (selectionMode === 'default') {
+        const confirmation = await prompts.confirm({
+            message: `Launch Claude to address ${selectedFeedbacks.length} suggestion${selectedFeedbacks.length === 1 ? '' : 's'}?`,
+            active: 'apply',
+            inactive: 'cancel',
+            initialValue: true,
+        })
+
+        if (prompts.isCancel(confirmation) || !promptValue(confirmation)) {
+            prompts.cancel('Feedback application cancelled.')
+            return buildFeedbackRunResult({
+                data,
+                selectionMode,
+                launchedClaude: false,
+                selectedFeedbacks,
+            })
+        }
+    }
+
+    await launchFeedbackClaude({
+        repoRoot: data.repoRoot,
+        prompt,
+        runInteractiveCommand: runInteractiveCommandFn,
+    })
+
+    const diffStat = (await getDiffStatAgainstHeadFn(repoRoot)) || '<no local diff detected>'
+    prompts.note(formatFeedbackOutcomeSummary({
+        commitHash: data.commitHash,
+        selectionMode,
+        selectedFeedbacks,
+    }), 'Review outcome')
+    prompts.note(diffStat, 'Local diff summary')
+    prompts.log.success(`Claude finished reviewing ${selectedFeedbacks.length} suggestion${selectedFeedbacks.length === 1 ? '' : 's'}`)
+
+    return buildFeedbackRunResult({
+        data,
+        selectionMode,
+        launchedClaude: true,
+        selectedFeedbacks,
+        diffStat,
+    })
+}