@doist/doistbot-cli 1.0.2 → 1.0.3

package/dist/actions/review.js

@@ -3,6 +3,7 @@ import { getRepositoryRoot, loadSandboxFormatModule, loadSandboxReviewModule } f
 import { formatReviewProgress, renderAlert, renderMarkdown, withSpinner, writeLine, } from '../terminal.js';
 import { formatReviewUsage } from './review-usage.js';
 const LOCAL_REVIEW_SOURCE_STAGED = 'staged';
+const JSON_SCHEMA_VERSION = 1;
 const PROVIDER_DISPLAY_NAMES = {
     gemini: 'Gemini',
     openai: 'OpenAI Codex',
@@ -42,14 +43,17 @@ function getReadableProviderFailure(failure) {
         ?.trim();
     return `${PROVIDER_DISPLAY_NAMES[failure.model]} failed: ${firstLine || 'unknown error'}`;
 }
-function getReadableProviderFailures(failures) {
+function getReadableProviderFailureEntries(failures) {
     const messagesByModel = new Map();
     for (const failure of failures) {
         if (!messagesByModel.has(failure.model)) {
             messagesByModel.set(failure.model, getReadableProviderFailure(failure));
         }
     }
-    return [...messagesByModel.values()];
+    return Array.from(messagesByModel, ([model, message]) => ({ model, message }));
+}
+function getReadableProviderFailures(failures) {
+    return getReadableProviderFailureEntries(failures).map(({ message }) => message);
 }
 function formatProviderFailureMessage(failures) {
     const messages = getReadableProviderFailures(failures);
@@ -87,19 +91,130 @@ function handleSkippedReview(result) {
 function formatReviewOutput({ formatReviewForTerminal, review, }) {
     return formatReviewForTerminal({ review });
 }
-export async function runReview(sourceArg) {
+function getJsonStatus(result) {
+    function mapping(statusMapping, canTrustCleanReview = statusMapping.status === 'reviewed') {
+        return { mapping: statusMapping, canTrustCleanReview };
+    }
+    if (result.reviewResult.status === 'skipped') {
+        switch (result.reviewResult.reason) {
+            case 'empty_review':
+            case 'no_models':
+            case 'no_review':
+                return mapping({
+                    status: 'unverified',
+                    verified: false,
+                    unverifiedReason: result.reviewResult.reason,
+                }, false);
+            default:
+                return mapping({
+                    status: 'skipped',
+                    verified: false,
+                    skipReason: result.reviewResult.reason,
+                }, false);
+        }
+    }
+    return mapping({ status: 'reviewed', verified: true });
+}
+function finalizeJsonStatus({ initialStatus, findingCount, providerFailureCount, }) {
+    if (initialStatus.canTrustCleanReview && providerFailureCount > 0 && findingCount === 0) {
+        return { status: 'unverified', verified: false, unverifiedReason: 'provider_failures' };
+    }
+    return initialStatus.mapping;
+}
+function getReviewForJson(result) {
+    if (result.reviewResult.status === 'reviewed') {
+        return result.reviewResult.review;
+    }
+    return { summary: '', comments: [] };
+}
+function hasLocation(finding) {
+    return typeof finding.path === 'string' && typeof finding.line === 'number';
+}
+function formatReviewJsonFinding(finding) {
+    return {
+        body: finding.body,
+        severity: finding.severity,
+        ...(hasLocation(finding)
+            ? {
+                location: {
+                    path: finding.path,
+                    line: finding.line,
+                    ...(finding.side ? { side: finding.side } : {}),
+                },
+            }
+            : {}),
+    };
+}
+function getReviewFindingsForJson(review) {
+    if (review.findings) {
+        return review.findings;
+    }
+    return review.comments.map((comment) => ({
+        body: comment.body,
+        severity: null,
+        placement: 'inline',
+        path: comment.path,
+        line: comment.line,
+        side: comment.side,
+    }));
+}
+function getReviewFindingCount(review) {
+    return getReviewFindingsForJson(review).length;
+}
+function formatReviewForJson(result) {
+    const review = getReviewForJson(result);
+    const reviewFindings = getReviewFindingsForJson(review);
+    const findings = reviewFindings.map(formatReviewJsonFinding);
+    const statusMapping = finalizeJsonStatus({
+        initialStatus: getJsonStatus(result),
+        findingCount: findings.length,
+        providerFailureCount: result.reviewResult.providerFailures.length,
+    });
+    return {
+        schemaVersion: JSON_SCHEMA_VERSION,
+        ...statusMapping,
+        reviewSource: result.source,
+        repository: {
+            owner: result.owner,
+            repo: result.repo,
+            branch: result.branch,
+            baseBranch: result.baseBranch,
+        },
+        review: {
+            count: findings.length,
+            findings,
+        },
+        providerFailures: getReadableProviderFailureEntries(result.reviewResult.providerFailures),
+    };
+}
+async function runLocalReviewForCli({ source, onProgress, }) {
+    const reviewModule = await loadSandboxReviewModule();
+    return await reviewModule.runLocalReview({
+        workspaceDir: getRepositoryRoot(),
+        source,
+        apiKeys: await getApiKeys(),
+        suppressLogs: true,
+        onProgress,
+    });
+}
+export async function runReview(sourceArg, options = {}) {
     if (sourceArg !== undefined && sourceArg !== LOCAL_REVIEW_SOURCE_STAGED) {
         throw new Error(formatReviewUsage());
     }
     const source = sourceArg === LOCAL_REVIEW_SOURCE_STAGED ? LOCAL_REVIEW_SOURCE_STAGED : 'base';
-    const reviewModule = await loadSandboxReviewModule();
+    if (options.json === true) {
+        const result = await runLocalReviewForCli({ source });
+        const output = formatReviewForJson(result);
+        writeLine(JSON.stringify(output, null, 2));
+        if (output.status === 'unverified') {
+            process.exitCode = 1;
+        }
+        return;
+    }
     const result = await withSpinner(source === LOCAL_REVIEW_SOURCE_STAGED
         ? 'Reviewing staged changes...'
-        : 'Reviewing local changes...', async (status) => await reviewModule.runLocalReview({
-        workspaceDir: getRepositoryRoot(),
+        : 'Reviewing local changes...', async (status) => await runLocalReviewForCli({
         source,
-        apiKeys: await getApiKeys(),
-        suppressLogs: true,
         onProgress: status.enabled
             ? (event) => status.update(formatReviewProgress(event))
             : undefined,
@@ -110,7 +225,7 @@ export async function runReview(sourceArg) {
     }
     const formatModule = await loadSandboxFormatModule();
     if (result.reviewResult.providerFailures.length > 0 &&
-        result.reviewResult.review.comments.length === 0) {
+        getReviewFindingCount(result.reviewResult.review) === 0) {
         throw new Error(formatProviderFailureMessage(result.reviewResult.providerFailures));
     }
     const output = formatReviewOutput({

package/dist/actions/setup.js

@@ -3,7 +3,7 @@ import { renderDiagnosticCheck, writeLine } from '../terminal.js';
 import { runAuthSetup } from './auth.js';
 import { formatSetupCompleteMessage } from './review-usage.js';
 export async function runSetup() {
-    writeLine('Checking DoistBot CLI prerequisites...');
+    writeLine('Checking Doistbot CLI prerequisites...');
     await renderDiagnosticCheck('git', checkGit);
     await renderDiagnosticCheck('pi', checkPiDependency);
     await renderDiagnosticCheck('sandbox build', checkSandboxBuild);

package/dist/index.js

@@ -2,7 +2,7 @@
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { Command } from 'commander';
+import { Command, Option } from 'commander';
 import { AUTH_LOGOUT_PROVIDER_USAGE, runAuthLogout, runAuthSetup, runAuthStatus, } from './actions/auth.js';
 import { runDoctor } from './actions/doctor.js';
 import { runReview } from './actions/review.js';
@@ -34,18 +34,27 @@ export function createProgram({ runAuthLogout: authLogout = runAuthLogout, runAu
         automaticUpdateCommands.add(command);
         return command;
     }
+    function shouldRunAutomaticUpdateCheck(actionCommand) {
+        if (!automaticUpdateCommands.has(actionCommand)) {
+            return false;
+        }
+        if (actionCommand.name() === 'review' && actionCommand.opts().json) {
+            return false;
+        }
+        return true;
+    }
     program
         .name('doistbot')
-        .description('DoistBot local self-review CLI')
+        .description('Doistbot local self-review CLI')
         .version(PACKAGE_VERSION)
         .hook('postAction', async (_thisCommand, actionCommand) => {
-        if (automaticUpdateCommands.has(actionCommand)) {
+        if (shouldRunAutomaticUpdateCheck(actionCommand)) {
             await automaticUpdateCheck();
         }
     });
     withAutomaticUpdateCheck(program
         .command('doctor')
-        .description('Diagnose local DoistBot CLI setup')
+        .description('Diagnose local Doistbot CLI setup')
         .action(async () => await doctor()));
     withAutomaticUpdateCheck(program
         .command('setup')
@@ -53,7 +62,7 @@ export function createProgram({ runAuthLogout: authLogout = runAuthLogout, runAu
         .action(async () => await setup()));
     const authCommand = withAutomaticUpdateCheck(program
         .command('auth')
-        .description('Authenticate DoistBot CLI with local review providers')
+        .description('Authenticate Doistbot CLI with local review providers')
         .action(async () => await authSetup()));
     withAutomaticUpdateCheck(authCommand
         .command('status')
@@ -65,15 +74,16 @@ export function createProgram({ runAuthLogout: authLogout = runAuthLogout, runAu
         .action(async () => await authSetup()));
     withAutomaticUpdateCheck(authCommand
         .command('logout [provider]')
-        .description(`Clear stored DoistBot CLI auth for ${AUTH_LOGOUT_PROVIDER_USAGE}`)
+        .description(`Clear stored Doistbot CLI auth for ${AUTH_LOGOUT_PROVIDER_USAGE}`)
         .action(async (provider) => await authLogout(provider)));
     withAutomaticUpdateCheck(program
         .command('review [source]')
         .description('Run a local self-review. Use `staged` to review only staged changes.')
-        .action(async (source) => await review(source)));
+        .addOption(new Option('--json', 'Print machine-readable JSON instead of terminal-formatted markdown').hideHelp())
+        .action(async (source, options) => await review(source, { json: options?.json === true })));
     program
         .command('update')
-        .description('Check whether a newer DoistBot CLI version is available')
+        .description('Check whether a newer Doistbot CLI version is available')
         .action(async () => await updateCheck());
     return program;
 }

package/dist/runtime.js

@@ -53,10 +53,10 @@ async function loadBundledModule(modulePath, missingMessage) {
     return (await import(pathToFileURL(modulePath).href));
 }
 export async function loadSandboxReviewModule() {
-    return loadBundledModule(getSandboxReviewModulePath(), 'Sandbox review runner is missing. Rebuild or reinstall the DoistBot CLI package.');
+    return loadBundledModule(getSandboxReviewModulePath(), 'Sandbox review runner is missing. Rebuild or reinstall the Doistbot CLI package.');
 }
 export async function loadSandboxFormatModule() {
-    return loadBundledModule(getSandboxFormatModulePath(), 'Sandbox review formatter is missing. Rebuild or reinstall the DoistBot CLI package.');
+    return loadBundledModule(getSandboxFormatModulePath(), 'Sandbox review formatter is missing. Rebuild or reinstall the Doistbot CLI package.');
 }
 export function runGit(args, cwd = process.cwd()) {
     return execFileSync('git', args, {
@@ -89,7 +89,7 @@ export function checkSandboxBuild() {
     const modulePath = getSandboxReviewModulePath();
     return fs.existsSync(modulePath)
         ? { ok: true, message: 'sandbox review runner is built' }
-        : { ok: false, message: 'rebuild or reinstall the DoistBot CLI package' };
+        : { ok: false, message: 'rebuild or reinstall the Doistbot CLI package' };
 }
 export function checkPiDependency() {
     try {

package/dist/update-check.js

@@ -38,7 +38,7 @@ export async function notifyIfCliUpdateAvailable({ cachePath = getDefaultUpdateC
         timeoutMs,
     });
     if (!latestVersion) {
-        write('Unable to check for DoistBot CLI updates.');
+        write('Unable to check for Doistbot CLI updates.');
         return;
     }
     if (!isNewerVersion(latestVersion, currentVersion)) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@doist/doistbot-cli",
-    "version": "1.0.2",
-    "description": "Local self-review CLI for DoistBot",
+    "version": "1.0.3",
+    "description": "Local self-review CLI for Doistbot",
     "type": "module",
     "main": "dist/index.js",
     "bin": {

package/sandbox/_node_modules/doistbot-repo-config/dist/index.d.ts

@@ -28,6 +28,7 @@ export type RepoConfig = {
     issue_triage?: {
         enable_auto_triage?: boolean;
         enable_auto_fix?: boolean;
+        use_fix_loop?: boolean;
         max_changed_files?: number;
         max_changed_lines?: number;
     };

package/sandbox/dist/core/bot-logins.js

@@ -6,9 +6,22 @@ export const KNOWN_DOISTBOT_LOGINS = new Set([
     'doistbot-app',
     'doistbot-app[bot]',
 ]);
+export const KNOWN_AUTOMATION_LOGINS = new Set([
+    ...KNOWN_DOISTBOT_LOGINS,
+    'dependabot',
+    'dependabot[bot]',
+    'renovate',
+    'renovate[bot]',
+]);
 export function isKnownDoistbotLogin(login) {
     if (!login) {
         return false;
     }
     return KNOWN_DOISTBOT_LOGINS.has(login.toLowerCase());
 }
+export function isKnownAutomationLogin(login) {
+    if (!login) {
+        return false;
+    }
+    return KNOWN_AUTOMATION_LOGINS.has(login.toLowerCase());
+}

package/sandbox/dist/core/retry.js

@@ -0,0 +1,29 @@
+/** Default per-attempt delays for retrying transient HTTP failures. */
+export const HTTP_RETRY_DELAYS_MS = [250, 500, 1000];
+/** True for HTTP errors that are typically worth retrying: 429 and any 5xx. */
+function isTransientHttpError(error) {
+    const status = error?.status;
+    return typeof status === 'number' && (status === 429 || (status >= 500 && status < 600));
+}
+/**
+ * Retries `fn` on errors classified as retryable, sleeping between attempts.
+ * Total attempts = 1 + delaysMs.length. Throws immediately on a non-retryable
+ * error, or after the budget is exhausted (re-throwing the last error).
+ *
+ * Defaults match HTTP usage (429 / 5xx with exponential backoff). Pass
+ * `delaysMs` / `isRetryable` to retry against a different signal.
+ */
+export async function withRetry(fn, delaysMs = HTTP_RETRY_DELAYS_MS, isRetryable = isTransientHttpError) {
+    let attempt = 0;
+    while (true) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (!isRetryable(error) || attempt >= delaysMs.length)
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, delaysMs[attempt]));
+            attempt++;
+        }
+    }
+}

package/sandbox/dist/core/shared.js

@@ -44,8 +44,8 @@ export function parseBaseContext() {
     return {
         owner: requiredEnv('REPO_OWNER'),
         repo: requiredEnv('REPO_NAME'),
-        prNumber: Number(requiredEnv('PR_NUMBER')),
-        installationId: Number(requiredEnv('INSTALLATION_ID')),
+        prNumber: requiredPositiveInt('PR_NUMBER'),
+        installationId: requiredPositiveInt('INSTALLATION_ID'),
         appId: requiredEnv('APP_ID'),
         privateKey: requiredEnv('PRIVATE_KEY'),
         githubToken: process.env.GITHUB_TOKEN?.trim() || undefined,

package/sandbox/dist/main.js

@@ -12,6 +12,9 @@ switch (taskType) {
     case 'issue-fix-retry':
         await import('./tasks/issue-fix-retry/fix-retry.js');
         break;
+    case 'fix-loop-promotion':
+        await import('./tasks/issue-triage/fix-loop/promotion-task.js');
+        break;
     case 'persist-logs': {
         const { main } = await import('./tasks/persist-logs/persist-logs.js');
         await main();

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

@@ -2,8 +2,9 @@ import { execFileSync } from 'child_process';
 import { logger } from '../../core/logging.js';
 import { fillPromptTemplate, loadPromptTemplateFile } from '../../core/prompt-template.js';
 import { validateDiff } from './diff-validator.js';
+import { CODEX_CANNOT_FIX_REASON, FIX_LOOP_FAILED_REASON_PREFIX } from './fix-failure-reasons.js';
 import { CX_HERO_MANUAL_HANDLE, resolveHeroGroup } from './hero-group-map.js';
-import { HERO_AUTOFIX_MARKER } from './markers.js';
+import { AUTOFIX_FAILURE_MARKER, FIX_LOOP_START_MARKER, HERO_AUTOFIX_MARKER } from './markers.js';
 import { invokeTriageModel } from './model.js';
 import { commitAndPushFix, findPRTemplate, openDraftFixPR } from './pr-creator.js';
 const FIX_PROMPT_FILE = 'issue-triage-fix-prompt.md';
@@ -18,6 +19,9 @@ export function shouldAttemptFix(assessment) {
     }
     return assessment.confidence === 'high' || assessment.confidence === 'medium';
 }
+export function buildFixAssessmentSkipReason(assessment) {
+    return `Assessment: ${assessment.classification} (confidence: ${assessment.confidence})`;
+}
 function loadFixPromptTemplate() {
     return loadPromptTemplateFile({
         fileName: FIX_PROMPT_FILE,
@@ -160,6 +164,110 @@ export function buildFollowUpCommentBody({ prUrl, targetRepoFullName, fixAssessm
         `The PR targets \`${targetRepoFullName}\`. Please review it carefully before merging.`,
     ].join('\n');
 }
+function isNonRetryableFailure(reason) {
+    return reason.includes(CODEX_CANNOT_FIX_REASON);
+}
+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.prNumber !== undefined)
+        return false;
+    if (isNonRetryableFailure(fixResult.reason))
+        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, }) {
+    const repoNote = targetRepoFullName ? ` in \`${targetRepoFullName}\`` : '';
+    return [
+        AUTOFIX_FAILURE_MARKER,
+        '',
+        '### Automated fix attempt failed',
+        '',
+        `I attempted an automated fix but couldn't open a fix PR${repoNote}.`,
+        '',
+        '**Reason:**',
+        '',
+        '```',
+        reason,
+        '```',
+        '',
+        'You can retry by commenting `@doistbot /fix`.',
+    ].join('\n');
+}
+export async function postAutoFixFailureComment({ octokit, ctx, reason, targetRepoFullName, }) {
+    const body = buildAutoFixFailureCommentBody({ reason, targetRepoFullName });
+    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',
+    });
+}
 async function postFollowUpComment({ octokit, ctx, prUrl, prNumber, targetRepo, fixAssessment, }) {
     const heroGroup = resolveHeroGroup([], targetRepo);
     if (!heroGroup) {
@@ -193,6 +301,18 @@ async function postFollowUpComment({ octokit, ctx, prUrl, prNumber, targetRepo,
 }
 export async function runFixCore(input) {
     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),
+        };
+    }
     // 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`.
@@ -277,7 +397,7 @@ export async function runFixCore(input) {
             issueNumber: ctx.issueNumber,
             output: fixDescription.slice(0, 500),
         });
-        return { ok: false, reason: 'Codex determined fix cannot be applied automatically.' };
+        return { ok: false, reason: CODEX_CANNOT_FIX_REASON };
     }
     // Capture the diff
     const diff = captureGitDiff(targetRepo.localPath);
@@ -341,7 +461,7 @@ export async function attemptFix(input) {
         return {
             attempted: false,
             repository: fallbackRepository,
-            reason: `Assessment: ${fixAssessment.classification} (confidence: ${fixAssessment.confidence})`,
+            reason: buildFixAssessmentSkipReason(fixAssessment),
         };
     }
     if (clonedRepos.length === 0) {
@@ -378,6 +498,7 @@ export async function attemptFix(input) {
         issueTitle: input.issueTitle,
         issueUrl: input.issueUrl,
         ghToken: input.ghToken,
+        force,
     });
     if (!coreResult.ok) {
         return {
@@ -401,6 +522,7 @@ export async function attemptFix(input) {
             reason: 'Dry run — PR not created.',
         };
     }
+    let openedPr;
     try {
         const { branch } = await commitAndPushFix({
             repoOwner: targetRepo.repository.owner,
@@ -411,7 +533,7 @@ export async function attemptFix(input) {
             issueTitle: input.issueTitle,
             prTitle: coreResult.generatedPRTitle ?? undefined,
         });
-        const prResult = await openDraftFixPR({
+        openedPr = await openDraftFixPR({
             repoOwner: targetRepo.repository.owner,
             repoName: targetRepo.repository.repo,
             octokit,
@@ -429,38 +551,43 @@ export async function attemptFix(input) {
         await postFollowUpComment({
             octokit,
             ctx,
-            prUrl: prResult.prUrl,
-            prNumber: prResult.prNumber,
+            prUrl: openedPr.prUrl,
+            prNumber: openedPr.prNumber,
             targetRepo: targetRepo.repository,
             fixAssessment,
         });
         logger.info('Fix attempt completed successfully', {
             task: 'issue-triage',
             issueNumber: ctx.issueNumber,
-            prUrl: prResult.prUrl,
-            prNumber: prResult.prNumber,
+            prUrl: openedPr.prUrl,
+            prNumber: openedPr.prNumber,
             durationMs: Date.now() - startedAt,
         });
         return {
             attempted: true,
             repository: targetRepo.repository.fullName,
             prCreated: true,
-            prUrl: prResult.prUrl,
-            prNumber: prResult.prNumber,
+            prUrl: openedPr.prUrl,
+            prNumber: openedPr.prNumber,
         };
     }
     catch (error) {
-        logger.error('Fix PR creation failed', {
+        const reason = error instanceof Error ? error.message : String(error);
+        logger.error(openedPr ? 'Fix PR follow-up failed' : 'Fix PR creation failed', {
             task: 'issue-triage',
             issueNumber: ctx.issueNumber,
-            error: error instanceof Error ? error.message : String(error),
+            error: reason,
+            ...(openedPr ? { pr_number: openedPr.prNumber, pr_url: openedPr.prUrl } : {}),
             durationMs: Date.now() - startedAt,
         });
         return {
             attempted: true,
             repository: targetRepo.repository.fullName,
             prCreated: false,
-            reason: `PR creation failed: ${error instanceof Error ? error.message : String(error)}`,
+            reason: openedPr
+                ? `PR follow-up failed after opening PR: ${reason}`
+                : `PR creation failed: ${reason}`,
+            ...(openedPr ? { prNumber: openedPr.prNumber } : {}),
         };
     }
 }