@todoist/doistbot-cli 0.0.0-stage → 1.0.16

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

@@ -0,0 +1,59 @@
+import { repositoryKey, repositorySandboxProfile, SANDBOX_PROFILES } from 'doistbot-issue-routing';
+function readSelection() {
+    if (!process.env.SANDBOX_SELECTION)
+        return undefined;
+    const selection = JSON.parse(process.env.SANDBOX_SELECTION);
+    function strings(value) {
+        return Array.isArray(value) && value.every((item) => typeof item === 'string');
+    }
+    if (!selection ||
+        !strings(selection.repositories) ||
+        !strings(selection.labels) ||
+        !strings(selection.verificationLimits) ||
+        typeof selection.reason !== 'string' ||
+        (selection.profile !== 'legacy' &&
+            (!SANDBOX_PROFILES.includes(selection.profile) || typeof selection.image !== 'string')))
+        throw new Error('Invalid sandbox selection.');
+    return selection;
+}
+/** Check image identity only. Repo setup and required checks belong to issue #524. */
+export function sandboxEnvironmentError(repository) {
+    let selection;
+    try {
+        selection = readSelection();
+    }
+    catch {
+        return 'Invalid sandbox selection.';
+    }
+    if (!selection)
+        return undefined;
+    if (!selection.repositories.some((candidate) => repositoryKey(candidate) === repositoryKey(repository)))
+        return 'Fix target is outside the recorded sandbox scope.';
+    // Mixed scopes deliberately retain the existing image and autofix behavior.
+    if (selection.profile === 'legacy')
+        return undefined;
+    const profile = repositorySandboxProfile(repository, selection.labels);
+    if (selection.profile !== profile ||
+        process.env.SANDBOX_PROFILE !== profile ||
+        process.env.SANDBOX_IMAGE_ID !== selection.image)
+        return 'Unsupported fix environment: target needs a different image. Cross-image fix dispatch is not enabled.';
+    return undefined;
+}
+export function describeSandboxEnvironment() {
+    let selection;
+    try {
+        selection = readSelection();
+    }
+    catch {
+        return '\n\nSandbox selection is invalid; automatic fixes are unavailable.';
+    }
+    if (!selection)
+        return '';
+    const tools = {
+        legacy: 'Git, gh, rg, curl, and Node are available. Check availability before using other tools.',
+        web: 'Git, gh, rg, curl, pup, sentry, Node, npm, pnpm, Yarn, Bun, Chromium, and Playwright are installed.',
+        python: 'Git, gh, rg, curl, pup, sentry, Python, uv, Poetry, pip, and native build tools are installed.',
+        android: 'Git, gh, rg, curl, pup, sentry, Java, Kotlin, Android SDK, Chromium, and Playwright are installed.',
+    };
+    return `\n\n## Sandbox environment\nProfile: ${selection.profile}. ${selection.reason}\n${tools[selection.profile]}\n${selection.verificationLimits.join('\n')}\nReport only checks actually performed.`;
+}

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

@@ -0,0 +1,86 @@
+import { spawnSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { extractIssueLabelNames } from 'doistbot-issue-routing';
+import { App } from 'octokit';
+import { REPOS_SUBDIR, WORKSPACE_DIR } from '../../core/environment.js';
+import { gitAuthEnv, GITHUB_HTTPS_REWRITE_ARGS } from '../../core/git-auth.js';
+import { logger } from '../../core/logging.js';
+import { resolveWriteOctokit } from '../../core/shared.js';
+import { resolveInstallationIdForRepo } from './pr-creator.js';
+export { TRIAGE_MARKER } from './markers.js';
+export function getIssueUrl(owner, repo, issueNumber) {
+    return `https://github.com/${owner}/${repo}/issues/${issueNumber}`;
+}
+export function extractLabelNames(labels) {
+    return extractIssueLabelNames(labels);
+}
+export function prepareWorkspaceReposDirectory() {
+    const reposDir = path.join(WORKSPACE_DIR, REPOS_SUBDIR);
+    fs.mkdirSync(reposDir, { recursive: true });
+    return reposDir;
+}
+export async function createGitHubClients(ctx) {
+    const app = new App({
+        appId: ctx.appId,
+        privateKey: ctx.privateKey,
+    });
+    const readOctokit = await app.getInstallationOctokit(ctx.installationId);
+    const writeOctokit = resolveWriteOctokit({
+        githubToken: ctx.githubToken,
+        fallbackOctokit: readOctokit,
+    });
+    return { app, readOctokit, writeOctokit };
+}
+export { fetchIssue, fetchIssueComments, } from '../../core/github-issues.js';
+export async function cloneRepository({ app, repository, reposDir, fallbackInstallationId, }) {
+    const installationId = await resolveInstallationIdForRepo({
+        app,
+        owner: repository.owner,
+        repo: repository.repo,
+        fallbackInstallationId,
+    });
+    const auth = (await app.octokit.auth({
+        type: 'installation',
+        installationId,
+    }));
+    const localPath = path.join(reposDir, repository.repo);
+    const repoUrl = `https://github.com/${repository.owner}/${repository.repo}.git`;
+    logger.info('Repository clone starting', {
+        task: 'issue-triage',
+        repository: repository.fullName,
+        localPath,
+    });
+    const result = spawnSync('git', [
+        ...GITHUB_HTTPS_REWRITE_ARGS,
+        'clone',
+        '--depth',
+        '50',
+        '--recurse-submodules',
+        '--shallow-submodules',
+        repoUrl,
+        localPath,
+    ], {
+        encoding: 'utf8',
+        stdio: 'pipe',
+        env: gitAuthEnv(auth.token),
+    });
+    if (result.error) {
+        throw new Error(`Failed to clone ${repository.fullName}: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        const stderrPreview = (result.stderr ?? '').trim().slice(0, 500);
+        const details = stderrPreview || `git exited with status ${result.status}`;
+        throw new Error(`Failed to clone ${repository.fullName}: ${details}`);
+    }
+    logger.info('Repository clone completed', {
+        task: 'issue-triage',
+        repository: repository.fullName,
+        stdoutBytes: (result.stdout ?? '').length,
+        stderrBytes: (result.stderr ?? '').length,
+    });
+    return {
+        repository,
+        localPath,
+    };
+}

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

@@ -0,0 +1,102 @@
+import { logger } from '../../core/logging.js';
+import { withPhase } from '../../core/tracing.js';
+import { MAX_TRIAGE_COMMENT_CHARS, TRIAGE_MARKER } from './markers.js';
+export async function postIssueComment(ctx, octokit, body, options = {}) {
+    const marker = options.marker;
+    const placeholderCommentId = options.placeholderCommentId;
+    const bodyWithMarker = marker && !body.includes(marker) ? `${marker}\n\n${body}` : body;
+    if (bodyWithMarker.length > MAX_TRIAGE_COMMENT_CHARS) {
+        throw new Error(`Issue comment exceeds ${MAX_TRIAGE_COMMENT_CHARS} characters.`);
+    }
+    if (ctx.dryRun) {
+        logger.info('Issue triage dry run side effect skipped', {
+            task: 'issue-triage',
+            action: 'would_post_comment',
+            issueNumber: ctx.issueNumber,
+            marker,
+            bodyChars: bodyWithMarker.length,
+            placeholderCommentId,
+        });
+        process.stdout.write(`${bodyWithMarker}\n`);
+        return;
+    }
+    let updated = false;
+    if (placeholderCommentId) {
+        try {
+            await octokit.rest.issues.updateComment({
+                owner: ctx.owner,
+                repo: ctx.repo,
+                comment_id: placeholderCommentId,
+                body: bodyWithMarker,
+            });
+            updated = true;
+        }
+        catch (error) {
+            logger.warn('Failed to update placeholder comment, falling back to new comment', {
+                task: 'issue-triage',
+                commentId: placeholderCommentId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    if (!updated) {
+        await octokit.rest.issues.createComment({
+            owner: ctx.owner,
+            repo: ctx.repo,
+            issue_number: ctx.issueNumber,
+            body: bodyWithMarker,
+        });
+    }
+}
+export async function postTriageOutput(params) {
+    await withPhase('triage.side-effects', { 'comment.body.length': params.body.length }, async () => {
+        await postIssueComment(params.ctx, params.octokit, params.body, {
+            marker: TRIAGE_MARKER,
+            placeholderCommentId: params.ctx.placeholderCommentId,
+        });
+    });
+}
+export async function deleteIssueComment(ctx, octokit, commentId, options = {}) {
+    if (ctx.dryRun) {
+        logger.info('Issue triage dry run side effect skipped', {
+            task: 'issue-triage',
+            action: 'would_delete_comment',
+            issueNumber: ctx.issueNumber,
+            marker: options.marker,
+            commentId,
+            reason: options.reason,
+        });
+        return;
+    }
+    await octokit.rest.issues.deleteComment({
+        owner: ctx.owner,
+        repo: ctx.repo,
+        comment_id: commentId,
+    });
+}
+export async function deleteAutoTriagePlaceholder({ octokit, ctx, reason, }) {
+    if (ctx.triggerType !== 'auto' || !ctx.placeholderCommentId) {
+        return;
+    }
+    try {
+        await deleteIssueComment(ctx, octokit, ctx.placeholderCommentId, {
+            marker: TRIAGE_MARKER,
+            reason,
+        });
+        logger.info('Auto issue triage placeholder comment deleted', {
+            task: 'issue-triage',
+            issueNumber: ctx.issueNumber,
+            placeholderCommentId: ctx.placeholderCommentId,
+            reason,
+        });
+    }
+    catch (error) {
+        logger.warn('Failed to delete auto issue triage placeholder comment', {
+            task: 'issue-triage',
+            issueNumber: ctx.issueNumber,
+            placeholderCommentId: ctx.placeholderCommentId,
+            reason,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}

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

@@ -0,0 +1,442 @@
+import { performance } from 'node:perf_hooks';
+import { SpanStatusCode } from '@opentelemetry/api';
+import { recordTaskMetrics } from '../../core/datadog-metrics.js';
+import { WORKSPACE_DIR } from '../../core/environment.js';
+import { logger } from '../../core/logging.js';
+import { removeIssueCommentReactionIfPresent } from '../../core/reactions.js';
+import { withPhase } from '../../core/tracing.js';
+import { cloneTriageRepositories } from './clone.js';
+import { loadTriageContext, parseIssueTriageContext } from './context.js';
+import { postAutoFixFailureComment, shouldAttemptFix, shouldPostAutoFixFailureComment, } from './fix-attempt.js';
+import { runConfiguredFix } from './fix-dispatch.js';
+import { invokeTriageModel } from './model.js';
+import { buildTriageFailureMessage, buildUnresolvedLabelsOutput, validateTriageOutput, } from './output.js';
+import { buildReportCompactionPrompt, buildTriagePrompt } from './prompt.js';
+import { allRepositoriesAllow, createRepoConfigLoader, isAutoTriageEnabled } from './repo-config.js';
+import { readTriageHistory } from './report-history.js';
+import { resolveTriageScope } from './resolution.js';
+import { buildHeroRoutingComment, canRouteToHeroGroup, findAutoRoutedAssignees, postTriageRouting, shouldPostHeroRoutingComment, } from './routing.js';
+import { createGitHubClients, getIssueUrl, prepareWorkspaceReposDirectory } from './shared.js';
+import { deleteAutoTriagePlaceholder, postTriageOutput } from './side-effects.js';
+const TRIAGE_PROVIDER = 'openai';
+export async function runIssueTriage(ctx) {
+    if (ctx.triggerType === 'auto') {
+        return runAutoIssueTriage(ctx);
+    }
+    return runManualIssueTriage(ctx);
+}
+export async function runManualIssueTriage(ctx) {
+    return runIssueTriagePipeline(ctx, {
+        routeUnresolvedLabels: false,
+    });
+}
+export async function runAutoIssueTriage(ctx) {
+    return runIssueTriagePipeline(ctx, {
+        routeUnresolvedLabels: true,
+    });
+}
+async function runIssueTriagePipeline(ctx, mode) {
+    const startedAt = performance.now();
+    let triageMetricOutcome = 'failure';
+    const triageMetricRepository = `${ctx.owner}/${ctx.repo}`;
+    let triageDurationMs = null;
+    let pendingFixMetric = null;
+    // Temporary during auto-triage rollout: repo opt-out is an intentional skip,
+    // not triage work, so avoid reporting it as a success or failure.
+    let shouldRecordTriageMetric = true;
+    let triageCommentPosted = false;
+    logger.setBaseContext({
+        deliveryId: ctx.deliveryId,
+        repository: `${ctx.owner}/${ctx.repo}`,
+        issueNumber: ctx.issueNumber,
+    });
+    // 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',
+        '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,
+    }, 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 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,
+                            summary: unresolvedBody,
+                        }),
+                    });
+                }
+                triageDurationMs = performance.now() - startedAt;
+                return;
+            }
+            const getCachedRepoConfig = createRepoConfigLoader({
+                octokit: readOctokit,
+                logger,
+            });
+            if (ctx.triggerType === 'auto') {
+                const enableAutoTriage = await allRepositoriesAllow({
+                    repositories: resolution.repositories,
+                    loadRepoConfig: getCachedRepoConfig,
+                    isEnabled: isAutoTriageEnabled,
+                    feature: 'auto_triage',
+                    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),
+                    });
+                    await deleteAutoTriagePlaceholder({
+                        octokit: writeOctokit,
+                        ctx,
+                        reason: 'auto_triage_disabled',
+                    });
+                    return;
+                }
+            }
+            const reposDir = prepareWorkspaceReposDirectory();
+            const { clonedRepositories, failedRepositories } = await cloneTriageRepositories({
+                app,
+                reposDir,
+                repositories: resolution.repositories,
+                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.',
+                });
+                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,
+                    failedRepositories,
+                });
+            }
+            const issueInstallationAuth = (await app.octokit.auth({
+                type: 'installation',
+                installationId: ctx.installationId,
+            }));
+            const issueUrl = getIssueUrl(ctx.owner, ctx.repo, ctx.issueNumber);
+            const history = readTriageHistory(comments, issueUrl);
+            const prompt = buildTriagePrompt({
+                issueUrl,
+                repositories: clonedRepositories,
+                history,
+            });
+            const triageResult = await invokeTriageModel({
+                prompt,
+                apiKey: ctx.openaiApiKey,
+                cwd: WORKSPACE_DIR,
+                extraEnv: {
+                    GH_TOKEN: issueInstallationAuth.token,
+                },
+                thinkingLevel: 'xhigh',
+            });
+            if (!triageResult.ok) {
+                await postFinalTriageComment(buildTriageFailureMessage(triageResult.error));
+                rootSpan.setStatus({ code: SpanStatusCode.ERROR, message: triageResult.error });
+                triageDurationMs = performance.now() - startedAt;
+                return;
+            }
+            const validationContext = {
+                issueUrl,
+                repositories: clonedRepositories.map(({ repository }) => repository.fullName),
+                history,
+            };
+            let validated = await validateTriageOutput({
+                ...validationContext,
+                rawOutput: triageResult.output,
+            });
+            if (!validated.ok && validated.reason === 'too-long') {
+                const { decision, reinvestigation } = validated.analysis;
+                const compacted = await invokeTriageModel({
+                    prompt: buildReportCompactionPrompt(triageResult.output),
+                    apiKey: ctx.openaiApiKey,
+                    cwd: WORKSPACE_DIR,
+                    thinkingLevel: 'low',
+                    timeoutMs: 2 * 60 * 1000,
+                    phaseName: 'triage.report-compaction',
+                    capabilityPreset: 'none',
+                });
+                if (compacted.ok) {
+                    validated = await validateTriageOutput({
+                        ...validationContext,
+                        rawOutput: compacted.output,
+                        expectedMetadata: { decision, reinvestigation },
+                    });
+                }
+            }
+            if (!validated.ok) {
+                await postFinalTriageComment(validated.commentOutput);
+                triageDurationMs = performance.now() - startedAt;
+                throw new Error(validated.error);
+            }
+            await postFinalTriageComment(validated.commentOutput);
+            triageMetricOutcome = 'success';
+            triageDurationMs = performance.now() - startedAt;
+            const fixAssessment = validated.assessment;
+            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 primaryRepo = resolution.repositories.length === 1
+                    ? resolution.repositories[0]
+                    : undefined;
+                let autoRoutedAssignees = [];
+                if (canRouteToHeroGroup(labelNames, primaryRepo)) {
+                    try {
+                        autoRoutedAssignees = await findAutoRoutedAssignees({
+                            octokit: readOctokit,
+                            ctx,
+                        });
+                    }
+                    catch (error) {
+                        logger.warn('Failed to read auto-routed assignees; routing to Hero', {
+                            task: 'issue-triage',
+                            issueNumber: ctx.issueNumber,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                    logger.info('Triage routing target resolved', {
+                        task: 'issue-triage',
+                        issueNumber: ctx.issueNumber,
+                        autoRoutedAssignees,
+                    });
+                }
+                const routingComment = buildHeroRoutingComment({
+                    labels: labelNames,
+                    primaryRepo,
+                    summary: validated.report.analysis.summary,
+                    assessment: fixAssessment,
+                    resolvedRepos: resolution.repositories.map((repo) => repo.fullName),
+                    autoRoutedAssignees,
+                });
+                await postTriageRouting({
+                    octokit: writeOctokit,
+                    ctx,
+                    body: routingComment,
+                });
+            }
+            const loggingPlanAlreadyPending = fixAssessment.classification === 'logs-needed' &&
+                validated.report.pendingLoggingReportId !== validated.report.id;
+            if (shouldAttemptFix(fixAssessment) && !loggingPlanAlreadyPending) {
+                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,
+                    assigneeReview: {
+                        assignees: (issue.assignees ?? []).map((assignee) => assignee.login),
+                        membershipOctokit: readOctokit,
+                    },
+                });
+                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,
+                            ...('prNumber' in fixResult
+                                ? { prNumber: fixResult.prNumber }
+                                : {}),
+                            ...('interruption' in fixResult
+                                ? { interruption: fixResult.interruption }
+                                : {}),
+                        });
+                    }
+                    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,
+                    attempted: false,
+                });
+            }
+        }
+        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,
+                trigger: ctx.triggerType,
+                error: error instanceof Error ? error.message : String(error),
+                durationMs: performance.now() - startedAt,
+            });
+            if (ctx.triggerType === 'auto' && !triageCommentPosted) {
+                await deleteAutoTriagePlaceholder({
+                    octokit: writeOctokit,
+                    ctx,
+                    reason: 'auto_triage_failed_before_final_comment',
+                });
+            }
+            if (!ctx.dryRun && ctx.triggerType !== 'auto' && !triageCommentPosted) {
+                try {
+                    const reason = error instanceof Error ? error.message : String(error);
+                    await postFinalTriageComment(buildTriageFailureMessage(reason));
+                }
+                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),
+                    });
+                }
+            }
+            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,
+                },
+            });
+            if (pendingFixMetric) {
+                await recordTaskMetrics({
+                    type: 'fix',
+                    repository: pendingFixMetric.repository,
+                    model: TRIAGE_PROVIDER,
+                    outcome: pendingFixMetric.outcome,
+                    durationMs: performance.now() - pendingFixMetric.startedAt,
+                    sandboxVariant: ctx.sandboxVariant,
+                });
+            }
+            if (shouldRecordTriageMetric) {
+                await recordTaskMetrics({
+                    type: 'triage',
+                    repository: triageMetricRepository,
+                    model: TRIAGE_PROVIDER,
+                    outcome: triageMetricOutcome,
+                    durationMs: triageDurationMs ?? performance.now() - startedAt,
+                    sandboxVariant: ctx.sandboxVariant,
+                });
+            }
+        }
+    });
+}
+async function main() {
+    try {
+        await runIssueTriage(parseIssueTriageContext());
+    }
+    catch (error) {
+        logger.error('Issue triage task failed in main', {
+            task: 'issue-triage',
+            error: error instanceof Error ? error.message : String(error),
+        });
+        process.exitCode = 1;
+    }
+}
+if (process.env.VITEST !== 'true' && process.env.TASK_TYPE === 'issue-triage') {
+    main();
+}