@doist/doistbot-cli 1.0.5 → 1.0.6

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

@@ -1,26 +1,27 @@
 import { performance } from 'node:perf_hooks';
 import path from 'path';
+import { SpanStatusCode } from '@opentelemetry/api';
 import { recordTaskMetrics } from '../../core/datadog-metrics.js';
 import { logger } from '../../core/logging.js';
-import { logPiProgressEvent } from '../../core/pi-progress-logging.js';
 import { loadPromptTemplateFile } from '../../core/prompt-template.js';
 import { removeIssueCommentReactionIfPresent } from '../../core/reactions.js';
-import { resolveIssueRepositories } from '../../core/repository-resolver.js';
 import { REPOS_SUBDIR, WORKSPACE_DIR } from '../../core/shared.js';
-import { parseIssueTriageContext } from './context.js';
+import { withPhase } from '../../core/tracing.js';
+import { cloneTriageRepositories } from './clone.js';
+import { loadTriageContext, parseIssueTriageContext } from './context.js';
 import { postAutoFixFailureComment, shouldPostAutoFixFailureComment } from './fix-attempt.js';
 import { runConfiguredFix } from './fix-dispatch.js';
 import { invokeTriageModel } from './model.js';
-import { buildTriageFailureMessage, buildUnresolvedLabelsOutput, ensureStructuredTriageOutput, parseFixAssessment, REQUIRED_HEADINGS, } from './output.js';
+import { buildTriageFailureMessage, buildUnresolvedLabelsOutput, REQUIRED_HEADINGS, validateTriageOutput, } from './output.js';
 import { fillTemplate, loadPromptTemplate } from './prompt.js';
 import { allRepositoriesAllow, createRepoConfigLoader, isAutoFixEnabled, isAutoTriageEnabled, } from './repo-config.js';
-import { buildHeroRoutingComment, postHeroRoutingComment, shouldPostHeroRoutingComment, } from './routing.js';
-import { cloneRepository, createGitHubClients, extractLabelNames, fetchIssue, fetchIssueComments, getIssueUrl, prepareWorkspaceReposDirectory, TRIAGE_MARKER, } from './shared.js';
-import { deleteAutoTriagePlaceholder, postIssueComment } from './side-effects.js';
+import { resolveTriageScope } from './resolution.js';
+import { buildHeroRoutingComment, postTriageRouting, shouldPostHeroRoutingComment, } from './routing.js';
+import { createGitHubClients, getIssueUrl, prepareWorkspaceReposDirectory } from './shared.js';
+import { deleteAutoTriagePlaceholder, postTriageOutput } from './side-effects.js';
 const MAX_ISSUE_BODY_CHARS = 8_000;
 const MAX_COMMENT_BODY_CHARS = 2_000;
 const MAX_PROMPT_COMMENTS = 120;
-const VERBOSE_PI_PROGRESS_LOGS = process.env.DOISTBOT_VERBOSE_PI_PROGRESS === 'true';
 const TRIAGE_PROVIDER = 'openai';
 function truncateText(text, maxChars) {
     if (text.length <= maxChars) {
@@ -58,27 +59,6 @@ function formatRepositoriesForPrompt(repositories) {
         .map(({ repository, localPath }) => `- ${repository.fullName} (local path: ${localPath})`)
         .join('\n');
 }
-function logTriageModelProgress(ctx, event) {
-    const meta = {
-        task: 'issue-triage',
-        issueNumber: ctx.issueNumber,
-    };
-    logPiProgressEvent({
-        event,
-        messages: {
-            agentStart: 'Issue triage model agent started',
-            agentEnd: 'Issue triage model agent finished',
-            thinking: 'Issue triage model still thinking',
-            responding: 'Issue triage model streaming response',
-            toolStart: 'Issue triage model tool started',
-            toolUpdate: 'Issue triage model tool still running',
-            toolEnd: 'Issue triage model tool finished',
-        },
-        meta,
-        logResponding: VERBOSE_PI_PROGRESS_LOGS,
-        logTools: VERBOSE_PI_PROGRESS_LOGS,
-    });
-}
 function buildPrompt({ ctx, issue, comments, labelNames, clonedRepositories, decisionPath, enableAutoFix, }) {
     const template = loadPromptTemplate();
     const issueBody = truncateText(formatCommentBody(issue.body ?? '(No issue description provided.)'), MAX_ISSUE_BODY_CHARS);
@@ -105,22 +85,6 @@ function buildPrompt({ ctx, issue, comments, labelNames, clonedRepositories, dec
             : '',
     });
 }
-async function postTriageComment({ octokit, ctx, body, }) {
-    logger.info('Issue triage comment post starting', {
-        task: 'issue-triage',
-        issueNumber: ctx.issueNumber,
-        bodyChars: body.length,
-        editingPlaceholder: Boolean(ctx.placeholderCommentId),
-    });
-    await postIssueComment(ctx, octokit, body, {
-        marker: TRIAGE_MARKER,
-        placeholderCommentId: ctx.placeholderCommentId,
-    });
-    logger.info('Issue triage comment post succeeded', {
-        task: 'issue-triage',
-        issueNumber: ctx.issueNumber,
-    });
-}
 export async function runIssueTriage(ctx) {
     if (ctx.triggerType === 'auto') {
         return runAutoIssueTriage(ctx);
@@ -152,425 +116,331 @@ async function runIssueTriagePipeline(ctx, mode) {
         repository: `${ctx.owner}/${ctx.repo}`,
         issueNumber: ctx.issueNumber,
     });
-    logger.info('Issue triage task started', {
+    // The root withPhase wraps the entire run. OTel sets this span active, so
+    // every nested withPhase / startToolSpan parents under it automatically.
+    // withPhase handles the span lifecycle + ERROR status; the inner try/catch
+    // keeps the existing failure log and cleanup side effects.
+    return withPhase('triage', {
         task: 'issue-triage',
-        dryRun: ctx.dryRun,
-        issueNumber: ctx.issueNumber,
-        commentId: ctx.commentId,
+        'gen_ai.operation.name': 'invoke_agent',
+        'gen_ai.agent.name': 'doistbot.triage',
+        dry_run: ctx.dryRun,
+        'issue.number': ctx.issueNumber,
+        'comment.id': ctx.commentId,
         trigger: ctx.triggerType,
-        enableAutoFixOverride: ctx.enableAutoFixOverride,
-    });
-    const { app, readOctokit, writeOctokit } = await createGitHubClients(ctx);
-    async function postFinalTriageComment(body) {
-        await postTriageComment({
-            octokit: writeOctokit,
-            ctx,
-            body,
-        });
-        triageCommentPosted = true;
-    }
-    try {
-        logger.info('Fetching issue triage context from GitHub', {
-            task: 'issue-triage',
-            issueNumber: ctx.issueNumber,
-        });
-        const [issue, comments] = await Promise.all([
-            fetchIssue(readOctokit, {
-                owner: ctx.owner,
-                repo: ctx.repo,
-                issueNumber: ctx.issueNumber,
-            }),
-            fetchIssueComments(readOctokit, {
+        enable_auto_fix_override: ctx.enableAutoFixOverride,
+    }, async (rootSpan) => {
+        const { app, readOctokit, writeOctokit } = await createGitHubClients(ctx);
+        // postTriageOutput adds TRIAGE_MARKER (and edits the auto-triage
+        // placeholder) internally — callers pass marker-free bodies.
+        async function postFinalTriageComment(body) {
+            await postTriageOutput({ octokit: writeOctokit, ctx, body });
+            triageCommentPosted = true;
+        }
+        try {
+            const { issue, comments, labelNames } = await loadTriageContext({
+                octokit: readOctokit,
                 owner: ctx.owner,
                 repo: ctx.repo,
                 issueNumber: ctx.issueNumber,
-            }),
-        ]);
-        const labelNames = extractLabelNames(issue.labels);
-        logger.info('Issue triage context loaded', {
-            task: 'issue-triage',
-            issueNumber: ctx.issueNumber,
-            labelsCount: labelNames.length,
-            commentsCount: comments.length,
-        });
-        const resolution = resolveIssueRepositories(labelNames);
-        logger.info('Issue triage label resolution completed', {
-            task: 'issue-triage',
-            issueNumber: ctx.issueNumber,
-            status: resolution.status,
-            reason: resolution.reason,
-            confidence: resolution.confidence,
-            decisionPath: resolution.decisionPath,
-            parsedProducts: resolution.parsedLabels.productLabels,
-            parsedApps: resolution.parsedLabels.appLabels,
-            parsedTeams: resolution.parsedLabels.teamLabels,
-            unknownProductLabels: resolution.parsedLabels.unknownProductLabels,
-            unknownAppLabels: resolution.parsedLabels.unknownAppLabels,
-            unknownTeamLabels: resolution.parsedLabels.unknownTeamLabels,
-        });
-        logger.info('triage.repo_resolution', {
-            task: 'issue-triage',
-            trigger: ctx.triggerType,
-            status: resolution.status,
-            confidence: resolution.confidence,
-        });
-        if (resolution.status === 'unresolved') {
-            const unresolvedBody = buildUnresolvedLabelsOutput({
-                reason: resolution.reason,
-                productLabels: resolution.parsedLabels.productLabels,
-                appLabels: resolution.parsedLabels.appLabels,
-                teamLabels: resolution.parsedLabels.teamLabels,
             });
-            await postFinalTriageComment(unresolvedBody);
-            if (mode.routeUnresolvedLabels) {
-                await postHeroRoutingComment({
-                    octokit: writeOctokit,
-                    ctx,
-                    body: buildHeroRoutingComment({
-                        labels: labelNames,
-                        triageOutput: unresolvedBody,
-                    }),
+            const resolution = await resolveTriageScope({
+                triggerType: ctx.triggerType,
+                labelNames,
+            });
+            if (resolution.status === 'unresolved') {
+                const unresolvedBody = buildUnresolvedLabelsOutput({
+                    reason: resolution.reason,
+                    productLabels: resolution.parsedLabels.productLabels,
+                    appLabels: resolution.parsedLabels.appLabels,
+                    teamLabels: resolution.parsedLabels.teamLabels,
                 });
+                await postFinalTriageComment(unresolvedBody);
+                if (mode.routeUnresolvedLabels) {
+                    await postTriageRouting({
+                        octokit: writeOctokit,
+                        ctx,
+                        body: buildHeroRoutingComment({
+                            labels: labelNames,
+                            triageOutput: unresolvedBody,
+                        }),
+                    });
+                }
+                triageDurationMs = performance.now() - startedAt;
+                return;
             }
-            triageDurationMs = performance.now() - startedAt;
-            return;
-        }
-        logger.info('Issue triage repository resolution succeeded', {
-            task: 'issue-triage',
-            issueNumber: ctx.issueNumber,
-            resolvedReposCount: resolution.repositories.length,
-            resolvedRepos: resolution.repositories.map((repository) => repository.fullName),
-            confidence: resolution.confidence,
-        });
-        const getCachedRepoConfig = createRepoConfigLoader({
-            octokit: readOctokit,
-            logger,
-        });
-        if (ctx.triggerType === 'auto') {
-            const enableAutoTriage = await allRepositoriesAllow({
-                repositories: resolution.repositories,
-                loadRepoConfig: getCachedRepoConfig,
-                isEnabled: isAutoTriageEnabled,
-                feature: 'auto_triage',
+            const getCachedRepoConfig = createRepoConfigLoader({
+                octokit: readOctokit,
                 logger,
             });
-            if (!enableAutoTriage) {
-                shouldRecordTriageMetric = false;
-                logger.info('Auto issue triage skipped: a resolved repository disabled auto triage', {
-                    task: 'issue-triage',
-                    issueNumber: ctx.issueNumber,
-                    resolvedRepos: resolution.repositories.map((repository) => repository.fullName),
+            if (ctx.triggerType === 'auto') {
+                const enableAutoTriage = await allRepositoriesAllow({
+                    repositories: resolution.repositories,
+                    loadRepoConfig: getCachedRepoConfig,
+                    isEnabled: isAutoTriageEnabled,
+                    feature: 'auto_triage',
+                    logger,
                 });
-                await deleteAutoTriagePlaceholder({
-                    octokit: writeOctokit,
-                    ctx,
-                    reason: 'auto_triage_disabled',
+                if (!enableAutoTriage) {
+                    shouldRecordTriageMetric = false;
+                    logger.info('Auto issue triage skipped: a resolved repository disabled auto triage', {
+                        task: 'issue-triage',
+                        issueNumber: ctx.issueNumber,
+                        resolvedRepos: resolution.repositories.map((repository) => repository.fullName),
+                    });
+                    await deleteAutoTriagePlaceholder({
+                        octokit: writeOctokit,
+                        ctx,
+                        reason: 'auto_triage_disabled',
+                    });
+                    return;
+                }
+            }
+            let enableAutoFix = ctx.enableAutoFixOverride ?? true;
+            if (ctx.enableAutoFixOverride === undefined) {
+                enableAutoFix = await allRepositoriesAllow({
+                    repositories: resolution.repositories,
+                    loadRepoConfig: getCachedRepoConfig,
+                    isEnabled: isAutoFixEnabled,
+                    feature: 'auto_fix',
+                    logger,
                 });
-                return;
             }
-        }
-        let enableAutoFix = ctx.enableAutoFixOverride ?? true;
-        if (ctx.enableAutoFixOverride === undefined) {
-            enableAutoFix = await allRepositoriesAllow({
+            const reposDir = prepareWorkspaceReposDirectory();
+            const { clonedRepositories, failedRepositories } = await cloneTriageRepositories({
+                app,
+                reposDir,
                 repositories: resolution.repositories,
-                loadRepoConfig: getCachedRepoConfig,
-                isEnabled: isAutoFixEnabled,
-                feature: 'auto_fix',
-                logger,
+                fallbackInstallationId: ctx.installationId,
             });
-        }
-        const reposDir = prepareWorkspaceReposDirectory();
-        const clonedRepositories = [];
-        const failedRepositories = [];
-        logger.info('Issue triage clone phase started', {
-            task: 'issue-triage',
-            issue_number: ctx.issueNumber,
-        });
-        for (const repository of resolution.repositories) {
-            try {
-                const cloneResult = await cloneRepository({
-                    app,
-                    repository,
-                    reposDir,
-                    fallbackInstallationId: ctx.installationId,
+            if (clonedRepositories.length === 0) {
+                await postFinalTriageComment(buildTriageFailureMessage('Repository cloning failed for all resolved repositories.'));
+                // Non-throwing failure: mark the root span so the run is
+                // not reported as ok in Datadog. withPhase never forces OK,
+                // so this survives to the root phase.end.
+                rootSpan.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: 'Repository cloning failed for all resolved repositories.',
                 });
-                clonedRepositories.push(cloneResult);
+                triageDurationMs = performance.now() - startedAt;
+                return;
             }
-            catch (error) {
-                failedRepositories.push({
-                    repository: repository.fullName,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                logger.warn('Issue triage clone failed', {
+            if (failedRepositories.length > 0) {
+                logger.warn('Issue triage running in degraded mode after partial clone failures', {
                     task: 'issue-triage',
-                    repository: repository.fullName,
-                    error: error instanceof Error ? error.message : String(error),
+                    issueNumber: ctx.issueNumber,
+                    cloneSucceeded: clonedRepositories.length,
+                    cloneFailed: failedRepositories.length,
+                    failedRepositories,
                 });
             }
-        }
-        logger.info('Issue triage clone phase completed', {
-            task: 'issue-triage',
-            issueNumber: ctx.issueNumber,
-            cloneSucceeded: clonedRepositories.length,
-            cloneFailed: failedRepositories.length,
-            failedRepositories,
-        });
-        if (clonedRepositories.length === 0) {
-            const fallbackComment = `${TRIAGE_MARKER}\n\n${buildTriageFailureMessage('Repository cloning failed for all resolved repositories.')}`;
-            await postFinalTriageComment(fallbackComment);
-            triageDurationMs = performance.now() - startedAt;
-            return;
-        }
-        if (failedRepositories.length > 0) {
-            logger.warn('Issue triage running in degraded mode after partial clone failures', {
-                task: 'issue-triage',
-                issueNumber: ctx.issueNumber,
-                cloneSucceeded: clonedRepositories.length,
-                cloneFailed: failedRepositories.length,
+            const issueInstallationAuth = (await app.octokit.auth({
+                type: 'installation',
+                installationId: ctx.installationId,
+            }));
+            const prompt = buildPrompt({
+                ctx,
+                issue,
+                comments,
+                labelNames,
+                clonedRepositories,
+                decisionPath: resolution.decisionPath,
+                enableAutoFix,
             });
-        }
-        const issueInstallationAuth = (await app.octokit.auth({
-            type: 'installation',
-            installationId: ctx.installationId,
-        }));
-        const prompt = buildPrompt({
-            ctx,
-            issue,
-            comments,
-            labelNames,
-            clonedRepositories,
-            decisionPath: resolution.decisionPath,
-            enableAutoFix,
-        });
-        logger.info('Issue triage model invocation starting', {
-            task: 'issue-triage',
-            issueNumber: ctx.issueNumber,
-            provider: TRIAGE_PROVIDER,
-            promptChars: prompt.length,
-            repositoriesAnalyzed: clonedRepositories.length,
-        });
-        const triageResult = await invokeTriageModel({
-            prompt,
-            apiKey: ctx.openaiApiKey,
-            cwd: WORKSPACE_DIR,
-            extraEnv: {
-                GH_TOKEN: issueInstallationAuth.token,
-            },
-            thinkingLevel: 'high',
-            onProgress: (event) => {
-                logTriageModelProgress(ctx, event);
-            },
-        });
-        if (!triageResult.ok) {
-            logger.error('Issue triage model invocation failed', {
-                task: 'issue-triage',
-                issueNumber: ctx.issueNumber,
-                provider: TRIAGE_PROVIDER,
-                timedOut: triageResult.timedOut,
-                durationMs: triageResult.durationMs,
-                error: triageResult.error,
+            const triageResult = await invokeTriageModel({
+                prompt,
+                apiKey: ctx.openaiApiKey,
+                cwd: WORKSPACE_DIR,
+                extraEnv: {
+                    GH_TOKEN: issueInstallationAuth.token,
+                },
+                thinkingLevel: 'high',
             });
-            const fallbackComment = `${TRIAGE_MARKER}\n\n${buildTriageFailureMessage(triageResult.error)}`;
-            await postFinalTriageComment(fallbackComment);
-            triageDurationMs = performance.now() - startedAt;
-            return;
-        }
-        logger.info('Issue triage model invocation finished', {
-            task: 'issue-triage',
-            issueNumber: ctx.issueNumber,
-            provider: TRIAGE_PROVIDER,
-            durationMs: triageResult.durationMs,
-            outputChars: triageResult.output.length,
-        });
-        const normalized = ensureStructuredTriageOutput(triageResult.output);
-        logger.info('Issue triage output quality check completed', {
-            task: 'issue-triage',
-            issueNumber: ctx.issueNumber,
-            missingSections: normalized.missingSections,
-            missingSectionsCount: normalized.missingSections.length,
-        });
-        if (normalized.missingSections.length > 0) {
-            const failureComment = `${TRIAGE_MARKER}\n\n${buildTriageFailureMessage(`Triage model returned incomplete output. Missing sections: ${normalized.missingSections.join(', ')}`)}`;
-            await postFinalTriageComment(failureComment);
+            if (!triageResult.ok) {
+                await postFinalTriageComment(buildTriageFailureMessage(triageResult.error));
+                rootSpan.setStatus({ code: SpanStatusCode.ERROR, message: triageResult.error });
+                triageDurationMs = performance.now() - startedAt;
+                return;
+            }
+            const validated = await validateTriageOutput({ rawOutput: triageResult.output });
+            if (!validated.ok) {
+                await postFinalTriageComment(buildTriageFailureMessage(validated.error));
+                rootSpan.setStatus({ code: SpanStatusCode.ERROR, message: validated.error });
+                triageDurationMs = performance.now() - startedAt;
+                return;
+            }
+            await postFinalTriageComment(validated.commentOutput);
+            triageMetricOutcome = 'success';
             triageDurationMs = performance.now() - startedAt;
-            return;
+            const fixAssessment = validated.assessment;
+            if (fixAssessment) {
+                logger.info('Fix assessment parsed from triage output', {
+                    task: 'issue-triage',
+                    issueNumber: ctx.issueNumber,
+                    classification: fixAssessment.classification,
+                    confidence: fixAssessment.confidence,
+                    scope: fixAssessment.scope,
+                });
+            }
+            if (shouldPostHeroRoutingComment(fixAssessment)) {
+                const routingComment = buildHeroRoutingComment({
+                    labels: labelNames,
+                    primaryRepo: resolution.repositories.length === 1
+                        ? resolution.repositories[0]
+                        : undefined,
+                    triageOutput: validated.output,
+                });
+                await postTriageRouting({
+                    octokit: writeOctokit,
+                    ctx,
+                    body: routingComment,
+                });
+            }
+            if (enableAutoFix && fixAssessment) {
+                const fixMetricRepository = fixAssessment.targetRepo ??
+                    (clonedRepositories.length === 1
+                        ? clonedRepositories[0].repository.fullName
+                        : `${ctx.owner}/${ctx.repo}`);
+                pendingFixMetric = {
+                    repository: fixMetricRepository,
+                    startedAt: performance.now(),
+                    outcome: 'failure',
+                };
+                const fixResult = await runConfiguredFix({
+                    ctx,
+                    octokit: writeOctokit,
+                    triageOutput: validated.output,
+                    fixAssessment,
+                    clonedRepos: clonedRepositories,
+                    issueTitle: issue.title ?? 'Untitled issue',
+                    issueUrl: issue.html_url ?? getIssueUrl(ctx.owner, ctx.repo, ctx.issueNumber),
+                    ghToken: issueInstallationAuth.token,
+                    loadRepoConfig: getCachedRepoConfig,
+                });
+                logger.info('triage.fix_attempted', {
+                    task: 'issue-triage',
+                    trigger: ctx.triggerType,
+                    classification: fixAssessment.classification,
+                    attempted: fixResult.attempted,
+                });
+                logger.info('Fix attempt result', {
+                    task: 'issue-triage',
+                    issueNumber: ctx.issueNumber,
+                    attempted: fixResult.attempted,
+                    prCreated: fixResult.attempted && fixResult.prCreated,
+                    reason: 'reason' in fixResult ? fixResult.reason : undefined,
+                    prUrl: 'prUrl' in fixResult ? fixResult.prUrl : undefined,
+                    pr_number: 'prNumber' in fixResult ? fixResult.prNumber : undefined,
+                    durationMs: performance.now() - startedAt,
+                });
+                pendingFixMetric = {
+                    repository: fixResult.repository,
+                    startedAt: pendingFixMetric.startedAt,
+                    outcome: fixResult.attempted && fixResult.prCreated ? 'success' : 'failure',
+                };
+                const shouldPostFailureComment = await shouldPostAutoFixFailureComment(fixResult, {
+                    dryRun: ctx.dryRun,
+                    octokit: writeOctokit,
+                    ctx,
+                });
+                if (shouldPostFailureComment) {
+                    try {
+                        await postAutoFixFailureComment({
+                            octokit: writeOctokit,
+                            ctx,
+                            reason: 'reason' in fixResult ? fixResult.reason : 'Unknown reason',
+                            targetRepoFullName: fixResult.repository,
+                        });
+                    }
+                    catch (commentError) {
+                        logger.warn('Failed to post auto-fix failure comment', {
+                            task: 'issue-triage',
+                            issue_number: ctx.issueNumber,
+                            error: commentError instanceof Error
+                                ? commentError.message
+                                : String(commentError),
+                        });
+                    }
+                }
+            }
+            else {
+                logger.info('triage.fix_attempted', {
+                    task: 'issue-triage',
+                    trigger: ctx.triggerType,
+                    classification: fixAssessment?.classification ?? 'none',
+                    attempted: false,
+                });
+            }
         }
-        const triageComment = `${TRIAGE_MARKER}\n\n${normalized.commentOutput}`;
-        await postFinalTriageComment(triageComment);
-        logger.info('Issue triage task completed successfully', {
-            task: 'issue-triage',
-            issueNumber: ctx.issueNumber,
-            resolvedReposCount: clonedRepositories.length,
-            durationMs: performance.now() - startedAt,
-        });
-        triageMetricOutcome = 'success';
-        triageDurationMs = performance.now() - startedAt;
-        const fixAssessment = parseFixAssessment(normalized.output);
-        if (fixAssessment) {
-            logger.info('Fix assessment parsed from triage output', {
+        catch (error) {
+            // withPhase records the exception + sets the root span ERROR status
+            // when we re-throw. This block keeps the existing failure log and
+            // user-visible cleanup side effects.
+            logger.error('Issue triage task failed', {
                 task: 'issue-triage',
                 issueNumber: ctx.issueNumber,
-                classification: fixAssessment.classification,
-                confidence: fixAssessment.confidence,
-                scope: fixAssessment.scope,
-            });
-        }
-        if (shouldPostHeroRoutingComment(fixAssessment)) {
-            const routingComment = buildHeroRoutingComment({
-                labels: labelNames,
-                primaryRepo: resolution.repositories.length === 1 ? resolution.repositories[0] : undefined,
-                triageOutput: normalized.output,
-            });
-            await postHeroRoutingComment({
-                octokit: writeOctokit,
-                ctx,
-                body: routingComment,
-            });
-        }
-        if (enableAutoFix && fixAssessment) {
-            const fixMetricRepository = fixAssessment.targetRepo ??
-                (clonedRepositories.length === 1
-                    ? clonedRepositories[0].repository.fullName
-                    : `${ctx.owner}/${ctx.repo}`);
-            pendingFixMetric = {
-                repository: fixMetricRepository,
-                startedAt: performance.now(),
-                outcome: 'failure',
-            };
-            const fixResult = await runConfiguredFix({
-                ctx,
-                octokit: writeOctokit,
-                triageOutput: normalized.output,
-                fixAssessment,
-                clonedRepos: clonedRepositories,
-                issueTitle: issue.title ?? 'Untitled issue',
-                issueUrl: issue.html_url ?? getIssueUrl(ctx.owner, ctx.repo, ctx.issueNumber),
-                ghToken: issueInstallationAuth.token,
-                loadRepoConfig: getCachedRepoConfig,
-            });
-            logger.info('triage.fix_attempted', {
-                task: 'issue-triage',
                 trigger: ctx.triggerType,
-                classification: fixAssessment.classification,
-                attempted: fixResult.attempted,
-            });
-            logger.info('Fix attempt result', {
-                task: 'issue-triage',
-                issueNumber: ctx.issueNumber,
-                attempted: fixResult.attempted,
-                prCreated: fixResult.attempted && fixResult.prCreated,
-                reason: 'reason' in fixResult ? fixResult.reason : undefined,
-                prUrl: 'prUrl' in fixResult ? fixResult.prUrl : undefined,
-                pr_number: 'prNumber' in fixResult ? fixResult.prNumber : undefined,
+                error: error instanceof Error ? error.message : String(error),
                 durationMs: performance.now() - startedAt,
             });
-            pendingFixMetric = {
-                repository: fixResult.repository,
-                startedAt: pendingFixMetric.startedAt,
-                outcome: fixResult.attempted && fixResult.prCreated ? 'success' : 'failure',
-            };
-            const shouldPostFailureComment = await shouldPostAutoFixFailureComment(fixResult, {
-                dryRun: ctx.dryRun,
-                octokit: writeOctokit,
-                ctx,
-            });
-            if (shouldPostFailureComment) {
+            if (ctx.triggerType === 'auto' && !triageCommentPosted) {
+                await deleteAutoTriagePlaceholder({
+                    octokit: writeOctokit,
+                    ctx,
+                    reason: 'auto_triage_failed_before_final_comment',
+                });
+            }
+            if (!ctx.dryRun && ctx.triggerType !== 'auto') {
                 try {
-                    await postAutoFixFailureComment({
-                        octokit: writeOctokit,
-                        ctx,
-                        reason: 'reason' in fixResult ? fixResult.reason : 'Unknown reason',
-                        targetRepoFullName: fixResult.repository,
-                    });
+                    const reason = error instanceof Error ? error.message : String(error);
+                    await postFinalTriageComment(buildTriageFailureMessage(reason));
                 }
                 catch (commentError) {
-                    logger.warn('Failed to post auto-fix failure comment', {
+                    logger.warn('Failed to post issue triage failure response', {
                         task: 'issue-triage',
-                        issue_number: ctx.issueNumber,
+                        issueNumber: ctx.issueNumber,
                         error: commentError instanceof Error
                             ? commentError.message
                             : String(commentError),
                     });
                 }
             }
+            throw error;
         }
-        else {
-            logger.info('triage.fix_attempted', {
-                task: 'issue-triage',
-                trigger: ctx.triggerType,
-                classification: fixAssessment?.classification ?? 'none',
-                attempted: false,
-            });
-        }
-    }
-    catch (error) {
-        logger.error('Issue triage task failed', {
-            task: 'issue-triage',
-            issueNumber: ctx.issueNumber,
-            trigger: ctx.triggerType,
-            error: error instanceof Error ? error.message : String(error),
-            durationMs: performance.now() - startedAt,
-        });
-        if (ctx.triggerType === 'auto' && !triageCommentPosted) {
-            await deleteAutoTriagePlaceholder({
+        finally {
+            await removeIssueCommentReactionIfPresent({
                 octokit: writeOctokit,
-                ctx,
-                reason: 'auto_triage_failed_before_final_comment',
+                owner: ctx.owner,
+                repo: ctx.repo,
+                commentId: ctx.commentId,
+                reactionId: ctx.reactionId,
+                warnMessage: 'Failed to remove issue triage reaction',
+                successMessage: 'Issue triage reaction removed',
+                logMeta: {
+                    task: 'issue-triage',
+                    reactionId: ctx.reactionId,
+                },
             });
-        }
-        if (!ctx.dryRun && ctx.triggerType !== 'auto') {
-            try {
-                const reason = error instanceof Error ? error.message : String(error);
-                await postFinalTriageComment(`${TRIAGE_MARKER}\n\n${buildTriageFailureMessage(reason)}`);
+            if (pendingFixMetric) {
+                await recordTaskMetrics({
+                    type: 'fix',
+                    repository: pendingFixMetric.repository,
+                    model: TRIAGE_PROVIDER,
+                    outcome: pendingFixMetric.outcome,
+                    durationMs: performance.now() - pendingFixMetric.startedAt,
+                });
             }
-            catch (commentError) {
-                logger.warn('Failed to post issue triage failure response', {
-                    task: 'issue-triage',
-                    issueNumber: ctx.issueNumber,
-                    error: commentError instanceof Error ? commentError.message : String(commentError),
+            if (shouldRecordTriageMetric) {
+                await recordTaskMetrics({
+                    type: 'triage',
+                    repository: triageMetricRepository,
+                    model: TRIAGE_PROVIDER,
+                    outcome: triageMetricOutcome,
+                    durationMs: triageDurationMs ?? performance.now() - startedAt,
                 });
             }
         }
-        throw error;
-    }
-    finally {
-        await removeIssueCommentReactionIfPresent({
-            octokit: writeOctokit,
-            owner: ctx.owner,
-            repo: ctx.repo,
-            commentId: ctx.commentId,
-            reactionId: ctx.reactionId,
-            warnMessage: 'Failed to remove issue triage reaction',
-            successMessage: 'Issue triage reaction removed',
-            logMeta: {
-                task: 'issue-triage',
-                reactionId: ctx.reactionId,
-            },
-        });
-        logger.info('Issue triage task finalized', {
-            task: 'issue-triage',
-            issueNumber: ctx.issueNumber,
-            durationMs: performance.now() - startedAt,
-        });
-        if (pendingFixMetric) {
-            await recordTaskMetrics({
-                type: 'fix',
-                repository: pendingFixMetric.repository,
-                model: TRIAGE_PROVIDER,
-                outcome: pendingFixMetric.outcome,
-                durationMs: performance.now() - pendingFixMetric.startedAt,
-            });
-        }
-        if (shouldRecordTriageMetric) {
-            await recordTaskMetrics({
-                type: 'triage',
-                repository: triageMetricRepository,
-                model: TRIAGE_PROVIDER,
-                outcome: triageMetricOutcome,
-                durationMs: triageDurationMs ?? performance.now() - startedAt,
-            });
-        }
-    }
+    });
 }
 async function main() {
     try {