@todoist/doistbot-cli 0.0.0-stage → 1.0.16

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

@@ -0,0 +1,47 @@
+import { getRepoConfig } from 'doistbot-repo-config';
+export function isAutoTriageEnabled(config) {
+    return config?.issue_triage?.enable_auto_triage !== false;
+}
+export function createRepoConfigLoader({ octokit, logger, }) {
+    const cache = new Map();
+    return async function loadRepoConfig(repository) {
+        const cached = cache.get(repository.fullName);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const config = (await getRepoConfig({
+            octokit,
+            owner: repository.owner,
+            repo: repository.repo,
+            logger,
+        })) ?? null;
+        cache.set(repository.fullName, config);
+        return config;
+    };
+}
+/**
+ * Returns true only when every repository allows the feature. Treats a config
+ * load error as an opt-out (fail closed) so transient GitHub API failures
+ * cannot silently override an explicit `enable_*: false`.
+ */
+export async function allRepositoriesAllow({ repositories, loadRepoConfig, isEnabled, feature, logger, }) {
+    for (const repository of repositories) {
+        let config;
+        try {
+            config = await loadRepoConfig(repository);
+        }
+        catch (error) {
+            logger.warn('Failed to load repo config; failing closed', {
+                component: 'issue-triage',
+                feature,
+                repository: repository.fullName,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+        if (!isEnabled(config)) {
+            return false;
+        }
+    }
+    return true;
+}

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

@@ -0,0 +1,77 @@
+import { readFileSync, realpathSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { CONFIG_FILE_PATH, getLocalRepoConfig } from 'doistbot-repo-config';
+import { hashAutofixInputs } from '../../core/autofix-verification.js';
+import { logger } from '../../core/logging.js';
+import { loadPromptTemplateFile, resolvePromptFile } from '../../core/prompt-template.js';
+const MAX_PROMPT_BYTES = 64 * 1024;
+function isWithin(root, file) {
+    const relative = path.relative(root, file);
+    return (relative !== '' &&
+        relative !== '..' &&
+        !relative.startsWith(`..${path.sep}`) &&
+        !path.isAbsolute(relative));
+}
+/** Read once before model execution; never cache repository files across runs. */
+export function loadRepositoryWorkflow(repoPath, phase) {
+    const config = getLocalRepoConfig({ workspaceDir: repoPath, logger, strict: true });
+    const section = config?.issue_triage;
+    if (section === undefined)
+        return null;
+    if (!section || typeof section !== 'object' || Array.isArray(section))
+        throw new Error(`Invalid issue_triage in ${CONFIG_FILE_PATH}: expected an object`);
+    const prompts = section.prompts;
+    if (prompts === undefined)
+        return null;
+    if (!prompts || typeof prompts !== 'object' || Array.isArray(prompts))
+        throw new Error(`Invalid issue_triage.prompts in ${CONFIG_FILE_PATH}: expected an object`);
+    const source = prompts[phase];
+    if (source === undefined)
+        return null;
+    if (typeof source !== 'string' || !source.trim() || path.isAbsolute(source))
+        throw new Error(`issue_triage.prompts.${phase} must be a non-empty repository-relative path`);
+    try {
+        const root = realpathSync(repoPath);
+        const candidate = path.resolve(root, source);
+        if (!isWithin(root, candidate))
+            throw new Error('path must stay inside the repository');
+        const file = realpathSync(candidate);
+        if (!isWithin(root, file))
+            throw new Error('symlink must stay inside the repository');
+        const stat = statSync(file);
+        if (!stat.isFile() || stat.size > MAX_PROMPT_BYTES)
+            throw new Error('expected a file of at most 64 KiB');
+        const content = readFileSync(file, 'utf8');
+        if (!content.trim() || content.includes('\0'))
+            throw new Error('expected non-empty Markdown text');
+        const hash = hashAutofixInputs(content);
+        logger.info('Loaded repository workflow prompt', {
+            repositoryPath: repoPath,
+            phase,
+            source,
+            hash,
+        });
+        return { source, content, hash };
+    }
+    catch (error) {
+        throw new Error(`Cannot load issue_triage.prompts.${phase} (${source}): ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function describeWorkflow(workflow, defaultFileName) {
+    return [
+        `Workflow source: ${workflow ? `${workflow.source} (sha256: ${workflow.hash})` : 'Doistbot default'}`,
+        'Follow these workflow instructions for this repository. The shared task rules, output format, tool limits, and verification rules still apply and take precedence.',
+        '',
+        workflow?.content ??
+            loadPromptTemplateFile({
+                fileName: resolvePromptFile(import.meta.url, defaultFileName),
+                promptLabel: defaultFileName,
+            }),
+    ].join('\n');
+}
+/** Preserve existing checkpoint identities for repositories using the default workflow. */
+export function serializeAutofixPolicy(policy, workflow) {
+    return workflow
+        ? JSON.stringify({ policy, workflow: { source: workflow.source, hash: workflow.hash } })
+        : JSON.stringify(policy);
+}

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

@@ -0,0 +1,53 @@
+import { escapeReportText } from './report.js';
+import { createTriageReport } from './report-history.js';
+export const TRIAGE_ISSUE_URL = 'https://github.com/Doist/Issues/issues/42';
+export const TRIAGE_TARGET_REPO = 'Doist/todoist-web';
+export function triageReport(overrides = {}) {
+    return createTriageReport({
+        analysis: triageAnalysis(),
+        issueUrl: TRIAGE_ISSUE_URL,
+        repositories: [TRIAGE_TARGET_REPO],
+        history: { latest: null, pending: null },
+        now: new Date('2026-10-01T00:00:00Z'),
+        ...overrides,
+    });
+}
+export function triageAnalysis() {
+    return {
+        summary: 'Missing creator data leaves an email placeholder visible. A fallback can preserve the expected banner text.',
+        investigation: `## Findings
+
+The banner should show admin guidance. At src/banner.tsx:42 in ${TRIAGE_TARGET_REPO}, the template accepts an undefined email. The focused component test reproduces the visible placeholder when creator data is missing.
+
+## Proposed fix
+
+Use existing admin guidance when the email is missing. Run banner tests with valid and missing creator data.`,
+        decision: {
+            classification: 'auto-fixable',
+            confidence: 'high',
+            scope: 'Add fallback admin guidance.',
+            targetRepo: TRIAGE_TARGET_REPO,
+        },
+        reinvestigation: { kind: 'none' },
+    };
+}
+export function loggingAnalysis() {
+    return {
+        ...triageAnalysis(),
+        summary: 'The cause is not established. Log creator-data presence to test the hypothesis.',
+        investigation: `The creator data may be absent when Banner renders in src/banner.tsx.
+
+Add banner.creator_state with hasCreator and hasEmail presence flags. Do not record email addresses. Query with pup: service:todoist-web @event:banner.creator_state. A false hasEmail distinguishes missing data from a rendering failure. Check that events contain only presence flags. Observe for 7 days after release.`,
+        decision: {
+            classification: 'logs-needed',
+            confidence: 'medium',
+            scope: 'Record whether creator data reaches the banner.',
+            targetRepo: TRIAGE_TARGET_REPO,
+            observationDaysAfterRelease: 7,
+        },
+    };
+}
+export function triageModelOutput(analysis = triageAnalysis()) {
+    const { summary, investigation, ...metadata } = analysis;
+    return `${summary}\n\n<!--doistbot-triage-metadata\n${JSON.stringify(metadata)}\n-->\n\n<!--doistbot-triage-report\n${escapeReportText(investigation)}\n-->`;
+}

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

@@ -0,0 +1,113 @@
+import { randomUUID } from 'node:crypto';
+import { repositoryKey } from 'doistbot-issue-routing';
+import { isKnownDoistbotLogin } from '../../core/bot-logins.js';
+import { githubHistoryIdentity } from '../../core/github-history.js';
+import { MAX_LOGGING_ROUNDS, readTriageReport, validateTriageDecision } from './report.js';
+export function readTriageHistory(comments, issueUrl) {
+    const reports = new Map();
+    let latest = null;
+    for (const comment of [...comments].sort((a, b) => a.id - b.id)) {
+        if (!isKnownDoistbotLogin(comment.user?.login))
+            continue;
+        const report = readTriageReport(comment.body ?? '');
+        if (!report || githubHistoryIdentity(report.issueUrl) !== githubHistoryIdentity(issueUrl))
+            continue;
+        latest = { report, commentUrl: comment.html_url };
+        reports.set(report.id, latest);
+    }
+    const pendingId = latest?.report.pendingLoggingReportId;
+    const pending = pendingId ? reports.get(pendingId) : null;
+    if (pendingId && pending?.report.analysis.decision.classification !== 'logs-needed') {
+        throw new Error('The previous logging report is missing. Restore it before another triage.');
+    }
+    return { latest, pending: pending ?? null };
+}
+function completedLoggingRound(analysis, history, now) {
+    const { reinvestigation } = analysis;
+    const pending = history.pending?.report;
+    if (!pending) {
+        if (reinvestigation.kind !== 'none')
+            throw new Error('No previous logging plan is awaiting investigation.');
+        return false;
+    }
+    if (reinvestigation.kind === 'none') {
+        throw new Error('Triage must account for the pending logging plan.');
+    }
+    if (reinvestigation.kind === 'pending')
+        return false;
+    const decision = pending.analysis.decision;
+    if (decision.classification !== 'logs-needed' ||
+        reinvestigation.loggingReportId !== pending.id) {
+        throw new Error('Reinvestigation does not reference the pending logging plan.');
+    }
+    const prPrefix = `https://github.com/${githubHistoryIdentity(decision.targetRepo)}/pull/`;
+    const loggingPrUrl = githubHistoryIdentity(reinvestigation.loggingPrUrl);
+    if (!loggingPrUrl.startsWith(prPrefix) ||
+        !/^\d+$/.test(loggingPrUrl.slice(prPrefix.length)) ||
+        !URL.canParse(reinvestigation.releaseUrl) ||
+        new URL(reinvestigation.releaseUrl).protocol !== 'https:') {
+        throw new Error('Reinvestigation requires a logging PR in the target repository and a release evidence URL.');
+    }
+    const releasedAt = Date.parse(reinvestigation.releasedAt);
+    const observationEndsAt = releasedAt + decision.observationDaysAfterRelease * 86_400_000;
+    if (!Number.isFinite(releasedAt) ||
+        releasedAt < Date.parse(pending.createdAt) ||
+        observationEndsAt > now.getTime()) {
+        throw new Error('The logging release and its observation period must precede reinvestigation.');
+    }
+    return true;
+}
+export function createTriageReport({ analysis, issueUrl, repositories, history, now = new Date(), }) {
+    const targetRepo = 'targetRepo' in analysis.decision ? analysis.decision.targetRepo : undefined;
+    if (targetRepo &&
+        !repositories.some((repo) => repositoryKey(repo) === repositoryKey(targetRepo))) {
+        throw new Error('The proposed target is outside the cloned repository scope.');
+    }
+    const completed = completedLoggingRound(analysis, history, now);
+    const completedLoggingRounds = (history.latest?.report.completedLoggingRounds ?? 0) + (completed ? 1 : 0);
+    if (completedLoggingRounds > MAX_LOGGING_ROUNDS)
+        throw new Error('Logging round limit exceeded.');
+    const id = randomUUID();
+    let pendingLoggingReportId = completed ? null : (history.pending?.report.id ?? null);
+    let finalAnalysis = analysis;
+    if (analysis.decision.classification === 'logs-needed') {
+        if (completedLoggingRounds === MAX_LOGGING_ROUNDS) {
+            const reason = 'Two logging rounds are complete. Further investigation needs an engineer.';
+            finalAnalysis = {
+                ...analysis,
+                summary: reason,
+                decision: {
+                    classification: 'needs-human',
+                    confidence: analysis.decision.confidence,
+                    scope: reason,
+                },
+            };
+            pendingLoggingReportId = null;
+        }
+        else if (pendingLoggingReportId && history.pending) {
+            finalAnalysis = {
+                ...analysis,
+                summary: 'The previous logging plan is still pending. Complete its release and observation checks before another logging round.',
+                decision: history.pending.report.analysis.decision,
+                investigation: `${analysis.investigation}\n\n## Pending logging plan\n\n${history.pending.report.analysis.investigation}`,
+            };
+        }
+        else {
+            pendingLoggingReportId = id;
+        }
+    }
+    else if (analysis.decision.classification === 'auto-fixable') {
+        pendingLoggingReportId = null;
+    }
+    validateTriageDecision(finalAnalysis.decision);
+    return {
+        schemaVersion: '1',
+        id,
+        issueUrl,
+        createdAt: now.toISOString(),
+        previousReportId: history.latest?.report.id ?? null,
+        completedLoggingRounds,
+        pendingLoggingReportId,
+        analysis: finalAnalysis,
+    };
+}

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

@@ -0,0 +1,63 @@
+import { Ajv } from 'ajv/dist/jtd.js';
+const text = { type: 'string' };
+const confidence = { enum: ['high', 'medium', 'low'] };
+const handover = { properties: { confidence, scope: text } };
+export const TRIAGE_METADATA_SCHEMA = {
+    properties: {
+        decision: {
+            discriminator: 'classification',
+            mapping: {
+                'auto-fixable': {
+                    properties: {
+                        confidence: { enum: ['high'] },
+                        scope: text,
+                        targetRepo: text,
+                    },
+                },
+                'logs-needed': {
+                    properties: {
+                        confidence,
+                        scope: text,
+                        targetRepo: text,
+                        observationDaysAfterRelease: { type: 'uint16' },
+                    },
+                },
+                'needs-human': handover,
+                'insufficient-context': handover,
+            },
+        },
+        reinvestigation: {
+            discriminator: 'kind',
+            mapping: {
+                none: { properties: {} },
+                pending: { properties: {} },
+                completed: {
+                    properties: {
+                        loggingReportId: text,
+                        loggingPrUrl: text,
+                        releaseUrl: text,
+                        releasedAt: text,
+                    },
+                },
+            },
+        },
+    },
+};
+const TRIAGE_STORED_METADATA_SCHEMA = {
+    properties: {
+        schemaVersion: { enum: ['1'] },
+        id: text,
+        issueUrl: text,
+        createdAt: text,
+        previousReportId: { ...text, nullable: true },
+        completedLoggingRounds: { type: 'uint8' },
+        pendingLoggingReportId: { ...text, nullable: true },
+        ...TRIAGE_METADATA_SCHEMA.properties,
+    },
+};
+const ajv = new Ajv();
+export const isTriageMetadata = ajv.compile(TRIAGE_METADATA_SCHEMA);
+export const isStoredTriageMetadata = ajv.compile(TRIAGE_STORED_METADATA_SCHEMA);
+export function triageSchemaError() {
+    return ajv.errorsText(isTriageMetadata.errors);
+}

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

@@ -0,0 +1,111 @@
+import { isStoredTriageMetadata, isTriageMetadata, triageSchemaError } from './report-schema.js';
+export const TRIAGE_METADATA_MARKER = '<!--doistbot-triage-metadata';
+export const TRIAGE_REPORT_MARKER = '<!--doistbot-triage-report';
+export const TRIAGE_REJECTED_MARKER = '<!--doistbot-triage-rejected';
+export const MAX_LOGGING_ROUNDS = 2;
+export const AUTO_FIX_START_NOTICE = "**I'm starting an AutoFix attempt for this report**";
+export function escapeReportText(text) {
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function readBlock(body, marker) {
+    const start = body.indexOf(marker);
+    const end = body.indexOf('-->', start + marker.length);
+    if (start < 0 || end < 0 || body.indexOf(marker, start + 1) >= 0) {
+        throw new Error(`Missing, incomplete, or duplicate triage block: ${marker.slice(4)}`);
+    }
+    return { start, end: end + 3, text: body.slice(start + marker.length, end).trim() };
+}
+function readReportParts(body) {
+    const metadata = readBlock(body, TRIAGE_METADATA_MARKER);
+    const report = readBlock(body, TRIAGE_REPORT_MARKER);
+    if (metadata.end > report.start ||
+        body.slice(metadata.end, report.start).trim() ||
+        body.slice(report.end).trim()) {
+        throw new Error('Place the summary first, then metadata, then the hidden Markdown report.');
+    }
+    const visibleSummary = body
+        .slice(0, metadata.start)
+        .replace(/<!--[\s\S]*?-->/g, '')
+        .trim();
+    const summary = visibleSummary.endsWith(AUTO_FIX_START_NOTICE)
+        ? visibleSummary.slice(0, -AUTO_FIX_START_NOTICE.length).trim()
+        : visibleSummary;
+    const investigation = report.text.replace(/&(amp|lt|gt);/g, (entity) => {
+        if (entity === '&lt;')
+            return '<';
+        if (entity === '&gt;')
+            return '>';
+        return '&';
+    });
+    if (!summary || !investigation) {
+        throw new Error('Triage requires a summary and a Markdown investigation report.');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(metadata.text);
+    }
+    catch {
+        throw new Error('Triage workflow metadata is not valid JSON.');
+    }
+    return { summary, investigation, metadata: parsed };
+}
+export function validateTriageDecision(decision) {
+    if (!decision.scope.trim() || ('targetRepo' in decision && !decision.targetRepo.trim())) {
+        throw new Error('Triage workflow metadata requires a nonempty scope and target repository.');
+    }
+    if (decision.classification === 'logs-needed' &&
+        (decision.observationDaysAfterRelease < 1 || decision.observationDaysAfterRelease > 7)) {
+        throw new Error('decision.observationDaysAfterRelease must be between 1 and 7 days.');
+    }
+}
+export function parseTriageAnalysis(rawOutput) {
+    const { metadata, ...prose } = readReportParts(rawOutput);
+    if (!isTriageMetadata(metadata)) {
+        throw new Error(`Invalid triage workflow metadata: ${triageSchemaError()}`);
+    }
+    const analysis = { ...prose, ...metadata };
+    validateTriageDecision(analysis.decision);
+    return analysis;
+}
+export function readTriageReport(body) {
+    if (body.includes(TRIAGE_REJECTED_MARKER))
+        return null;
+    if (!body.includes(TRIAGE_REPORT_MARKER) && !body.includes(TRIAGE_METADATA_MARKER))
+        return null;
+    const { metadata, ...prose } = readReportParts(body);
+    if (!isStoredTriageMetadata(metadata) || metadata.completedLoggingRounds > MAX_LOGGING_ROUNDS) {
+        throw new Error('Triage comment contains invalid or unsupported workflow metadata.');
+    }
+    if (!Number.isFinite(Date.parse(metadata.createdAt))) {
+        throw new Error('Triage comment contains an invalid creation time.');
+    }
+    const { decision, reinvestigation, ...stored } = metadata;
+    const analysis = { ...prose, decision, reinvestigation };
+    validateTriageDecision(analysis.decision);
+    return { ...stored, analysis };
+}
+export function renderTriageReport(report) {
+    const { analysis, ...stored } = report;
+    const { summary, investigation, ...workflow } = analysis;
+    const json = JSON.stringify({ ...stored, ...workflow })
+        .replace(/</g, '\\u003c')
+        .replace(/>/g, '\\u003e');
+    const visibleSummary = workflow.decision.classification === 'auto-fixable'
+        ? `${summary.trim()}\n\n${AUTO_FIX_START_NOTICE}`
+        : summary.trim();
+    return `${visibleSummary}\n\n${TRIAGE_METADATA_MARKER}\n${json}\n-->\n\n${TRIAGE_REPORT_MARKER}\n${escapeReportText(investigation)}\n-->`;
+}
+export function reportAssessment(report) {
+    const { decision } = report.analysis;
+    return {
+        classification: decision.classification,
+        confidence: decision.confidence,
+        scope: decision.scope,
+        ...('targetRepo' in decision ? { targetRepo: decision.targetRepo } : {}),
+    };
+}
+export function reportForFix(report) {
+    const { analysis, ...stored } = report;
+    const { summary, investigation, ...workflow } = analysis;
+    return `${summary}\n\n${investigation}\n\n## Triage workflow\n\n\`\`\`json\n${JSON.stringify({ ...stored, ...workflow }, null, 2)}\n\`\`\``;
+}

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

@@ -0,0 +1,30 @@
+import { resolveIssueRepositories, } from '../../core/repository-resolver.js';
+import { recordDecision, withPhase } from '../../core/tracing.js';
+export async function resolveTriageScope(params) {
+    return withPhase('triage.resolution', { 'labels.count': params.labelNames.length }, async (span) => {
+        const result = resolveIssueRepositories(params.labelNames);
+        recordDecision('triage.resolution.outcome', {
+            trigger: params.triggerType,
+            status: result.status,
+            confidence: result.confidence,
+            reason: result.reason,
+            decision_path: result.decisionPath,
+            parsed_products: result.parsedLabels.productLabels,
+            parsed_apps: result.parsedLabels.appLabels,
+            parsed_teams: result.parsedLabels.teamLabels,
+            parsed_integrations: result.parsedLabels.integrationLabels,
+            matched_routes: result.matchedRoutes,
+            matched_integrations: result.matchedIntegrations,
+            unknown_product_labels: result.parsedLabels.unknownProductLabels,
+            unknown_app_labels: result.parsedLabels.unknownAppLabels,
+            unknown_team_labels: result.parsedLabels.unknownTeamLabels,
+            unknown_integration_labels: result.parsedLabels.unknownIntegrationLabels,
+        });
+        span.setAttributes({
+            'resolution.status': result.status,
+            'resolution.confidence': result.confidence,
+            'resolution.repos.count': result.status === 'resolved' ? result.repositories.length : 0,
+        });
+        return result;
+    });
+}

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

@@ -0,0 +1,169 @@
+import { repositoryKey } from 'doistbot-issue-routing';
+import { isKnownDoistbotLogin } from '../../core/bot-logins.js';
+import { withRetry } from '../../core/retry.js';
+import { withPhase } from '../../core/tracing.js';
+import { shouldAttemptFix } from './fix-attempt.js';
+import { GITHUB_REQUEST_TIMEOUT_MS } from './github-request.js';
+import { CX_HERO_MANUAL_HANDLE, resolveHeroGroup } from './hero-group-map.js';
+import { postIssueComment } from './side-effects.js';
+export const HERO_ROUTING_MARKER = '<!--doistbot-hero-routing-->';
+const CX_NO_PRODUCT_LABEL_COMMENT = `${HERO_ROUTING_MARKER}
+
+${CX_HERO_MANUAL_HANDLE} This issue doesn't have a product label, so I can't route it. Could you please add the right label? I'll pick it up automatically once it's labeled.`;
+const CX_UNRESOLVABLE_COMMENT = `${HERO_ROUTING_MARKER}
+
+${CX_HERO_MANUAL_HANDLE} I couldn't determine which team to route this to based on its labels. Could you please take a look?`;
+function hasProductLabel(labels) {
+    return labels.some((label) => label.trim().toLowerCase().startsWith('product:'));
+}
+// The single sentence-boundary heuristic. Returns whole sentences or nothing —
+// a half-sentence of context is what made the old routing comment worthless, so
+// detail that doesn't fit is dropped, not clipped. Any complete sentence is worth
+// keeping, however short: the boundary check already rules out fragments.
+function sentencesWithin(text, maxChars) {
+    if (text.length <= maxChars) {
+        return text;
+    }
+    const clipped = text.slice(0, maxChars);
+    const sentenceEnd = Math.max(clipped.lastIndexOf('. '), clipped.lastIndexOf('! '), clipped.lastIndexOf('? '));
+    return sentenceEnd > 0 ? clipped.slice(0, sentenceEnd + 1) : undefined;
+}
+// As above, but for text we would rather shorten than lose. Falls back to a word
+// boundary + ellipsis when the budget holds no complete sentence at all.
+function trimToSentence(text, maxChars) {
+    const whole = sentencesWithin(text, maxChars);
+    if (whole !== undefined) {
+        return whole;
+    }
+    const capped = text.slice(0, maxChars - 3);
+    const wordEnd = capped.lastIndexOf(' ');
+    return `${(wordEnd > 0 ? capped.slice(0, wordEnd) : capped).trimEnd()}...`;
+}
+export function summarizeTriageReasoning(summary, maxChars = 320) {
+    const normalized = summary.replace(/\s+/g, ' ').trim();
+    return normalized
+        ? trimToSentence(normalized, maxChars)
+        : 'See the triage summary above for details.';
+}
+function buildStatusLine(assessment, maxChars) {
+    if (!assessment) {
+        return undefined;
+    }
+    const states = {
+        'insufficient-context': 'Blocked, no PR opened',
+        'needs-human': 'Needs a human, no PR opened',
+        'logs-needed': 'Logging plan ready',
+    };
+    const state = states[assessment.classification] ?? `No PR opened (${assessment.confidence} confidence)`;
+    const scope = sentencesWithin(assessment.scope.replace(/\s+/g, ' ').trim(), maxChars);
+    return scope ? `- **${state}** — ${scope}` : `- **${state}.**`;
+}
+// ~1 in 6 triages concludes the code lives outside the repos the labels resolved to.
+// Without this the pinged team opens the issue, decides it isn't theirs, and bounces it.
+function buildRepoMismatchLine(assessment, resolvedRepos) {
+    const targetRepo = assessment?.targetRepo?.trim();
+    if (!targetRepo || resolvedRepos.length === 0) {
+        return undefined;
+    }
+    const matches = resolvedRepos.some((repo) => repositoryKey(repo) === repositoryKey(targetRepo));
+    if (matches) {
+        return undefined;
+    }
+    return `- ⚠️ **Likely in \`${targetRepo}\`**, not ${resolvedRepos.map((repo) => `\`${repo}\``).join(' / ')} — may belong to another team.`;
+}
+export function buildTriageRecap({ summary, assessment, resolvedRepos = [], maxChars = 220, }) {
+    return [
+        buildRepoMismatchLine(assessment, resolvedRepos),
+        buildStatusLine(assessment, maxChars),
+        summarizeTriageReasoning(summary),
+    ]
+        .filter(Boolean)
+        .join('\n\n');
+}
+/**
+ * Returns the current issue assignees that the `todoist/Issues` auto-routing workflows assigned.
+ *
+ * Auto-routing is the only automation that assigns issues as Doistbot, so an assignee whose
+ * latest assignment event was made by Doistbot is treated as auto-routed.
+ */
+export async function findAutoRoutedAssignees({ octokit, ctx, }) {
+    const request = {
+        owner: ctx.owner,
+        repo: ctx.repo,
+        issue_number: ctx.issueNumber,
+    };
+    const { data: issue } = await withRetry(() => octokit.rest.issues.get({
+        ...request,
+        request: { signal: AbortSignal.timeout(GITHUB_REQUEST_TIMEOUT_MS) },
+    }));
+    const assignees = (issue.assignees ?? []).map((assignee) => assignee.login);
+    if (assignees.length === 0) {
+        return [];
+    }
+    const events = await withRetry(() => octokit.paginate(octokit.rest.issues.listEvents, {
+        ...request,
+        per_page: 100,
+        request: { signal: AbortSignal.timeout(GITHUB_REQUEST_TIMEOUT_MS) },
+    }));
+    const latestAssignmentByDoistbot = new Map();
+    for (const event of events) {
+        if (event.event !== 'assigned' && event.event !== 'unassigned') {
+            continue;
+        }
+        const login = 'assignee' in event ? event.assignee?.login?.toLowerCase() : undefined;
+        if (!login) {
+            continue;
+        }
+        latestAssignmentByDoistbot.set(login, event.event === 'assigned' &&
+            'assigner' in event &&
+            isKnownDoistbotLogin(event.assigner?.login));
+    }
+    return assignees.filter((login) => !isKnownDoistbotLogin(login) &&
+        latestAssignmentByDoistbot.get(login.toLowerCase()) === true);
+}
+export function canRouteToHeroGroup(labels, primaryRepo) {
+    return hasProductLabel(labels) && resolveHeroGroup(labels, primaryRepo) !== null;
+}
+function formatRoutingTarget(autoRoutedAssignees, heroMention) {
+    if (autoRoutedAssignees.length === 0) {
+        return heroMention;
+    }
+    const mentions = autoRoutedAssignees.map((login) => `@${login}`).join(', ');
+    return autoRoutedAssignees.length === 1
+        ? `${mentions}, the auto-routed assignee,`
+        : `${mentions}, the auto-routed assignees,`;
+}
+export function buildHeroRoutingComment({ labels, primaryRepo, summary, assessment, resolvedRepos, autoRoutedAssignees = [], }) {
+    if (!hasProductLabel(labels)) {
+        return CX_NO_PRODUCT_LABEL_COMMENT;
+    }
+    const heroGroup = resolveHeroGroup(labels, primaryRepo);
+    if (!heroGroup) {
+        return CX_UNRESOLVABLE_COMMENT;
+    }
+    return `${HERO_ROUTING_MARKER}
+
+Routing to ${formatRoutingTarget(autoRoutedAssignees, heroGroup.mention)} for triage.
+
+${buildTriageRecap({ summary, assessment, resolvedRepos })}`;
+}
+export function shouldPostHeroRoutingComment(fixAssessment) {
+    if (!fixAssessment) {
+        return true;
+    }
+    return !shouldAttemptFix(fixAssessment);
+}
+export async function postHeroRoutingComment({ octokit, ctx, body, }) {
+    await postIssueComment(ctx, octokit, body, {
+        marker: HERO_ROUTING_MARKER,
+    });
+}
+export async function postTriageRouting(params) {
+    await withPhase('triage.routing', { 'comment.body.length': params.body.length }, async () => {
+        await postHeroRoutingComment({
+            octokit: params.octokit,
+            ctx: params.ctx,
+            body: params.body,
+        });
+    });
+}