@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/tasks/issue-triage/fix-attempt.js

@@ -0,0 +1,617 @@
+import { execFileSync } from 'child_process';
+import { writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { sampleAutofixResources, summarizeAutofixResources } from '../../core/autofix-resources.js';
+import { AUTOFIX_RUNTIME_ENV, hashAutofixInputs, isCurrentCheck, readVerificationState, saveVerificationState, selectCheckResult, } from '../../core/autofix-verification.js';
+import { logger } from '../../core/logging.js';
+import { fillPromptTemplate, loadPromptTemplateFile, resolvePromptFile, } from '../../core/prompt-template.js';
+import { recordEvent } from '../../core/tracing.js';
+import { resolveAutofixCapabilityEnv } from './autofix-capabilities.js';
+import { AutofixCheckpointStore, checkpointIdentity } from './autofix-checkpoint.js';
+import { describeAutofixPolicy, loadAutofixPolicy } from './autofix-policy.js';
+import { validateDiff } from './diff-validator.js';
+import { CODEX_CANNOT_FIX_REASON, FIX_LOOP_FAILED_REASON_PREFIX } from './fix-failure-reasons.js';
+import { AUTOFIX_FAILURE_MARKER, FIX_LOOP_START_MARKER } from './markers.js';
+import { invokeTriageModel } from './model.js';
+import { findPRTemplate, RECORDED_CHECKS_HEADING } from './pr-creator.js';
+import { describeWorkflow, loadRepositoryWorkflow, serializeAutofixPolicy } from './repo-prompts.js';
+import { describeSandboxEnvironment, sandboxEnvironmentError } from './sandbox-environment.js';
+const FIX_PROMPT_FILE = 'issue-triage-fix-prompt.md';
+// Maximum time allowed for the Codex fix-generation invocation before we abort
+const AUTO_FIX_CODEX_TIMEOUT_MS = 140 * 60 * 1000;
+const CANNOT_FIX_MARKER = '## Cannot Fix';
+export function shouldAttemptFix(assessment) {
+    return (assessment.classification === 'logs-needed' ||
+        (assessment.classification === 'auto-fixable' && assessment.confidence === 'high'));
+}
+export function buildFixAssessmentSkipReason(assessment) {
+    return `Assessment: ${assessment.classification} (confidence: ${assessment.confidence})`;
+}
+function loadFixPromptTemplate() {
+    return loadPromptTemplateFile({
+        fileName: resolvePromptFile(import.meta.url, FIX_PROMPT_FILE),
+        promptLabel: 'issue triage fix',
+    });
+}
+function buildPRTemplateSection(prTemplate) {
+    return [
+        '### PR Body',
+        '',
+        'The target repository uses the following pull request template:',
+        '',
+        '<template>',
+        prTemplate,
+        '</template>',
+        '',
+        'After the Changes Made and Verification sections, output a `## PR Body` section containing a',
+        'filled-in version of this template. Replace placeholder text with details about your changes. For',
+        "checkbox items, check the ones that apply. Keep the template's structure intact.",
+        '',
+        'Reference the source issue with its full URL because the PR may be in another repository.',
+        'For logging work, use "Related to" instead of closing keywords such as "Fixes" or "Closes",',
+        'including when the repository template contains a closing keyword. Logging does not fix the issue.',
+    ].join('\n');
+}
+export function parsePRTitleFromOutput(output) {
+    const headingPattern = /^## PR Title\s*$/m;
+    const headingMatch = output.match(headingPattern);
+    if (headingMatch?.index === undefined) {
+        return null;
+    }
+    const afterHeading = output.slice(headingMatch.index + headingMatch[0].length);
+    const nextHeadingIdx = afterHeading.search(/^##\s/m);
+    const section = nextHeadingIdx >= 0 ? afterHeading.slice(0, nextHeadingIdx) : afterHeading;
+    const title = section.trim().split('\n')[0]?.trim() ?? null;
+    return title || null;
+}
+export function stripPRTitleSection(output) {
+    const headingPattern = /^## PR Title\s*$/m;
+    const headingMatch = output.match(headingPattern);
+    if (headingMatch?.index === undefined) {
+        return output;
+    }
+    const before = output.slice(0, headingMatch.index);
+    const afterHeading = output.slice(headingMatch.index + headingMatch[0].length);
+    const nextHeadingIdx = afterHeading.search(/^##\s/m);
+    const after = nextHeadingIdx >= 0 ? afterHeading.slice(nextHeadingIdx) : '';
+    return (before + after).replace(/\n{3,}/g, '\n\n').trim();
+}
+export function parsePRBodyFromOutput(output) {
+    const marker = '## PR Body';
+    const startIdx = output.indexOf(marker);
+    if (startIdx === -1) {
+        return null;
+    }
+    const trimmed = output.slice(startIdx + marker.length).trim();
+    return trimmed || null;
+}
+function buildFixPrompt({ triageOutput, fixAssessment, issueUrl, targetRepo, prTemplate, workflow, }) {
+    const template = loadFixPromptTemplate();
+    return (fillPromptTemplate(template, {
+        IMPLEMENTATION_WORKFLOW: describeWorkflow(workflow, 'autofix-workflow.md'),
+        REPO_FULL: targetRepo.repository.fullName,
+        ISSUE_URL: issueUrl,
+        TRIAGE_ANALYSIS: triageOutput,
+        FIX_SCOPE: fixAssessment.scope,
+        FIX_CLASSIFICATION: fixAssessment.classification,
+        LOGGING_PLAN_CHECK: fixAssessment.classification === 'logs-needed'
+            ? loadPromptTemplateFile({
+                fileName: resolvePromptFile(import.meta.url, 'logging-plan-check.md'),
+                promptLabel: 'logging plan check',
+            })
+            : '',
+        TARGET_REPO_ROOT: targetRepo.localPath,
+        PR_TEMPLATE_SECTION: prTemplate ? buildPRTemplateSection(prTemplate) : '',
+    }) + describeSandboxEnvironment());
+}
+function formatPreviousFinding(finding) {
+    const tag = finding.severity ? `[${finding.severity}] ` : '';
+    const body = finding.body.trim().replace(/\s+/g, ' ');
+    return `- ${tag}${finding.path}:${finding.line}: ${body}`;
+}
+export function buildPreviousFindingsSection(findings) {
+    return [
+        '# Previous Review Findings',
+        '',
+        'A prior fix attempt for this issue was reviewed and the following issues were',
+        'flagged. Address each finding in your new fix attempt before producing the diff:',
+        '',
+        ...findings.map(formatPreviousFinding),
+        '',
+        '---',
+        '',
+    ].join('\n');
+}
+export function buildFixPromptWithFindings(input) {
+    const basePrompt = buildFixPrompt(input);
+    if (!input.previousFindings || input.previousFindings.length === 0) {
+        return basePrompt;
+    }
+    return buildPreviousFindingsSection(input.previousFindings) + basePrompt;
+}
+function captureGitDiff(repoLocalPath) {
+    try {
+        // Stage all changes (including new untracked files) so they appear in the diff
+        // and flow through validation before being committed.
+        execFileSync('git', ['add', '-A'], {
+            cwd: repoLocalPath,
+            encoding: 'utf8',
+            stdio: 'pipe',
+        });
+        return execFileSync('git', [
+            'diff',
+            '--no-ext-diff',
+            '--no-textconv',
+            '--full-index',
+            '--cached',
+            'HEAD',
+            '--binary',
+        ], {
+            cwd: repoLocalPath,
+            encoding: 'utf8',
+            maxBuffer: 5 * 1024 * 1024,
+        });
+    }
+    catch (error) {
+        logger.error('Failed to capture git diff', {
+            task: 'issue-triage',
+            repoLocalPath,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return '';
+    }
+}
+// Detect the "## Cannot Fix" verdict and pull Codex's own explanation in one pass,
+// so the failure comment can tell the human *why* it bailed, not just that it did.
+// Returns null when the marker is absent (not a cannot-fix verdict), the explanation
+// string when present, or '' when the model gave the verdict with no explanation.
+// The full tail is intentional — the prompt makes "## Cannot Fix" the terminal output.
+// ponytail: 2000-char cap keeps the comment readable; raise it if reasons get truncated.
+export function extractCannotFixDetail(output) {
+    const idx = output.indexOf(CANNOT_FIX_MARKER);
+    if (idx === -1)
+        return null;
+    return output
+        .slice(idx + CANNOT_FIX_MARKER.length)
+        .trim()
+        .slice(0, 2000);
+}
+async function findSourceIssueCommentByMarker({ octokit, ctx, marker, }) {
+    const comments = await octokit.paginate(octokit.rest.issues.listComments, {
+        owner: ctx.owner,
+        repo: ctx.repo,
+        issue_number: ctx.issueNumber,
+        per_page: 100,
+    });
+    return comments.find((c) => typeof c.body === 'string' && c.body.includes(marker));
+}
+export async function shouldPostAutoFixFailureComment(fixResult, { dryRun, octokit, ctx }) {
+    if (dryRun)
+        return false;
+    if (!fixResult.attempted)
+        return false;
+    if (fixResult.prCreated)
+        return false;
+    // A PR opened during the loop is already announced via FIX_LOOP_START_MARKER;
+    // a "didn't produce a fix PR" comment would be misleading.
+    if (fixResult.interruption || fixResult.recoveryRefused)
+        return true;
+    if (fixResult.prNumber !== undefined)
+        return false;
+    if (fixResult.reason.startsWith(FIX_LOOP_FAILED_REASON_PREFIX)) {
+        try {
+            const hasFixLoopStartComment = await sourceIssueHasFixLoopStartComment({ octokit, ctx });
+            if (hasFixLoopStartComment) {
+                logger.info('Auto-fix failure comment skipped', {
+                    task: 'issue-triage',
+                    issue_number: ctx.issueNumber,
+                    reason: 'fix-loop start comment exists',
+                });
+                return false;
+            }
+        }
+        catch (error) {
+            logger.warn('Failed to check fix-loop start comment', {
+                task: 'issue-triage',
+                issue_number: ctx.issueNumber,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
+    return true;
+}
+export async function sourceIssueHasFixLoopStartComment({ octokit, ctx, }) {
+    const comment = await findSourceIssueCommentByMarker({
+        octokit,
+        ctx,
+        marker: FIX_LOOP_START_MARKER,
+    });
+    return comment !== undefined;
+}
+export function buildAutoFixFailureCommentBody({ reason, targetRepoFullName, prNumber, interruption, }) {
+    const repoNote = targetRepoFullName ? ` in \`${targetRepoFullName}\`` : '';
+    return [
+        AUTOFIX_FAILURE_MARKER,
+        '',
+        '### Automated fix attempt failed',
+        '',
+        prNumber
+            ? `The fix stopped${repoNote}. PR #${prNumber} keeps the changes already pushed.`
+            : `The fix stopped before a PR was opened${repoNote}.`,
+        '',
+        '**Reason:**',
+        '',
+        // Tilde fence, not backticks: the reason often carries Codex's own
+        // backtick-fenced output (logs, CLI), which would close a ``` block early.
+        '~~~',
+        reason,
+        '~~~',
+        '',
+        ...(interruption ? [buildRecoveryNotice(interruption), ''] : []),
+        'You can retry with `@doistbot /fix` or `@doistbot /retry`.',
+    ].join('\n');
+}
+export function buildRecoveryNotice(interruption) {
+    const work = interruption.stage === 'review'
+        ? 'The PR and review step are saved'
+        : 'The patch, check results, and loop step are saved';
+    return interruption.saved
+        ? `${work} in shared storage. Retry will continue from the last saved checkpoint if the report, check policy, and repository state still match. It will not start the fix again.`
+        : 'I could not confirm a save of the latest work in shared storage. A retry may need to start a fresh attempt.';
+}
+export async function postAutoFixFailureComment({ octokit, ctx, reason, targetRepoFullName, prNumber, interruption, }) {
+    const body = buildAutoFixFailureCommentBody({
+        reason,
+        targetRepoFullName,
+        prNumber,
+        interruption,
+    });
+    const existing = await findSourceIssueCommentByMarker({
+        octokit,
+        ctx,
+        marker: AUTOFIX_FAILURE_MARKER,
+    });
+    if (existing) {
+        await octokit.rest.issues.updateComment({
+            owner: ctx.owner,
+            repo: ctx.repo,
+            comment_id: existing.id,
+            body,
+        });
+    }
+    else {
+        await octokit.rest.issues.createComment({
+            owner: ctx.owner,
+            repo: ctx.repo,
+            issue_number: ctx.issueNumber,
+            body,
+        });
+    }
+    logger.info('Auto-fix failure comment posted', {
+        task: 'issue-triage',
+        issue_number: ctx.issueNumber,
+        target_repo: targetRepoFullName,
+        operation: existing ? 'update' : 'create',
+    });
+}
+export async function runFixCore(input) {
+    const attemptStartedAt = Date.now();
+    const { ctx, triageOutput, fixAssessment, targetRepo, resetTo = 'HEAD' } = input;
+    if (!input.force && !shouldAttemptFix(fixAssessment)) {
+        logger.info('Fix core skipped: assessment does not qualify', {
+            task: 'issue-triage',
+            issue_number: ctx.issueNumber,
+            classification: fixAssessment.classification,
+            confidence: fixAssessment.confidence,
+        });
+        return {
+            ok: false,
+            reason: buildFixAssessmentSkipReason(fixAssessment),
+        };
+    }
+    const environmentError = sandboxEnvironmentError(targetRepo.repository.fullName);
+    if (environmentError)
+        return { ok: false, reason: environmentError };
+    const capabilityEnvResult = resolveAutofixCapabilityEnv(targetRepo.repository.fullName);
+    if (!capabilityEnvResult.ok) {
+        return capabilityEnvResult;
+    }
+    let policy;
+    let baseCommit;
+    let store;
+    let verification = { roundsUsed: 0, results: [] };
+    let restoredPatch = '';
+    let identity;
+    let workflow;
+    try {
+        policy = loadAutofixPolicy(targetRepo.localPath);
+        workflow = loadRepositoryWorkflow(targetRepo.localPath, 'autofix');
+        baseCommit = execFileSync('git', ['rev-parse', resetTo], {
+            cwd: targetRepo.localPath,
+            encoding: 'utf8',
+            stdio: 'pipe',
+        }).trim();
+        identity = checkpointIdentity({
+            issueUrl: input.issueUrl,
+            repository: targetRepo.repository.fullName,
+            baseCommit,
+            triageOutput,
+            policy: serializeAutofixPolicy(policy, workflow),
+        });
+        store = new AutofixCheckpointStore(identity, 
+        // Sentry persists through IssueFixRecovery, under its short-lived prefix.
+        ctx.dryRun || ctx.sentryIssue ? undefined : process.env.LOG_SNAPSHOT_BUCKET);
+        if (input.checkpoint) {
+            const checkpoint = input.checkpoint;
+            if (checkpoint && checkpoint.baseCommit !== baseCommit)
+                throw new Error('Saved patch base does not match the fix attempt');
+            if (checkpoint) {
+                if (checkpoint.patch &&
+                    !validateDiff(checkpoint.patch, {
+                        forbiddenTestPaths: policy.forbidden_test_paths,
+                    }).valid) {
+                    throw new Error('Saved patch does not meet the current autofix rules');
+                }
+                restoredPatch = checkpoint.patch;
+                verification = checkpoint.verification;
+            }
+        }
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: `Could not prepare autofix policy or checkpoint: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    // Reset repo to clean state before fix attempt (triage Codex may have modified files).
+    // Use `git reset --hard` to clear both the working tree and the index, since
+    // captureGitDiff stages files with `git add -A`.
+    try {
+        execFileSync('git', ['reset', '--hard', resetTo], {
+            cwd: targetRepo.localPath,
+            encoding: 'utf8',
+            stdio: 'pipe',
+        });
+        execFileSync('git', ['clean', '-fd'], {
+            cwd: targetRepo.localPath,
+            encoding: 'utf8',
+            stdio: 'pipe',
+        });
+        if (restoredPatch) {
+            execFileSync('git', ['apply', '--index', '--whitespace=nowarn', '-'], {
+                cwd: targetRepo.localPath,
+                input: restoredPatch,
+                encoding: 'utf8',
+                stdio: 'pipe',
+            });
+            logger.info('Autofix checkpoint restored', {
+                baseCommit,
+                roundsUsed: verification.roundsUsed,
+            });
+        }
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        logger.warn('Failed to reset repo state before fix attempt', {
+            task: 'issue-triage',
+            issueNumber: ctx.issueNumber,
+            targetRepo: targetRepo.repository.fullName,
+            error: reason,
+        });
+        return {
+            ok: false,
+            reason: `Failed to reset repository state before fix attempt: ${reason}`,
+        };
+    }
+    const prTemplate = findPRTemplate(targetRepo.localPath);
+    if (prTemplate) {
+        logger.info('PR template found for fix attempt', {
+            task: 'issue-triage',
+            issueNumber: ctx.issueNumber,
+            targetRepo: targetRepo.repository.fullName,
+            templateChars: prTemplate.length,
+        });
+    }
+    // Run Codex to generate the fix
+    const prompt = buildFixPromptWithFindings({
+        triageOutput,
+        fixAssessment,
+        issueUrl: input.issueUrl,
+        targetRepo,
+        prTemplate,
+        previousFindings: input.previousFindings,
+        workflow,
+    }) +
+        describeAutofixPolicy(policy) +
+        (restoredPatch
+            ? `\n## Resumed fix\nThe saved patch is already applied. Continue this fix. Do not start over. ${verification.roundsUsed} verification rounds were used. Saved results follow. Passed checks apply only to the same source inputs.\n${JSON.stringify({ ...verification, results: verification.results.map((result) => ({ ...result, output: result.output.slice(-2000) })) })}\n`
+            : '');
+    const timeoutMs = Math.max(1, AUTO_FIX_CODEX_TIMEOUT_MS - (Date.now() - attemptStartedAt));
+    const statePath = path.join(store.directory, 'verification.json');
+    const runtimePath = path.join(store.directory, 'runtime.json');
+    saveVerificationState(statePath, verification);
+    const runtime = {
+        repoPath: targetRepo.localPath,
+        statePath,
+        policy,
+        deadlineMs: attemptStartedAt + AUTO_FIX_CODEX_TIMEOUT_MS - 2000,
+    };
+    writeFileSync(runtimePath, JSON.stringify(runtime), { mode: 0o600 });
+    const samples = [];
+    function sample() {
+        const resource = sampleAutofixResources(Date.now() - attemptStartedAt);
+        samples.push(resource);
+        recordEvent('autofix.resources', {
+            'autofix.elapsed_ms': resource.elapsedMs,
+            'autofix.cpu_seconds': resource.cpuSeconds,
+            'autofix.memory_bytes': resource.memoryBytes,
+            'autofix.memory_limit_bytes': resource.memoryLimitBytes,
+            'autofix.oom_kills': resource.oomKills,
+        });
+    }
+    sample();
+    const sampler = setInterval(sample, 10_000);
+    const codexResult = await invokeTriageModel({
+        // Distinct phase name: this is fix generation, not triage analysis.
+        // Callers (e.g. issue-fix-retry) override to keep it in their namespace.
+        phaseName: input.modelPhaseName ?? 'triage.fix-attempt.model',
+        prompt,
+        apiKey: ctx.openaiApiKey,
+        cwd: targetRepo.localPath,
+        thinkingLevel: 'max',
+        timeoutMs,
+        capabilityPreset: 'autofix',
+        extraEnv: {
+            GH_TOKEN: input.ghToken,
+            ...capabilityEnvResult.env,
+            [AUTOFIX_RUNTIME_ENV]: runtimePath,
+        },
+    })
+        .catch((error) => ({
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+        durationMs: Date.now() - attemptStartedAt,
+        timedOut: Date.now() >= runtime.deadlineMs,
+    }))
+        .finally(() => clearInterval(sampler));
+    sample();
+    verification = readVerificationState(statePath);
+    for (const result of verification.results) {
+        if (result.status === 'running') {
+            result.durationMs = Date.now() - result.startedAtMs;
+            if (result.buildStartedAtMs !== null)
+                result.buildDurationMs = Date.now() - result.buildStartedAtMs;
+            result.timedOut = !codexResult.ok && codexResult.timedOut;
+        }
+    }
+    const diff = captureGitDiff(targetRepo.localPath);
+    const resourceSummary = summarizeAutofixResources(samples);
+    const finalFingerprint = hashAutofixInputs(diff);
+    function checkStatus(result, check) {
+        if (!result)
+            return 'not-run';
+        if (!isCurrentCheck(result, check, finalFingerprint, verification))
+            return 'stale';
+        if (result.status !== 'finished')
+            return 'incomplete';
+        return result.exitCode === 0 && !result.timedOut ? 'passed' : 'failed';
+    }
+    const finalChecks = policy.verification.checks.map((check) => {
+        const result = selectCheckResult(verification, check, finalFingerprint);
+        return {
+            name: check.name,
+            command: check.command,
+            testSelectors: result?.testSelectors ?? [],
+            status: checkStatus(result, check),
+        };
+    });
+    let failureReason;
+    if (codexResult.ok) {
+        const cannotFixDetail = extractCannotFixDetail(codexResult.output);
+        if (cannotFixDetail !== null) {
+            failureReason = cannotFixDetail
+                ? `${CODEX_CANNOT_FIX_REASON}\n\n${cannotFixDetail}`
+                : CODEX_CANNOT_FIX_REASON;
+        }
+        else if (!diff.trim()) {
+            failureReason = 'Codex produced no file changes.';
+        }
+        else {
+            const validation = validateDiff(diff, {
+                forbiddenTestPaths: policy.forbidden_test_paths,
+            });
+            if (!validation.valid)
+                failureReason = `Diff validation failed: ${validation.reason}`;
+        }
+    }
+    const status = !codexResult.ok && codexResult.timedOut
+        ? 'timed-out'
+        : !codexResult.ok || failureReason
+            ? 'failed'
+            : 'completed';
+    const saved = await (input.saveCheckpoint ?? store.save.bind(store))({
+        version: 1,
+        identity,
+        baseCommit,
+        patch: diff,
+        verification,
+        status,
+        savedAt: new Date().toISOString(),
+    }, JSON.stringify({
+        status,
+        baseCommit,
+        durationMs: Date.now() - attemptStartedAt,
+        verification,
+        finalChecks,
+        modelWaitMs: codexResult.telemetry?.nonToolDurationMs ?? null,
+        modelWaitDefinition: 'Elapsed invocation time outside tool calls, including model and transport wait.',
+        resources: resourceSummary,
+        samples,
+    }));
+    recordEvent('autofix.summary', {
+        'autofix.status': status,
+        'autofix.duration_ms': Date.now() - attemptStartedAt,
+        'autofix.rounds_used': verification.roundsUsed,
+        'autofix.model_wait_ms': codexResult.telemetry?.nonToolDurationMs ?? null,
+        'autofix.sampled_peak_memory_bytes': resourceSummary.sampledPeakMemoryBytes,
+        'autofix.memory_limit_bytes': resourceSummary.memoryLimitBytes,
+        'autofix.cpu_seconds': resourceSummary.cpuSeconds,
+        'autofix.peak_cpu_cores': resourceSummary.peakCpuCores,
+        'autofix.oom_kills': resourceSummary.oomKills,
+    });
+    if (!codexResult.ok) {
+        logger.warn('Fix attempt invocation failed', {
+            task: 'issue-triage',
+            issueNumber: ctx.issueNumber,
+            error: codexResult.error,
+            timedOut: codexResult.timedOut,
+            durationMs: codexResult.durationMs,
+        });
+        return {
+            ok: false,
+            reason: `Fix attempt failed: ${codexResult.error}`,
+            ...(codexResult.timedOut ? { interruption: { stage: 'fix', saved } } : {}),
+        };
+    }
+    const fixDescription = codexResult.output;
+    logger.info('Fix Codex invocation completed', {
+        task: 'issue-triage',
+        issueNumber: ctx.issueNumber,
+        durationMs: codexResult.durationMs,
+        outputChars: fixDescription.length,
+    });
+    if (failureReason)
+        return { ok: false, reason: failureReason };
+    const generatedPRTitle = parsePRTitleFromOutput(fixDescription) ??
+        (fixAssessment.classification === 'logs-needed' ? 'chore: add diagnostics' : null);
+    if (generatedPRTitle) {
+        logger.info('Parsed PR title from Codex output', {
+            task: 'issue-triage',
+            issueNumber: ctx.issueNumber,
+            generatedPRTitle,
+        });
+    }
+    const checkSummary = finalChecks.length
+        ? `\n\n${RECORDED_CHECKS_HEADING}\n\n` +
+            finalChecks
+                .map((check) => `- ${check.name}: ${check.status}. Command: \`${check.command}\`.${check.testSelectors.length ? ` Test selectors: ${check.testSelectors.join(', ')}.` : ''}`)
+                .join('\n')
+        : '';
+    const parsedPRBody = parsePRBodyFromOutput(fixDescription);
+    const generatedPRBody = parsedPRBody ? parsedPRBody + checkSummary : null;
+    if (generatedPRBody) {
+        logger.info('Parsed PR body from Codex output', {
+            task: 'issue-triage',
+            issueNumber: ctx.issueNumber,
+            prBodyChars: generatedPRBody.length,
+        });
+    }
+    return {
+        ok: true,
+        codexOutput: fixDescription + checkSummary,
+        diff,
+        generatedPRTitle,
+        generatedPRBody,
+    };
+}

package/sandbox/dist/tasks/issue-triage/fix-context.js

@@ -0,0 +1,5 @@
+export function fixSource(source) {
+    return source.sentryIssue
+        ? { sentryIssue: source.sentryIssue }
+        : { issueNumber: source.issueNumber };
+}