@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/tasks/issue-triage/pr-creator.js

@@ -0,0 +1,585 @@
+import { execFileSync } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { DOISTBOT_AUTO_FIX_LABEL, DOISTBOT_SPECULATIVE_FIX_LABEL } from 'doistbot-shared-contracts';
+import { gitAuthEnv } from '../../core/git-auth.js';
+import { logger } from '../../core/logging.js';
+import { fillPromptTemplate, loadPromptTemplateFile, resolvePromptFile, } from '../../core/prompt-template.js';
+import { escapeRegExp } from '../../core/regexp.js';
+import { withRetry } from '../../core/retry.js';
+import { requestAssigneeReview } from './assignee-review.js';
+import { GITHUB_REQUEST_TIMEOUT_MS } from './github-request.js';
+import { markPullRequestReady } from './pr-readiness.js';
+const PR_TEMPLATE_PATHS = [
+    '.github/pull_request_template.md',
+    '.github/PULL_REQUEST_TEMPLATE.md',
+    'pull_request_template.md',
+    'PULL_REQUEST_TEMPLATE.md',
+    'docs/pull_request_template.md',
+];
+const GIT_PUSH_TIMEOUT_MS = 2 * 60 * 1000;
+const MAX_FIX_PR_BODY_CHARS = 60_000;
+export const RECORDED_CHECKS_HEADING = '## Recorded autofix checks';
+const REFERENCE_HEADING_PATTERN = /^#{1,6}\s+(?:\S+\s+)?references?\s*:?\s*$/i;
+export function findPRTemplate(repoLocalPath) {
+    for (const templatePath of PR_TEMPLATE_PATHS) {
+        const fullPath = path.join(repoLocalPath, templatePath);
+        try {
+            const content = fs.readFileSync(fullPath, 'utf8').trim();
+            if (content) {
+                logger.info('Found PR template', {
+                    task: 'issue-triage',
+                    templatePath,
+                    repoLocalPath,
+                    contentChars: content.length,
+                });
+                return content;
+            }
+        }
+        catch {
+            // File doesn't exist at this path, try next
+        }
+    }
+    return null;
+}
+// TODO: extract into a shared module consumed by both `apps/sandbox` and
+// `apps/webhook-handler`. The webhook handler hardcodes the same prefix in
+// `apps/webhook-handler/src/tasks/promotion-ci-gate/index.ts`
+// (`DOISTBOT_BRANCH_PREFIX`) to fast-path filter `check_suite.completed`
+// events before any API call. If this value changes, update both sites.
+const DOISTBOT_BRANCH_PREFIX = 'doistbot/';
+export function generateBranchName(source) {
+    const timestamp = Date.now();
+    const { issueNumber, sentryIssue } = source;
+    const identity = sentryIssue
+        ? `sentry-${sentryIssue.product.toLowerCase()}-${sentryIssue.routeId}-${sentryIssue.organization}-${sentryIssue.projectId}-${sentryIssue.issueId}`
+        : `issue-${issueNumber}`;
+    return `${DOISTBOT_BRANCH_PREFIX}auto-fix/${identity}-${timestamp}`;
+}
+export async function resolveInstallationIdForRepo({ app, owner, repo, fallbackInstallationId, }) {
+    try {
+        const { data } = await app.octokit.request('GET /repos/{owner}/{repo}/installation', {
+            owner,
+            repo,
+        });
+        if (typeof data.id === 'number' && Number.isInteger(data.id) && data.id > 0) {
+            return data.id;
+        }
+    }
+    catch (error) {
+        logger.warn('Failed to resolve installation for target repository; using fallback', {
+            task: 'issue-triage',
+            repository: `${owner}/${repo}`,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    return fallbackInstallationId;
+}
+const GIT_IDENTITY_ENV = {
+    GIT_AUTHOR_NAME: 'Doistbot',
+    GIT_AUTHOR_EMAIL: '37183429+doistbot@users.noreply.github.com',
+    GIT_COMMITTER_NAME: 'Doistbot',
+    GIT_COMMITTER_EMAIL: '37183429+doistbot@users.noreply.github.com',
+};
+function pushBranch({ repoLocalPath, branch, token, owner, repo, }) {
+    const remoteUrl = `https://github.com/${owner}/${repo}.git`;
+    execFileSync('git', ['-c', 'core.hooksPath=/dev/null', 'push', remoteUrl, branch], {
+        cwd: repoLocalPath,
+        encoding: 'utf8',
+        stdio: 'pipe',
+        timeout: GIT_PUSH_TIMEOUT_MS,
+        env: gitAuthEnv(token),
+    });
+}
+export function commitStagedChanges({ repoLocalPath, checkoutArgs, commitMessage, signingKey, }) {
+    const env = { ...process.env, ...GIT_IDENTITY_ENV };
+    delete env.GIT_SSH_SIGNING_KEY;
+    const execOptions = {
+        cwd: repoLocalPath,
+        encoding: 'utf8',
+        stdio: 'pipe',
+        env,
+    };
+    execFileSync('git', checkoutArgs, execOptions);
+    const signingDir = signingKey
+        ? fs.mkdtempSync(path.join(os.tmpdir(), 'doistbot-signing-'))
+        : undefined;
+    try {
+        const signingArgs = [];
+        if (signingDir && signingKey) {
+            const keyPath = path.join(signingDir, 'key');
+            fs.writeFileSync(keyPath, `${signingKey.trim()}\n`, { mode: 0o600 });
+            signingArgs.push('-c', 'gpg.format=ssh', '-c', `user.signingkey=${keyPath}`, '-c', 'gpg.ssh.program=/usr/bin/ssh-keygen');
+        }
+        // Files are already staged by captureGitDiff in fix-attempt.ts.
+        execFileSync('git', [
+            '-c',
+            'core.hooksPath=/dev/null',
+            ...signingArgs,
+            'commit',
+            signingDir ? '-S' : '--no-gpg-sign',
+            '-m',
+            commitMessage,
+        ], execOptions);
+    }
+    finally {
+        if (signingDir)
+            fs.rmSync(signingDir, { recursive: true, force: true });
+    }
+    return execFileSync('git', ['rev-parse', 'HEAD'], execOptions).trim();
+}
+async function commitAndPushBranch({ branch, githubToken, repoOwner, repoName, octokit, ...commit }) {
+    const signingKey = process.env.GIT_SSH_SIGNING_KEY?.trim();
+    if (!signingKey) {
+        throw new Error('GIT_SSH_SIGNING_KEY is required to publish Doistbot commits.');
+    }
+    const headSha = commitStagedChanges({ ...commit, signingKey });
+    pushBranch({
+        repoLocalPath: commit.repoLocalPath,
+        branch,
+        token: githubToken,
+        owner: repoOwner,
+        repo: repoName,
+    });
+    await verifyCommitSignature({ octokit, repoOwner, repoName, headSha });
+    return headSha;
+}
+export async function verifyCommitSignature({ octokit, repoOwner, repoName, headSha, }) {
+    const { data } = await withRetry(() => octokit.rest.repos.getCommit({
+        owner: repoOwner,
+        repo: repoName,
+        ref: headSha,
+        request: { signal: AbortSignal.timeout(GITHUB_REQUEST_TIMEOUT_MS) },
+    }));
+    if (data.commit.verification?.verified !== true) {
+        throw new Error(`GitHub did not verify Doistbot commit ${headSha} (${data.commit.verification?.reason ?? 'no verification result'}).`);
+    }
+}
+/**
+ * Strips markdown sections whose body contains no meaningful content.
+ * A section is considered empty when its body (between this heading and the
+ * next) consists only of whitespace, HTML comments, common placeholder text
+ * (e.g. "N/A"), or entirely-unchecked checkbox items.
+ */
+export function stripEmptySections(body) {
+    const lines = body.split('\n');
+    const sections = [];
+    const preamble = [];
+    for (const line of lines) {
+        const headingMatch = line.match(/^(#{1,6})\s/);
+        if (headingMatch) {
+            const level = headingMatch[1].length;
+            // Only start a new top-level section for headings at the same or higher
+            // level as the current one. Deeper subheadings are treated as content
+            // of the enclosing section so a parent isn't stripped when only its
+            // children carry the content.
+            if (sections.length === 0 || level <= sections[sections.length - 1].level) {
+                sections.push({ headingLine: line, bodyLines: [], level });
+            }
+            else {
+                sections[sections.length - 1].bodyLines.push(line);
+            }
+        }
+        else if (sections.length > 0) {
+            sections[sections.length - 1].bodyLines.push(line);
+        }
+        else {
+            preamble.push(line);
+        }
+    }
+    const nonEmpty = sections.filter((section) => {
+        let content = section.bodyLines
+            // Exclude subheading lines so a parent with only empty children is still empty
+            .filter((l) => !/^#{1,6}\s/.test(l))
+            .join('\n');
+        // Strip HTML comments
+        content = content.replace(/<!--[\s\S]*?-->/g, '');
+        content = content.trim();
+        if (!content)
+            return false;
+        // Common placeholder values (with optional list bullet and trailing period)
+        if (/^(?:[-*+]\s*)?(N\/A|None|TODO|TBD|-|—)\.?$/i.test(content))
+            return false;
+        // All lines are unchecked checkboxes — template boilerplate the model left as-is
+        const contentLines = content
+            .split('\n')
+            .map((l) => l.trim())
+            .filter((l) => l);
+        if (contentLines.length > 0 && contentLines.every((l) => /^[-*+] \[ \](?:\s|$)/.test(l)))
+            return false;
+        return true;
+    });
+    const result = [...preamble, ...nonEmpty.flatMap((s) => [s.headingLine, ...s.bodyLines])];
+    // Collapse runs of 2+ blank lines down to 1
+    const collapsed = [];
+    let blankCount = 0;
+    for (const line of result) {
+        if (line.trim() === '') {
+            blankCount++;
+            if (blankCount <= 1)
+                collapsed.push(line);
+        }
+        else {
+            blankCount = 0;
+            collapsed.push(line);
+        }
+    }
+    return collapsed.join('\n').trim();
+}
+/**
+ * Places the Sentry closing reference in the description's Reference section.
+ *
+ * Replaces a Reference section line that only references the issue, or else starts the first
+ * Reference section. Without a Reference section, it replaces such a line elsewhere, such as a
+ * template's `fixes` line, or adds a section before the recorded autofix checks.
+ */
+function placeClosingReference({ body, issueUrl, shortId, reference, }) {
+    const id = escapeRegExp(shortId);
+    const url = `${escapeRegExp(issueUrl.replace(/\/+$/, ''))}/?`;
+    const issueReferenceLine = new RegExp(`^(\\s*(?:[-*+]\\s+)?)(?:(?:related\\s+to|refs?|see|fix(?:e[sd])?|close[sd]?|resolve[sd]?|(?:sentry|source)\\s+issue)\\s*:?\\s+)?(?:<?${url}>?|${id}|\\[(?:${id}|${url})\\]\\(${url}\\))\\.?\\s*$`, 'i');
+    const lines = body.split('\n');
+    let referenceHeading = -1;
+    let referenceLevel = 0;
+    let sectionLine = -1;
+    let otherLine = -1;
+    let inComment = false;
+    let fence = '';
+    lines.forEach((line, index) => {
+        if (!inComment) {
+            const fenceMarker = line.match(/^ {0,3}(`{3,}|~{3,})/)?.[1];
+            if (fence) {
+                if (fenceMarker?.startsWith(fence) && line.trim() === fenceMarker)
+                    fence = '';
+                return;
+            }
+            if (fenceMarker) {
+                fence = fenceMarker;
+                return;
+            }
+        }
+        const commented = inComment;
+        const commentStart = line.lastIndexOf('<!--');
+        const commentEnd = line.lastIndexOf('-->');
+        if (commentStart > commentEnd)
+            inComment = true;
+        else if (commentEnd >= 0)
+            inComment = false;
+        if (commented)
+            return;
+        const heading = line.match(/^(#{1,6})\s/);
+        if (heading) {
+            const level = heading[1].length;
+            if (REFERENCE_HEADING_PATTERN.test(line)) {
+                referenceLevel = level;
+                if (referenceHeading < 0)
+                    referenceHeading = index;
+            }
+            else if (level <= referenceLevel) {
+                referenceLevel = 0;
+            }
+            return;
+        }
+        if (!issueReferenceLine.test(line))
+            return;
+        if (referenceLevel > 0) {
+            if (sectionLine < 0)
+                sectionLine = index;
+        }
+        else if (otherLine < 0) {
+            otherLine = index;
+        }
+    });
+    function replaceLine(index) {
+        lines[index] = lines[index].match(issueReferenceLine)[1] + reference;
+    }
+    if (sectionLine >= 0) {
+        replaceLine(sectionLine);
+    }
+    else if (referenceHeading >= 0) {
+        const nextLine = lines[referenceHeading + 1];
+        lines.splice(referenceHeading + 1, 0, '', reference, ...(nextLine?.trim() ? [''] : []));
+    }
+    else if (otherLine >= 0) {
+        replaceLine(otherLine);
+    }
+    else {
+        const checks = lines.lastIndexOf(RECORDED_CHECKS_HEADING);
+        const section = ['## Reference', '', reference];
+        if (checks >= 0)
+            lines.splice(checks, 0, ...section, '');
+        else
+            lines.push('', ...section);
+    }
+    return lines.join('\n');
+}
+function getConfidenceQualifier(classification, confidence) {
+    if (classification === 'auto-fixable' && confidence === 'high') {
+        return 'High confidence this addresses the issue correctly.';
+    }
+    if (classification === 'auto-fixable' && confidence === 'medium') {
+        return 'Should address the core issue but may need minor adjustments.';
+    }
+    if (classification === 'speculative' && confidence === 'high') {
+        return 'Starting point for the fix. The approach is likely correct but needs human verification.';
+    }
+    if (classification === 'speculative' && confidence === 'medium') {
+        return 'Starting point for the fix. Review carefully — the approach may need significant adjustments.';
+    }
+    return '';
+}
+const PR_BODY_TEMPLATE_FILE = 'auto-fix-pr-body-template.md';
+function buildPRBody({ issueNumber, issueUrl, triageAnalysis, fixDescription, fixAssessment, reference, }) {
+    const template = loadPromptTemplateFile({
+        fileName: resolvePromptFile(import.meta.url, PR_BODY_TEMPLATE_FILE),
+        promptLabel: 'auto-fix PR body',
+    });
+    const logging = fixAssessment?.classification === 'logs-needed';
+    let confidenceLine = '';
+    if (logging) {
+        confidenceLine = `\n> **Investigation confidence: ${fixAssessment.confidence}.** This PR adds diagnostics to test the triage hypotheses. The issue remains open.\n`;
+    }
+    else if (fixAssessment) {
+        const qualifier = getConfidenceQualifier(fixAssessment.classification, fixAssessment.confidence);
+        confidenceLine = `\n> **Fix confidence: ${fixAssessment.confidence}** — This is a ${fixAssessment.classification} fix. ${qualifier}\n`;
+    }
+    return fillPromptTemplate(template, {
+        ISSUE_URL: issueUrl,
+        FIX_CONFIDENCE: confidenceLine,
+        REFERENCE_SECTION: reference ? `\n## Reference\n\n${reference}` : '',
+        FIX_DESCRIPTION: fixDescription,
+        TRIAGE_ANALYSIS: triageAnalysis,
+        ISSUE_NUMBER: issueNumber === undefined ? '' : String(issueNumber),
+        CHANGE_SUMMARY: logging ? 'Automated logging changes' : 'Automated fix',
+        CHANGE_HEADING: logging ? 'Logging changes' : 'Fix Description',
+        VERIFY_TASK: logging
+            ? 'Verify the diagnostics answer the investigation questions without changing application behavior'
+            : `Verify the fix addresses the issue described in ${issueUrl}`,
+    });
+}
+export async function commitAndPushFix(input) {
+    const branch = input.branch ?? generateBranchName(input);
+    const logging = input.classification === 'logs-needed';
+    const titleLine = input.prTitle ?? `${logging ? 'chore: add diagnostics for' : 'fix:'} ${input.issueTitle}`;
+    const description = logging
+        ? 'Diagnostics generated by Doistbot based on the triage logging plan.'
+        : 'Automated fix generated by Doistbot based on triage analysis.';
+    const source = input.sentryIssue
+        ? (input.sentryIssue.shortId ?? `Sentry issue ${input.sentryIssue.issueId}`)
+        : `#${input.issueNumber}`;
+    const commitMessage = `${titleLine} (${source})\n\n${description}\nIssue: ${source}`;
+    logger.info('Creating fix PR', {
+        task: 'issue-triage',
+        repository: `${input.repoOwner}/${input.repoName}`,
+        issueNumber: input.issueNumber,
+        branch,
+    });
+    const headSha = await commitAndPushBranch({
+        repoLocalPath: input.repoLocalPath,
+        checkoutArgs: ['checkout', '-b', branch],
+        commitMessage,
+        branch,
+        githubToken: input.githubToken,
+        octokit: input.octokit,
+        repoOwner: input.repoOwner,
+        repoName: input.repoName,
+    });
+    logger.info('Fix branch pushed, creating draft PR', {
+        task: 'issue-triage',
+        repository: `${input.repoOwner}/${input.repoName}`,
+        branch,
+    });
+    return { branch, headSha };
+}
+/**
+ * Commits + pushes a second fix attempt on the EXISTING iter-0 branch. Unlike
+ * commitAndPushFix, this does not create a new branch — callers (the fix loop's
+ * iter-1 path) need the existing PR to pick up the new commit, which only
+ * works if we push to the same branch the PR was opened from.
+ *
+ * Assumes the working tree already has the iter-1 changes staged (typically by
+ * runFixCore's captureGitDiff `git add -A`) and that the repo is currently on
+ * `branch` (the case after iter-0 push + iter-1 `git reset --hard <iter0Sha>`).
+ */
+export async function commitAndPushIteration(input) {
+    const logging = input.classification === 'logs-needed';
+    const titleLine = input.prTitle ?? `${logging ? 'chore: add diagnostics for' : 'fix:'} ${input.issueTitle}`;
+    const description = logging
+        ? 'Follow-up diagnostics addressing prior review findings.'
+        : 'Follow-up fix addressing prior review findings.';
+    const source = input.sentryIssue
+        ? (input.sentryIssue.shortId ?? `Sentry issue ${input.sentryIssue.issueId}`)
+        : `#${input.issueNumber}`;
+    const commitMessage = `${titleLine} (iteration) (${source})\n\n${description}\nIssue: ${source}`;
+    // Defensive: make sure we are on the iter-0 branch before committing. The
+    // iter-1 codex run does `git reset --hard <iter0Sha>` which preserves the
+    // current branch, so this should be a no-op, but a checkout makes the
+    // invariant explicit.
+    const headSha = await commitAndPushBranch({
+        repoLocalPath: input.repoLocalPath,
+        checkoutArgs: ['checkout', input.branch],
+        commitMessage,
+        branch: input.branch,
+        githubToken: input.githubToken,
+        octokit: input.octokit,
+        repoOwner: input.repoOwner,
+        repoName: input.repoName,
+    });
+    logger.info('Fix iteration pushed to existing branch', {
+        task: 'issue-triage',
+        repository: `${input.repoOwner}/${input.repoName}`,
+        branch: input.branch,
+        issueNumber: input.issueNumber,
+    });
+    return { headSha };
+}
+/** Opens a draft, then marks it ready if an eligible assignee review was requested. */
+export async function openDraftFixPR(input) {
+    const logging = input.fixAssessment?.classification === 'logs-needed';
+    const title = input.prTitle || `${logging ? 'chore: add diagnostics for' : 'fix:'} ${input.issueTitle}`;
+    const source = input.sentryIssue
+        ? (input.sentryIssue.shortId ?? `Sentry issue ${input.sentryIssue.issueId}`)
+        : `todoist/Issues#${input.issueNumber}`;
+    const prTitle = `${title} (${source})`;
+    const shortId = !logging ? input.sentryIssue?.shortId : undefined;
+    let reference;
+    if (shortId) {
+        const issueLink = `[${shortId}](${input.issueUrl})`;
+        const titleClosesIssue = new RegExp(`\\bFixes\\s+${escapeRegExp(shortId)}(?![\\w-])`, 'i').test(prTitle);
+        reference = titleClosesIssue ? issueLink : `Fixes ${issueLink}`;
+    }
+    const loggingSummary = logging
+        ? `This PR implements the \`logs-needed\` triage plan. It adds diagnostics and keeps the issue open. Related to ${input.issueUrl}.\n\n`
+        : '';
+    let modelBody = input.prBody ? stripEmptySections(input.prBody) : '';
+    if (input.prBody && shortId && reference) {
+        modelBody = placeClosingReference({
+            body: modelBody,
+            issueUrl: input.issueUrl,
+            shortId,
+            reference,
+        });
+    }
+    const generatedBody = input.prBody
+        ? loggingSummary + modelBody
+        : buildPRBody({
+            issueNumber: input.issueNumber,
+            issueUrl: input.issueUrl,
+            triageAnalysis: input.triageAnalysis,
+            fixDescription: input.fixDescription,
+            fixAssessment: input.fixAssessment,
+            reference,
+        });
+    let prBody = generatedBody.includes(input.issueUrl)
+        ? generatedBody
+        : `${generatedBody}\n\nSource issue: ${input.issueUrl}`;
+    if (prBody.length > MAX_FIX_PR_BODY_CHARS) {
+        const shortened = "[PR description shortened to fit GitHub's size limit.]";
+        let notice = `${shortened}\n\nSource issue: ${input.issueUrl}\n\n`;
+        let cutoff = MAX_FIX_PR_BODY_CHARS - notice.length;
+        const referenceStart = reference ? prBody.indexOf(reference) : -1;
+        if (reference && referenceStart + reference.length > cutoff) {
+            notice = `${shortened}\n\n${reference}\n\n`;
+            cutoff = Math.min(MAX_FIX_PR_BODY_CHARS - notice.length, referenceStart);
+        }
+        // Avoid leaving half of a Unicode character at the cutoff.
+        const excerpt = prBody.slice(0, cutoff).replace(/[\uD800-\uDBFF]$/, '');
+        prBody = notice + excerpt;
+    }
+    const { data: repo } = await input.octokit.rest.repos.get({
+        owner: input.repoOwner,
+        repo: input.repoName,
+    });
+    const { data: pr } = await input.octokit.rest.pulls.create({
+        owner: input.repoOwner,
+        repo: input.repoName,
+        title: prTitle,
+        body: prBody,
+        head: input.branch,
+        base: repo.default_branch,
+        draft: true,
+    });
+    const requestedAssignees = await requestAssigneeReview({
+        owner: input.repoOwner,
+        repo: input.repoName,
+        prNumber: pr.number,
+        octokit: input.octokit,
+        assigneeReview: input.assigneeReview,
+    });
+    try {
+        const prLabel = input.fixAssessment?.classification === 'speculative'
+            ? DOISTBOT_SPECULATIVE_FIX_LABEL
+            : DOISTBOT_AUTO_FIX_LABEL;
+        await input.octokit.rest.issues.addLabels({
+            owner: input.repoOwner,
+            repo: input.repoName,
+            issue_number: pr.number,
+            labels: [prLabel],
+            request: { signal: AbortSignal.timeout(GITHUB_REQUEST_TIMEOUT_MS) },
+        });
+    }
+    catch (error) {
+        logger.warn('Failed to add label to fix PR (non-fatal)', {
+            task: 'issue-triage',
+            repository: `${input.repoOwner}/${input.repoName}`,
+            prNumber: pr.number,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    if (requestedAssignees.length > 0) {
+        // Apply the autofix label before emitting ready_for_review. An accepted
+        // assignee request is sufficient, even if writing its receipt failed.
+        try {
+            await markPullRequestReady({
+                octokit: input.octokit,
+                owner: input.repoOwner,
+                repo: input.repoName,
+                prNumber: pr.number,
+            });
+            logger.info('Assignee-reviewed fix PR marked ready', {
+                task: 'issue-triage',
+                repository: `${input.repoOwner}/${input.repoName}`,
+                prNumber: pr.number,
+            });
+        }
+        catch (error) {
+            // The PR and review request already exist. Preserve both and keep
+            // the fix loop running rather than reporting PR creation failure.
+            logger.warn('Failed to mark assignee-reviewed fix PR ready', {
+                task: 'issue-triage',
+                repository: `${input.repoOwner}/${input.repoName}`,
+                prNumber: pr.number,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            try {
+                await withRetry(() => input.octokit.rest.issues.createComment({
+                    owner: input.repoOwner,
+                    repo: input.repoName,
+                    issue_number: pr.number,
+                    body: "Review was requested from the issue assignees, but I couldn't confirm that this PR was marked ready for review. Please check its status and mark it ready manually if needed.",
+                    request: { signal: AbortSignal.timeout(GITHUB_REQUEST_TIMEOUT_MS) },
+                }));
+            }
+            catch (commentError) {
+                logger.warn('Failed to report fix PR readiness failure', {
+                    task: 'issue-triage',
+                    repository: `${input.repoOwner}/${input.repoName}`,
+                    prNumber: pr.number,
+                    error: commentError instanceof Error ? commentError.message : String(commentError),
+                });
+            }
+        }
+    }
+    logger.info('Fix PR created', {
+        task: 'issue-triage',
+        repository: `${input.repoOwner}/${input.repoName}`,
+        prNumber: pr.number,
+        prUrl: pr.html_url,
+        branch: input.branch,
+    });
+    return {
+        prUrl: pr.html_url,
+        prNumber: pr.number,
+        ...(requestedAssignees.length > 0 && { requestedAssignees }),
+    };
+}

package/sandbox/dist/tasks/issue-triage/pr-readiness.js

@@ -0,0 +1,25 @@
+import { withRetry } from '../../core/retry.js';
+import { GITHUB_REQUEST_TIMEOUT_MS } from './github-request.js';
+/** Safe both at creation and when the later CI-driven promotion runs. */
+export async function markPullRequestReady({ octokit, owner, repo, prNumber, }) {
+    // Re-read on every attempt: a mutation may have succeeded even if its
+    // response was lost. Repeating that mutation on a ready PR would fail.
+    await withRetry(async () => {
+        const { data: pr } = await octokit.rest.pulls.get({
+            owner,
+            repo,
+            pull_number: prNumber,
+            request: { signal: AbortSignal.timeout(GITHUB_REQUEST_TIMEOUT_MS) },
+        });
+        if (!pr.draft)
+            return;
+        await octokit.graphql(`mutation($pullRequestId: ID!) {
+                markPullRequestReadyForReview(input: { pullRequestId: $pullRequestId }) {
+                    pullRequest { isDraft }
+                }
+            }`, {
+            pullRequestId: pr.node_id,
+            request: { signal: AbortSignal.timeout(GITHUB_REQUEST_TIMEOUT_MS) },
+        });
+    });
+}

package/sandbox/dist/tasks/issue-triage/prompt.js

@@ -0,0 +1,63 @@
+import { fillPromptTemplate, loadPromptTemplateFile, resolvePromptFile, } from '../../core/prompt-template.js';
+import { describeWorkflow, loadRepositoryWorkflow } from './repo-prompts.js';
+import { TRIAGE_METADATA_SCHEMA } from './report-schema.js';
+import { describeSandboxEnvironment } from './sandbox-environment.js';
+export function buildReportCompactionPrompt(output) {
+    return fillPromptTemplate(loadPromptTemplateFile({
+        fileName: resolvePromptFile(import.meta.url, 'report-compaction.md'),
+        promptLabel: 'triage report compaction',
+    }), { REPORT: output });
+}
+function buildPriorInvestigationPrompt({ latest, pending }) {
+    if (!latest)
+        return '';
+    const template = loadPromptTemplateFile({
+        fileName: resolvePromptFile(import.meta.url, 'prior-investigation.md'),
+        promptLabel: 'prior investigation',
+    });
+    const previousReports = {
+        latest: { id: latest.report.id, url: latest.commentUrl },
+        completedLoggingRounds: latest.report.completedLoggingRounds,
+        pending: pending && { id: pending.report.id, url: pending.commentUrl },
+    };
+    return fillPromptTemplate(template, {
+        PREVIOUS_REPORTS: JSON.stringify(previousReports, null, 2),
+    });
+}
+export function buildTriagePrompt({ issueUrl, repositories, history, source = 'github', }) {
+    const template = loadPromptTemplateFile({
+        fileName: resolvePromptFile(import.meta.url, 'issue-triage-prompt.md'),
+        promptLabel: 'issue triage',
+    });
+    const { reinvestigation } = TRIAGE_METADATA_SCHEMA.properties;
+    const { none, pending, completed } = reinvestigation.mapping;
+    const metadataSchema = {
+        ...TRIAGE_METADATA_SCHEMA,
+        properties: {
+            ...TRIAGE_METADATA_SCHEMA.properties,
+            reinvestigation: {
+                ...reinvestigation,
+                mapping: history.pending ? { pending, completed } : { none },
+            },
+        },
+    };
+    return (fillPromptTemplate(template, {
+        INVESTIGATION_WORKFLOW: repositories
+            .map(({ repository, localPath }) => `### ${repository.fullName}\n\nApply this workflow only to ${repository.fullName}.\n\n${describeWorkflow(loadRepositoryWorkflow(localPath, 'triage'), 'triage-workflow.md')}`)
+            .join('\n\n'),
+        ISSUE_URL: issueUrl,
+        SOURCE_INSTRUCTIONS: source === 'sentry'
+            ? 'Use the sentry CLI to read the source issue and relevant events, stack traces, breadcrumbs, release details, and issue history. Read CLI help first if needed. Fetch the evidence; the URL alone is not a diagnosis. If access fails or there is no useful event evidence, report insufficient-context. This source has no GitHub issue or GitHub discussion. The Sentry POC only implements high-confidence bug fixes; logs-needed decisions stop without a fix. Completed reports are temporary and deleted when the task stops.'
+            : 'Use `gh` to read the issue report, labels, and its discussion. Fetch all comment pages and read the complete relevant comments, including prior Doistbot reports. The issue URL identifies the source; no shortened copy of the issue or discussion is supplied here.',
+        RESOLVED_REPOS: repositories
+            .map(({ repository, localPath }) => `- ${repository.fullName}: ${localPath}`)
+            .join('\n'),
+        PRIOR_INVESTIGATION: buildPriorInvestigationPrompt(history),
+        FIX_ASSESSMENT_INSTRUCTIONS: loadPromptTemplateFile({
+            fileName: resolvePromptFile(import.meta.url, 'fix-assessment-instructions.md'),
+            promptLabel: 'triage decision',
+        }),
+        PENDING_LOGGING_REPORT_ID: history.pending?.report.id ?? 'none',
+        METADATA_SCHEMA: JSON.stringify(metadataSchema, null, 2),
+    }) + describeSandboxEnvironment());
+}