@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/tasks/issue-triage/fix-loop/runners.js

@@ -0,0 +1,233 @@
+import { autofixFeedbackCommentMarker, iterationLabel } from 'doistbot-shared-contracts';
+import { logger } from '../../../core/logging.js';
+import { isFixLoopTerminal, ISSUE_FIX_INITIAL_STATE, isTerminal, next, } from './state-machine.js';
+const CI_FAILED_LABEL = 'doistbot:ci-failed';
+const NEEDS_HUMAN_LABEL = 'doistbot:needs-human';
+const AWAITING_CI_LABEL = 'doistbot:awaiting-ci';
+// Each terminal comment carries its outcome in the marker so retries update
+// the same reaction target and closure tracking can classify the result.
+export const PR_FEEDBACK_FOOTER = '<sub>🤖🫵 Please, react 👍 or 👎 on this comment to rate this bot-authored PR.</sub>';
+function withFeedbackFooter(body) {
+    return `${body}\n\n${PR_FEEDBACK_FOOTER}`;
+}
+async function postNeedsHumanFeedbackComment(effects, prNumber, body = 'This PR needs human review.') {
+    await effects.postIssueComment({
+        prNumber,
+        marker: autofixFeedbackCommentMarker('needs_human'),
+        body: withFeedbackFooter(body),
+    });
+}
+function formatFailedChecks(checks) {
+    return checks.map((c) => (c.url ? `- [${c.name}](${c.url})` : `- ${c.name}`)).join('\n');
+}
+function createEventApplier(onTransition) {
+    return (state, event) => {
+        const nextState = next(state, event);
+        onTransition?.({ from: state, event, to: nextState });
+        return nextState;
+    };
+}
+/**
+ * Drives the fix loop state machine to a terminal-for-fix-loop state
+ * (PUSHED_AWAITING_CI, DONE_PR_UPDATED, or DONE_NEEDS_HUMAN). For the
+ * doistbot_fix_ci policy, the promotion flow takes over from
+ * PUSHED_AWAITING_CI on the check_suite webhook; for the `none` policy
+ * (address_review), the workflow terminates in-process at DONE_PR_UPDATED.
+ */
+export async function runFixLoop(input) {
+    const { effects, initial, onTransition } = input;
+    const applyEvent = createEventApplier(onTransition);
+    let state = initial ?? ISSUE_FIX_INITIAL_STATE;
+    while (!isFixLoopTerminal(state)) {
+        await input.beforeStep?.(state);
+        if (state.kind === 'AWAITING_FIRST_FIX' || state.kind === 'ITERATING') {
+            const fixInput = state.kind === 'ITERATING'
+                ? {
+                    iteration: state.iteration,
+                    prevHeadSha: state.prevHeadSha,
+                    previousFindings: state.findings,
+                }
+                : { iteration: 0 };
+            const fix = await effects.runFix(fixInput);
+            // runFixCore validates the diff internally and returns ok:false
+            // (with a "Diff validation failed: ..." reason) when invalid; no
+            // need for the runner to re-validate.
+            if (!fix.ok) {
+                state = applyEvent(state, { kind: 'FIX_FAILED', reason: fix.reason });
+                continue;
+            }
+            const pushInput = {
+                iteration: fixInput.iteration,
+                diff: fix.diff,
+                codexOutput: fix.codexOutput,
+                generatedPRTitle: fix.generatedPRTitle,
+                generatedPRBody: fix.generatedPRBody,
+            };
+            if (state.kind === 'ITERATING') {
+                pushInput.branch = state.branch;
+            }
+            const push = await effects.pushCommit(pushInput);
+            const prNumber = state.kind === 'ITERATING' ? state.prNumber : push.prNumber;
+            if (prNumber === undefined) {
+                state = applyEvent(state, {
+                    kind: 'FIX_FAILED',
+                    reason: 'Fix push did not produce a PR number.',
+                });
+                continue;
+            }
+            state = applyEvent(state, {
+                kind: 'FIX_PUSHED',
+                headSha: push.headSha,
+                branch: push.branch,
+                prNumber,
+            });
+            continue;
+        }
+        if (state.kind === 'REVIEWING') {
+            const reviewInput = {
+                iteration: state.iteration,
+            };
+            if (state.reviewBaseSha !== undefined) {
+                reviewInput.reviewBaseSha = state.reviewBaseSha;
+            }
+            const result = await effects.runReview(reviewInput);
+            if (result.kind === 'unverified') {
+                state = applyEvent(state, { kind: 'REVIEW_UNVERIFIED', reason: result.reason });
+            }
+            else {
+                state = applyEvent(state, { kind: 'REVIEW_COMPLETE', findings: result.findings });
+            }
+            continue;
+        }
+        // Defensive: any other intermediate state is a bug.
+        throw new Error(`runFixLoop: unexpected state ${state.kind}`);
+    }
+    await input.beforeFinish?.(state);
+    if (state.kind === 'PUSHED_AWAITING_CI' &&
+        state.iteration !== undefined &&
+        state.promotionPolicy.kind === 'doistbot_fix_ci') {
+        // Local review accepted the patch; hand off to CI. awaiting-ci must
+        // NOT appear earlier: a fast CI suite could otherwise finalize checks
+        // for a patch the bot is still reviewing or about to iterate on.
+        // Assignee-reviewed PRs may already be ready, but still need this handoff.
+        // The iter-N label event also triggers reconciliation if CI already
+        // finished before awaiting-ci existed. Keep both labels in one call.
+        await tryApplyLabels(effects, state.prNumber, [
+            AWAITING_CI_LABEL,
+            iterationLabel(state.iteration),
+        ]);
+    }
+    if (state.kind === 'DONE_NEEDS_HUMAN' && state.prNumber !== undefined) {
+        await postNeedsHumanFeedbackComment(effects, state.prNumber);
+    }
+    return state;
+}
+async function tryApplyLabels(effects, prNumber, labels) {
+    try {
+        await effects.applyLabels({ prNumber, labels });
+    }
+    catch (error) {
+        logger.error('fix-loop: failed to apply tracking labels to PR', {
+            task: 'fix-loop',
+            pr_number: prNumber,
+            labels,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+/**
+ * Drives the promotion flow from PUSHED_AWAITING_CI through CI verification.
+ * Terminates at DONE_PROMOTED or DONE_NEEDS_HUMAN, or returns the unchanged
+ * PUSHED_AWAITING_CI state when CI is still pending (the caller re-invokes
+ * on the next webhook delivery).
+ */
+export async function runPromotionFlow(effects, input) {
+    // Only the doistbot auto-fix workflow ever reaches CI promotion; the
+    // address_review path terminates at DONE_PR_UPDATED in-process and never
+    // invokes this entry point. The upstream webhook handler is responsible
+    // for filtering (e.g. by PR label) so this function is only called for
+    // issue_fix PRs.
+    const initial = {
+        kind: 'PUSHED_AWAITING_CI',
+        headSha: input.headSha,
+        prNumber: input.prNumber,
+        intent: 'issue_fix',
+        promotionPolicy: { kind: 'doistbot_fix_ci' },
+        maxIterations: 2,
+    };
+    // The webhook handler's atomic claim removed AWAITING_CI_LABEL before
+    // dispatching this task. Every exit path from here must either re-arm
+    // the label (pending CI, side-effect failure) or leave it off
+    // intentionally (terminal success / human escalation). Each side effect
+    // below is idempotent on GitHub's side, so a future webhook redelivery
+    // can safely re-enter promotion.
+    try {
+        const ciStatus = await effects.checkCIStatus(input.headSha);
+        const state = next(initial, { kind: 'CI_RESULT', status: ciStatus });
+        if (state.kind === 'PUSHED_AWAITING_CI') {
+            // CI still in flight. Re-arm so the next check_suite event can
+            // re-claim and re-dispatch.
+            await effects.applyLabels({
+                prNumber: input.prNumber,
+                labels: [AWAITING_CI_LABEL],
+            });
+            return state;
+        }
+        if (state.kind === 'DONE_PROMOTED') {
+            await effects.requestHeroReview(input.prNumber);
+            await effects.applyAskLabel(input.prNumber);
+            // Publish the successful validation outcome before making a
+            // remaining draft ready, so an immediate merge cannot beat the
+            // feedback comment and closure tracking.
+            await effects.postIssueComment({
+                prNumber: input.prNumber,
+                marker: autofixFeedbackCommentMarker('success'),
+                // This comment doubles as the thumbs-feedback prompt: closure
+                // tracking reads 👍/👎 reactions on this exact comment (located
+                // via the marker above) when the PR closes. Keep the reaction
+                // ask on the comment people are invited to react to.
+                body: withFeedbackFooter('CI passed. Review has been requested; any remaining draft status will be cleared.'),
+            });
+            await effects.promoteToReady(input.prNumber);
+            return state;
+        }
+        if (state.kind === 'DONE_NEEDS_HUMAN') {
+            const labels = ciStatus.kind === 'failed'
+                ? [CI_FAILED_LABEL, NEEDS_HUMAN_LABEL]
+                : [NEEDS_HUMAN_LABEL];
+            await effects.applyLabels({ prNumber: input.prNumber, labels });
+            const body = ciStatus.kind === 'failed'
+                ? `CI failed for this fix attempt. Failing checks:\n${formatFailedChecks(ciStatus.failedChecks)}\n\nMarking this for human review.`
+                : ciStatus.kind === 'no_checks'
+                    ? 'No CI checks ran on this PR — please verify manually before merging.'
+                    : 'This PR needs human review.';
+            await postNeedsHumanFeedbackComment(effects, input.prNumber, body);
+            return state;
+        }
+        if (!isTerminal(state)) {
+            throw new Error(`runPromotionFlow: unexpected non-terminal state ${state.kind}`);
+        }
+        return state;
+    }
+    catch (error) {
+        await reapplyAwaitingCi(effects, input.prNumber, error);
+        throw error;
+    }
+}
+async function reapplyAwaitingCi(effects, prNumber, originalError) {
+    try {
+        await effects.applyLabels({ prNumber, labels: [AWAITING_CI_LABEL] });
+    }
+    catch (rearmError) {
+        // The original error is the primary failure operators need to see;
+        // surface the re-arm failure alongside it so the recovery hint
+        // ("awaiting-ci is still missing, redelivery will not retry") is
+        // visible, but don't replace the cause.
+        logger.error('runPromotionFlow: failed to re-apply awaiting-ci after side-effect failure', {
+            task: 'fix-loop-promotion',
+            pr_number: prNumber,
+            original_error: originalError instanceof Error ? originalError.message : String(originalError),
+            rearm_error: rearmError instanceof Error ? rearmError.message : String(rearmError),
+        });
+    }
+}

package/sandbox/dist/tasks/issue-triage/fix-loop/state-machine.js

@@ -0,0 +1,171 @@
+export const ISSUE_FIX_INITIAL_STATE = {
+    kind: 'AWAITING_FIRST_FIX',
+    intent: 'issue_fix',
+    promotionPolicy: { kind: 'doistbot_fix_ci' },
+    maxIterations: 2,
+};
+export function isTerminal(state) {
+    return (state.kind === 'DONE_PROMOTED' ||
+        state.kind === 'DONE_PR_UPDATED' ||
+        state.kind === 'DONE_NEEDS_HUMAN');
+}
+export function isFixLoopTerminal(state) {
+    return isTerminal(state) || state.kind === 'PUSHED_AWAITING_CI';
+}
+function blockers(findings) {
+    return findings.filter((f) => f.severity === 'P0' || f.severity === 'P1');
+}
+function invariant(state, event) {
+    throw new Error(`fix-loop: invalid event ${event.kind} for state ${state.kind}`);
+}
+function withMeta(base, meta) {
+    const out = { ...base };
+    if (meta.prNumber !== undefined)
+        out.prNumber = meta.prNumber;
+    if (meta.branch !== undefined)
+        out.branch = meta.branch;
+    return out;
+}
+function header(state) {
+    return {
+        intent: state.intent,
+        promotionPolicy: state.promotionPolicy,
+        maxIterations: state.maxIterations,
+    };
+}
+export function next(state, event) {
+    switch (state.kind) {
+        case 'AWAITING_FIRST_FIX': {
+            if (event.kind === 'FIX_PUSHED') {
+                return {
+                    kind: 'REVIEWING',
+                    iteration: 0,
+                    headSha: event.headSha,
+                    branch: event.branch,
+                    prNumber: event.prNumber,
+                    ...header(state),
+                };
+            }
+            if (event.kind === 'FIX_FAILED') {
+                return {
+                    kind: 'DONE_NEEDS_HUMAN',
+                    reason: event.reason,
+                    findings: [],
+                    ...header(state),
+                };
+            }
+            return invariant(state, event);
+        }
+        case 'REVIEWING': {
+            if (event.kind === 'REVIEW_UNVERIFIED') {
+                return withMeta({
+                    kind: 'DONE_NEEDS_HUMAN',
+                    reason: `Review unverified: ${event.reason}`,
+                    findings: [],
+                    ...header(state),
+                }, { prNumber: state.prNumber, branch: state.branch });
+            }
+            if (event.kind !== 'REVIEW_COMPLETE')
+                return invariant(state, event);
+            const blocking = blockers(event.findings);
+            if (blocking.length > 0) {
+                if (state.iteration + 1 < state.maxIterations) {
+                    return {
+                        kind: 'ITERATING',
+                        iteration: state.iteration + 1,
+                        findings: blocking,
+                        prevHeadSha: state.headSha,
+                        branch: state.branch,
+                        prNumber: state.prNumber,
+                        ...header(state),
+                    };
+                }
+                return withMeta({
+                    kind: 'DONE_NEEDS_HUMAN',
+                    reason: 'P0/P1 findings persisting after retry — manual review required',
+                    findings: event.findings,
+                    ...header(state),
+                }, { prNumber: state.prNumber, branch: state.branch });
+            }
+            if (state.promotionPolicy.kind === 'doistbot_fix_ci') {
+                return {
+                    kind: 'PUSHED_AWAITING_CI',
+                    iteration: state.iteration,
+                    headSha: state.headSha,
+                    prNumber: state.prNumber,
+                    branch: state.branch,
+                    ...header(state),
+                };
+            }
+            return withMeta({
+                kind: 'DONE_PR_UPDATED',
+                headSha: state.headSha,
+                ...header(state),
+            }, { prNumber: state.prNumber, branch: state.branch });
+        }
+        case 'ITERATING': {
+            if (event.kind === 'FIX_PUSHED') {
+                return {
+                    kind: 'REVIEWING',
+                    iteration: state.iteration,
+                    headSha: event.headSha,
+                    reviewBaseSha: state.prevHeadSha,
+                    branch: event.branch,
+                    prNumber: event.prNumber,
+                    ...header(state),
+                };
+            }
+            if (event.kind === 'FIX_FAILED') {
+                return withMeta({
+                    kind: 'DONE_NEEDS_HUMAN',
+                    reason: event.reason,
+                    findings: state.findings,
+                    ...header(state),
+                }, { prNumber: state.prNumber, branch: state.branch });
+            }
+            return invariant(state, event);
+        }
+        case 'PUSHED_AWAITING_CI': {
+            if (event.kind !== 'CI_RESULT')
+                return invariant(state, event);
+            const status = event.status;
+            // Ignore CI results carrying a SHA other than our current head.
+            // GitHub can deliver a check_suite for an earlier push after we
+            // have already pushed an iter-1 commit, in which case acting on
+            // the stale verdict would promote or escalate based on a SHA we
+            // have already superseded.
+            if (status.headSha !== state.headSha) {
+                return state;
+            }
+            if (status.kind === 'passed') {
+                return withMeta({
+                    kind: 'DONE_PROMOTED',
+                    headSha: status.headSha,
+                    ...header(state),
+                }, { prNumber: state.prNumber, branch: state.branch });
+            }
+            if (status.kind === 'failed') {
+                const failed = status.failedChecks.map((c) => c.name).join(', ');
+                return withMeta({
+                    kind: 'DONE_NEEDS_HUMAN',
+                    reason: `CI failed: ${failed || 'unknown checks'}`,
+                    findings: [],
+                    ...header(state),
+                }, { prNumber: state.prNumber, branch: state.branch });
+            }
+            if (status.kind === 'pending') {
+                return state;
+            }
+            return withMeta({
+                kind: 'DONE_NEEDS_HUMAN',
+                reason: 'No CI checks configured — manual review required',
+                findings: [],
+                ...header(state),
+            }, { prNumber: state.prNumber, branch: state.branch });
+        }
+        case 'DONE_PROMOTED':
+        case 'DONE_PR_UPDATED':
+        case 'DONE_NEEDS_HUMAN':
+            return invariant(state, event);
+    }
+}

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

@@ -0,0 +1,2 @@
+/** Per-attempt deadline for autofix signature checks, reviewer routing, and PR readiness. */
+export const GITHUB_REQUEST_TIMEOUT_MS = 15_000;

package/sandbox/dist/tasks/issue-triage/hero-group-map.js

@@ -0,0 +1,206 @@
+import { repositoryKey } from 'doistbot-issue-routing';
+import { normalizeScopedLabelValue, scopedLabelValue } from '../../core/label-parsing.js';
+import { APP_LABEL_ALIASES, findIntegrationRoute, findIssueRoute, findOwningRoutes, findRepositoryTarget as findRoutingRepositoryTarget, INTEGRATION_LABEL_ALIASES, PRODUCT_LABEL_ALIASES, PRODUCT_ROUTES, } from '../../core/repository-map.js';
+const HERO_GROUPS = {
+    'android-hero': { key: 'android-hero', mention: '@todoist/android-hero' },
+    'app-copy-hero': { key: 'app-copy-hero', mention: '@todoist/app-copy-hero' },
+    'apple-hero': { key: 'apple-hero', mention: '@todoist/apple-hero' },
+    'backend-hero': { key: 'backend-hero', mention: '@todoist/backend-hero' },
+    'brand-dev-hero': { key: 'brand-dev-hero', mention: '@todoist/brand-dev-hero' },
+    'cx-hero': { key: 'cx-hero', mention: '@todoist/cx-hero' },
+    dateist: { key: 'dateist', mention: '@amix' },
+    'design-brand-hero': { key: 'design-brand-hero', mention: '@todoist/design-brand-hero' },
+    'design-product-hero': {
+        key: 'design-product-hero',
+        mention: '@todoist/design-product-hero',
+    },
+    'desktop-hero': { key: 'desktop-hero', mention: '@todoist/desktop-hero' },
+    finance: { key: 'finance', mention: '@todoist/finance' },
+    'frontend-hero': { key: 'frontend-hero', mention: '@todoist/frontend-hero' },
+    platform: { key: 'platform', mention: '@todoist/platform' },
+    'product-hero': { key: 'product-hero', mention: '@todoist/product-hero' },
+};
+// Mirrored from Doist/Issues/.github/workflows/label-form-reports.yml on 2026-04-17.
+const TEAM_LABEL_TO_HERO = {
+    android: 'android-hero',
+    appcopy: 'app-copy-hero',
+    'app-copy': 'app-copy-hero',
+    apple: 'apple-hero',
+    backend: 'backend-hero',
+    brand: 'design-brand-hero',
+    branddev: 'brand-dev-hero',
+    'brand-dev': 'brand-dev-hero',
+    dateist: 'dateist',
+    desktop: 'desktop-hero',
+    designproduct: 'design-product-hero',
+    'design-product': 'design-product-hero',
+    finance: 'finance',
+    frontend: 'frontend-hero',
+    platform: 'platform',
+    product: 'product-hero',
+    support: 'cx-hero',
+};
+export const CX_HERO_MANUAL_HANDLE = HERO_GROUPS['cx-hero'].mention;
+/**
+ * Looks up a repository supported by issue routing.
+ */
+export function findRepositoryTarget(owner, repo) {
+    return findRoutingRepositoryTarget(owner, repo);
+}
+/**
+ * Derives the GitHub team slug for a PR from its configured issue route.
+ * Repositories that are unknown or belong to routes with different hero teams
+ * use cx-hero because the repository alone does not give enough context.
+ */
+export function resolveHeroTeamSlug(target) {
+    const group = resolveHeroGroup([], target);
+    if (!group || group.key === 'dateist') {
+        return 'cx-hero';
+    }
+    // The check above excluded `dateist`, so TS narrows group.key from
+    // HeroGroupKey to HeroTeamSlug here.
+    return group.key;
+}
+function resolveAppLabelAlias(value) {
+    return APP_LABEL_ALIASES[normalizeScopedLabelValue(value)];
+}
+function resolveIntegrationLabelAlias(value) {
+    return INTEGRATION_LABEL_ALIASES[normalizeScopedLabelValue(value)];
+}
+export function isKnownHeroRoutingLabel(label) {
+    const teamValue = scopedLabelValue(label, 'Team');
+    if (teamValue && TEAM_LABEL_TO_HERO[normalizeScopedLabelValue(teamValue)]) {
+        return true;
+    }
+    const integrationValue = scopedLabelValue(label, 'Integration');
+    if (integrationValue && resolveIntegrationLabelAlias(integrationValue)) {
+        return true;
+    }
+    const appValue = scopedLabelValue(label, 'App');
+    if (!appValue) {
+        return false;
+    }
+    const appLabel = resolveAppLabelAlias(appValue);
+    return (appLabel !== undefined &&
+        appLabel !== 'all' &&
+        Object.values(PRODUCT_ROUTES).some((routes) => routes.some((route) => route.id === appLabel)));
+}
+function resolveProduct(labels) {
+    const products = new Set();
+    for (const label of labels) {
+        const productValue = scopedLabelValue(label, 'Product');
+        if (!productValue) {
+            continue;
+        }
+        const product = PRODUCT_LABEL_ALIASES[normalizeScopedLabelValue(productValue)];
+        if (product) {
+            products.add(product);
+        }
+    }
+    return products.size === 1 ? products.values().next().value : undefined;
+}
+function resolveIntegrationHeroKeys(labels) {
+    const product = resolveProduct(labels);
+    const heroKeys = new Set();
+    for (const label of labels) {
+        const integrationValue = scopedLabelValue(label, 'Integration');
+        if (!integrationValue) {
+            continue;
+        }
+        const integration = resolveIntegrationLabelAlias(integrationValue);
+        if (!integration) {
+            continue;
+        }
+        const route = findIntegrationRoute(integration);
+        // An integration from another product is not in scope for this issue, so
+        // it must not contribute a hero the repository resolver would never pick.
+        if (product && route.product !== product) {
+            continue;
+        }
+        heroKeys.add(route.heroTeam);
+    }
+    return heroKeys;
+}
+function resolveAppRouteHeroKeys(labels) {
+    const routeIds = new Set();
+    for (const label of labels) {
+        const appValue = scopedLabelValue(label, 'App');
+        if (!appValue) {
+            continue;
+        }
+        const appLabel = resolveAppLabelAlias(appValue);
+        // `all` spans every route and `integration` names no route of its own —
+        // the accompanying `Integration:*` label supplies that hero instead.
+        if (appLabel && appLabel !== 'all' && appLabel !== 'integration') {
+            routeIds.add(appLabel);
+        }
+    }
+    const product = resolveProduct(labels);
+    const heroKeys = new Set();
+    for (const routeId of routeIds) {
+        const routes = product
+            ? [findIssueRoute(product, routeId)].filter((route) => route !== undefined)
+            : Object.values(PRODUCT_ROUTES)
+                .flat()
+                .filter((route) => route.id === routeId);
+        for (const route of routes) {
+            heroKeys.add(route.heroTeam);
+        }
+    }
+    return heroKeys;
+}
+export function resolveHeroGroup(labels, primaryRepo) {
+    const teamHeroKeys = new Set();
+    for (const label of labels) {
+        const teamValue = scopedLabelValue(label, 'Team');
+        if (!teamValue) {
+            continue;
+        }
+        const heroKey = TEAM_LABEL_TO_HERO[normalizeScopedLabelValue(teamValue)];
+        if (heroKey) {
+            teamHeroKeys.add(heroKey);
+        }
+    }
+    if (teamHeroKeys.size === 1) {
+        return HERO_GROUPS[teamHeroKeys.values().next().value];
+    }
+    if (teamHeroKeys.size > 1) {
+        return null;
+    }
+    const integrationHeroKeys = resolveIntegrationHeroKeys(labels);
+    if (integrationHeroKeys.size === 1) {
+        return HERO_GROUPS[integrationHeroKeys.values().next().value];
+    }
+    if (integrationHeroKeys.size > 1) {
+        return null;
+    }
+    const appHeroKeys = resolveAppRouteHeroKeys(labels);
+    if (appHeroKeys.size === 1) {
+        return HERO_GROUPS[appHeroKeys.values().next().value];
+    }
+    if (appHeroKeys.size > 1) {
+        return null;
+    }
+    if (primaryRepo) {
+        const repositoryHeroKeys = new Set(findOwningRoutes(primaryRepo).map((route) => route.heroTeam));
+        if (repositoryHeroKeys.size === 1) {
+            return HERO_GROUPS[repositoryHeroKeys.values().next().value];
+        }
+        if (repositoryHeroKeys.size > 1) {
+            return null;
+        }
+    }
+    return null;
+}
+/** The immutable branch retains Sentry ownership when a library has several owners. */
+export function sentryBranchHeroTeam(branch, target) {
+    if (!branch.startsWith('doistbot/auto-fix/sentry-'))
+        return undefined;
+    const match = /^doistbot\/auto-fix\/sentry-(todoist|comms)-([a-z]+)-[a-z0-9][a-z0-9-]*-[1-9][0-9]*-[1-9][0-9]*-[0-9]+$/.exec(branch);
+    const route = match
+        ? findIssueRoute(match[1] === 'todoist' ? 'Todoist' : 'Comms', match[2])
+        : undefined;
+    if (!route?.repositories.some((repo) => repositoryKey(repo.fullName) === repositoryKey(target.fullName)))
+        throw new Error('Sentry branch route does not match the target repository');
+    return route.heroTeam;
+}

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

@@ -0,0 +1,6 @@
+export const HERO_AUTOFIX_MARKER = '<!--doistbot-autofix-followup-->';
+export const ASSIGNEE_REVIEW_MARKER = '<!--doistbot-assignee-review-requested-->';
+export const FIX_LOOP_START_MARKER = '<!--doistbot-fixloop-start-->';
+export const AUTOFIX_FAILURE_MARKER = '<!--doistbot-autofix-failure-->';
+export const TRIAGE_MARKER = '<!--doistbot-issue-triage-->';
+export const MAX_TRIAGE_COMMENT_CHARS = 60_000;