@doist/doistbot-cli 1.0.4 → 1.0.6

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

@@ -164,8 +164,20 @@ export function buildFollowUpCommentBody({ prUrl, targetRepoFullName, fixAssessm
         `The PR targets \`${targetRepoFullName}\`. Please review it carefully before merging.`,
     ].join('\n');
 }
-function isNonRetryableFailure(reason) {
-    return reason.includes(CODEX_CANNOT_FIX_REASON);
+// Detect the "## Cannot Fix" verdict and pull Codex's own explanation in one pass,
+// so the failure comment can tell the human *why* it bailed, not just that it did.
+// Returns null when the marker is absent (not a cannot-fix verdict), the explanation
+// string when present, or '' when the model gave the verdict with no explanation.
+// The full tail is intentional — the prompt makes "## Cannot Fix" the terminal output.
+// ponytail: 2000-char cap keeps the comment readable; raise it if reasons get truncated.
+export function extractCannotFixDetail(output) {
+    const idx = output.indexOf(CANNOT_FIX_MARKER);
+    if (idx === -1)
+        return null;
+    return output
+        .slice(idx + CANNOT_FIX_MARKER.length)
+        .trim()
+        .slice(0, 2000);
 }
 async function findSourceIssueCommentByMarker({ octokit, ctx, marker, }) {
     const comments = await octokit.paginate(octokit.rest.issues.listComments, {
@@ -187,8 +199,6 @@ export async function shouldPostAutoFixFailureComment(fixResult, { dryRun, octok
     // a "didn't produce a fix PR" comment would be misleading.
     if (fixResult.prNumber !== undefined)
         return false;
-    if (isNonRetryableFailure(fixResult.reason))
-        return false;
     if (fixResult.reason.startsWith(FIX_LOOP_FAILED_REASON_PREFIX)) {
         try {
             const hasFixLoopStartComment = await sourceIssueHasFixLoopStartComment({ octokit, ctx });
@@ -231,9 +241,11 @@ export function buildAutoFixFailureCommentBody({ reason, targetRepoFullName, })
         '',
         '**Reason:**',
         '',
-        '```',
+        // Tilde fence, not backticks: the reason often carries Codex's own
+        // backtick-fenced output (logs, CLI), which would close a ``` block early.
+        '~~~',
         reason,
-        '```',
+        '~~~',
         '',
         'You can retry by commenting `@doistbot /fix`.',
     ].join('\n');
@@ -365,6 +377,9 @@ export async function runFixCore(input) {
         ? SPECULATIVE_CODEX_TIMEOUT_MS
         : AUTO_FIX_CODEX_TIMEOUT_MS;
     const codexResult = await invokeTriageModel({
+        // Distinct phase name: this is fix generation, not triage analysis.
+        // Callers (e.g. issue-fix-retry) override to keep it in their namespace.
+        phaseName: input.modelPhaseName ?? 'triage.fix-attempt.model',
         prompt,
         apiKey: ctx.openaiApiKey,
         cwd: targetRepo.localPath,
@@ -391,13 +406,19 @@ export async function runFixCore(input) {
         outputChars: fixDescription.length,
     });
     // Check if Codex reported it cannot fix
-    if (fixDescription.includes(CANNOT_FIX_MARKER)) {
+    const cannotFixDetail = extractCannotFixDetail(fixDescription);
+    if (cannotFixDetail !== null) {
         logger.info('Fix Codex reported cannot fix', {
             task: 'issue-triage',
             issueNumber: ctx.issueNumber,
             output: fixDescription.slice(0, 500),
         });
-        return { ok: false, reason: CODEX_CANNOT_FIX_REASON };
+        return {
+            ok: false,
+            reason: cannotFixDetail
+                ? `${CODEX_CANNOT_FIX_REASON}\n\n${cannotFixDetail}`
+                : CODEX_CANNOT_FIX_REASON,
+        };
     }
     // Capture the diff
     const diff = captureGitDiff(targetRepo.localPath);
@@ -499,6 +520,7 @@ export async function attemptFix(input) {
         issueUrl: input.issueUrl,
         ghToken: input.ghToken,
         force,
+        modelPhaseName: input.modelPhaseName,
     });
     if (!coreResult.ok) {
         return {
@@ -520,6 +542,7 @@ export async function attemptFix(input) {
             repository: targetRepo.repository.fullName,
             prCreated: false,
             reason: 'Dry run — PR not created.',
+            dryRun: true,
         };
     }
     let openedPr;

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

@@ -1,4 +1,6 @@
+import { SpanStatusCode } from '@opentelemetry/api';
 import { logger } from '../../core/logging.js';
+import { withPhase } from '../../core/tracing.js';
 import { DefaultLoopEffects } from './fix-loop/effects.js';
 import { runFixLoop } from './fix-loop/runners.js';
 import { attemptFix, buildFixAssessmentSkipReason, shouldAttemptFix } from './fix-attempt.js';
@@ -79,112 +81,163 @@ function prUrlFor(targetRepo, prNumber) {
     return `https://github.com/${targetRepo.repository.fullName}/pull/${prNumber}`;
 }
 export async function runConfiguredFix(input) {
-    const target = resolveFixTarget(input);
-    if (!target.ok) {
-        return { attempted: false, repository: target.repository, reason: target.reason };
-    }
-    const targetRepo = target.targetRepo;
-    let repoConfig;
-    try {
-        repoConfig = await input.loadRepoConfig(targetRepo.repository);
-    }
-    catch (error) {
-        logger.warn('Fix loop config load failed', {
-            task: 'fix-loop',
-            repository: targetRepo.repository.fullName,
-            error: errorReason(error),
-        });
-        return {
-            attempted: true,
-            repository: targetRepo.repository.fullName,
-            prCreated: false,
-            reason: `Fix loop config load failed: ${errorReason(error)}`,
-        };
-    }
-    const autoFixMode = getAutoFixMode(repoConfig, input.ctx.enableAutoFixOverride);
-    if (autoFixMode === 'disabled') {
-        return {
-            attempted: false,
-            repository: targetRepo.repository.fullName,
-            reason: 'Auto fix disabled by repository config.',
-        };
-    }
-    if (autoFixMode === 'one-pass') {
-        return attemptFix(toAttemptFixInput(input));
-    }
-    if (!shouldAttemptFix(input.fixAssessment)) {
-        return {
-            attempted: false,
-            repository: targetRepo.repository.fullName,
-            reason: buildFixAssessmentSkipReason(input.fixAssessment),
-        };
-    }
-    const session = {
-        kind: 'fix-loop',
-        ctx: input.ctx,
-        octokit: input.octokit,
-        triageOutput: input.triageOutput,
-        fixAssessment: input.fixAssessment,
-        targetRepo,
-        issueTitle: input.issueTitle,
-        issueUrl: input.issueUrl,
-        ghToken: input.ghToken,
-        pushToken: input.ctx.githubToken,
-        apiKeys: {
-            openai: input.ctx.openaiApiKey,
-            ...(input.ctx.geminiApiKey !== undefined && { gemini: input.ctx.geminiApiKey }),
-            ...(input.ctx.anthropicApiKey !== undefined && {
-                anthropic: input.ctx.anthropicApiKey,
-            }),
-        },
-    };
-    let finalState;
-    try {
-        finalState = await runFixLoop({
-            effects: new DefaultLoopEffects(session, { dryRun: input.ctx.dryRun }),
-            ...(input.ctx.dryRun ? { onTransition: logDryRunTransition } : {}),
-        });
-    }
-    catch (error) {
-        return {
-            attempted: true,
-            repository: targetRepo.repository.fullName,
-            prCreated: false,
-            reason: `${FIX_LOOP_FAILED_REASON_PREFIX} ${errorReason(error)}`,
+    return withPhase('triage.fix-attempt', { 'gen_ai.operation.name': 'invoke_agent', 'gen_ai.agent.name': 'codex.fix' }, async (span) => {
+        function finish(result) {
+            const prCreated = 'prCreated' in result ? result.prCreated : false;
+            // Only a real PR number counts as PR-evidence — dry-run loop
+            // states can carry a placeholder prNumber of 0.
+            const prNumber = 'prNumber' in result && result.prNumber !== undefined && result.prNumber > 0
+                ? result.prNumber
+                : undefined;
+            // Dry-run skips are expected outcomes, not failures — signaled
+            // by the stable dryRun flag on the result, never by parsing
+            // the human-readable reason copy.
+            const isDryRunSkip = 'dryRun' in result && result.dryRun === true;
+            let outcome;
+            if (prCreated) {
+                outcome = 'pr-created';
+            }
+            else if (isDryRunSkip) {
+                outcome = 'dry-run';
+            }
+            else if (prNumber !== undefined) {
+                // The loop opened a PR earlier (REVIEWING/ITERATING) but
+                // ended needing a human: a PR exists, the autonomous
+                // attempt did not finish.
+                outcome = 'pr-opened-needs-human';
+            }
+            else if (result.attempted) {
+                outcome = 'attempted-no-pr';
+            }
+            else {
+                outcome = 'not-attempted';
+            }
+            span.setAttributes({
+                'fix.attempted': result.attempted,
+                'fix.repository': result.repository,
+                'fix.pr_created': prCreated,
+                ...(prNumber !== undefined ? { 'fix.pr_number': prNumber } : {}),
+                'fix.outcome': outcome,
+            });
+            // A real attempt that did not deliver a ready PR is a failure
+            // (including pr-opened-needs-human — someone must take over);
+            // a legitimate skip or a dry-run is not. withPhase does not
+            // force OK on a normal return, so this ERROR survives to
+            // phase.end.
+            if (result.attempted && !prCreated && !isDryRunSkip && 'reason' in result) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: result.reason });
+            }
+            return result;
+        }
+        const target = resolveFixTarget(input);
+        if (!target.ok) {
+            return finish({
+                attempted: false,
+                repository: target.repository,
+                reason: target.reason,
+            });
+        }
+        const targetRepo = target.targetRepo;
+        let repoConfig;
+        try {
+            repoConfig = await input.loadRepoConfig(targetRepo.repository);
+        }
+        catch (error) {
+            logger.warn('Fix loop config load failed', {
+                task: 'fix-loop',
+                repository: targetRepo.repository.fullName,
+                error: errorReason(error),
+            });
+            return finish({
+                attempted: true,
+                repository: targetRepo.repository.fullName,
+                prCreated: false,
+                reason: `Fix loop config load failed: ${errorReason(error)}`,
+            });
+        }
+        const autoFixMode = getAutoFixMode(repoConfig, input.ctx.enableAutoFixOverride);
+        if (autoFixMode === 'disabled') {
+            return finish({
+                attempted: false,
+                repository: targetRepo.repository.fullName,
+                reason: 'Auto fix disabled by repository config.',
+            });
+        }
+        if (autoFixMode === 'one-pass') {
+            return finish(await attemptFix(toAttemptFixInput(input)));
+        }
+        if (!shouldAttemptFix(input.fixAssessment)) {
+            return finish({
+                attempted: false,
+                repository: targetRepo.repository.fullName,
+                reason: buildFixAssessmentSkipReason(input.fixAssessment),
+            });
+        }
+        const session = {
+            kind: 'fix-loop',
+            ctx: input.ctx,
+            octokit: input.octokit,
+            triageOutput: input.triageOutput,
+            fixAssessment: input.fixAssessment,
+            targetRepo,
+            issueTitle: input.issueTitle,
+            issueUrl: input.issueUrl,
+            ghToken: input.ghToken,
+            pushToken: input.ctx.githubToken,
+            apiKeys: {
+                openai: input.ctx.openaiApiKey,
+                ...(input.ctx.geminiApiKey !== undefined && { gemini: input.ctx.geminiApiKey }),
+            },
         };
-    }
-    if (finalState.kind === 'PUSHED_AWAITING_CI') {
-        if (input.ctx.dryRun) {
-            return {
+        let finalState;
+        try {
+            finalState = await runFixLoop({
+                effects: new DefaultLoopEffects(session, { dryRun: input.ctx.dryRun }),
+                ...(input.ctx.dryRun ? { onTransition: logDryRunTransition } : {}),
+            });
+        }
+        catch (error) {
+            return finish({
                 attempted: true,
                 repository: targetRepo.repository.fullName,
                 prCreated: false,
-                reason: 'Dry run: PR not created.',
-            };
+                reason: `${FIX_LOOP_FAILED_REASON_PREFIX} ${errorReason(error)}`,
+            });
         }
-        const prNumber = finalState.prNumber;
-        const prUrl = prUrlFor(targetRepo, prNumber);
-        return {
+        if (finalState.kind === 'PUSHED_AWAITING_CI') {
+            if (input.ctx.dryRun) {
+                return finish({
+                    attempted: true,
+                    repository: targetRepo.repository.fullName,
+                    prCreated: false,
+                    reason: 'Dry run: PR not created.',
+                    dryRun: true,
+                });
+            }
+            const prNumber = finalState.prNumber;
+            const prUrl = prUrlFor(targetRepo, prNumber);
+            return finish({
+                attempted: true,
+                repository: targetRepo.repository.fullName,
+                prCreated: true,
+                prUrl,
+                prNumber,
+            });
+        }
+        const reason = finalState.kind === 'DONE_NEEDS_HUMAN'
+            ? finalState.reason
+            : `Fix loop ended in ${finalState.kind}`;
+        return finish({
             attempted: true,
             repository: targetRepo.repository.fullName,
-            prCreated: true,
-            prUrl,
-            prNumber,
-        };
-    }
-    const reason = finalState.kind === 'DONE_NEEDS_HUMAN'
-        ? finalState.reason
-        : `Fix loop ended in ${finalState.kind}`;
-    return {
-        attempted: true,
-        repository: targetRepo.repository.fullName,
-        prCreated: false,
-        reason,
-        // If a PR was opened earlier in the loop (REVIEWING/ITERATING reached
-        // before DONE_NEEDS_HUMAN), surface it so callers can distinguish a
-        // silent failure from an in-progress PR.
-        ...('prNumber' in finalState && finalState.prNumber !== undefined
-            ? { prNumber: finalState.prNumber }
-            : {}),
-    };
+            prCreated: false,
+            reason,
+            // If a PR was opened earlier in the loop (REVIEWING/ITERATING reached
+            // before DONE_NEEDS_HUMAN), surface it so callers can distinguish a
+            // silent failure from an in-progress PR.
+            ...('prNumber' in finalState && finalState.prNumber !== undefined
+                ? { prNumber: finalState.prNumber }
+                : {}),
+        });
+    });
 }

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

@@ -1,3 +1,4 @@
+import { iterationLabel, PROMOTION_COMMENT_MARKER } from 'doistbot-shared-contracts';
 import { logger } from '../../../core/logging.js';
 import { isFixLoopTerminal, isTerminal, next, } from './state-machine.js';
 const CI_FAILED_LABEL = 'doistbot:ci-failed';
@@ -6,10 +7,13 @@ const AWAITING_CI_LABEL = 'doistbot:awaiting-ci';
 // Stamped on terminal comments so postIssueComment can find-or-update an
 // existing comment instead of double-posting when an earlier dispatch
 // succeeded on GitHub but the response timed out.
-const PROMOTION_COMMENT_MARKER = '<!--doistbot-promotion-comment-->';
-function iterationLabel(iteration) {
-    return `doistbot:iter-${iteration}`;
-}
+//
+// The success and human-escalation paths use DISTINCT markers: merge tracking
+// reads 👍/👎 reactions on the promotion (success) comment to derive the thumbs
+// metric, so it must be uniquely identifiable. A shared marker would let a
+// CI-failed-then-human-merged bot PR expose its failure comment as the reaction
+// target instead.
+const PROMOTION_NEEDS_HUMAN_COMMENT_MARKER = '<!--doistbot-promotion-needs-human-comment-->';
 function formatFailedChecks(checks) {
     return checks.map((c) => (c.url ? `- [${c.name}](${c.url})` : `- ${c.name}`)).join('\n');
 }
@@ -176,7 +180,12 @@ export async function runPromotionFlow(effects, input) {
             await effects.postIssueComment({
                 prNumber: input.prNumber,
                 marker: PROMOTION_COMMENT_MARKER,
-                body: 'CI passed — promoting this PR out of draft and requesting hero review.',
+                // This comment doubles as the thumbs-feedback prompt: merge
+                // tracking reads 👍/👎 reactions on this exact comment (located
+                // via the marker above) when the PR merges. Keep the reaction
+                // ask on the comment people are invited to react to.
+                body: 'CI passed — promoting this PR out of draft and requesting hero review.\n\n' +
+                    '<sub>🤖🫵 Please, react 👍 or 👎 on this comment to rate this bot-authored PR.</sub>',
             });
             await effects.promoteToReady(input.prNumber);
             return state;
@@ -193,7 +202,7 @@ export async function runPromotionFlow(effects, input) {
                     : 'This PR needs human review.';
             await effects.postIssueComment({
                 prNumber: input.prNumber,
-                marker: PROMOTION_COMMENT_MARKER,
+                marker: PROMOTION_NEEDS_HUMAN_COMMENT_MARKER,
                 body,
             });
             return state;

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

@@ -1,39 +1,123 @@
-import { invokePiPrompt } from '../../core/pi.js';
+import { SpanStatusCode } from '@opentelemetry/api';
+import { DEFAULT_PI_MODELS, invokePiPrompt } from '../../core/pi.js';
+import { recordEvent, startToolSpan, withPhase } from '../../core/tracing.js';
 const ISSUE_TRIAGE_TIMEOUT_MS = 12 * 60 * 1000;
-export async function invokeTriageModel({ prompt, apiKey, cwd, timeoutMs = ISSUE_TRIAGE_TIMEOUT_MS, extraEnv, thinkingLevel, onProgress, }) {
-    const startedAt = Date.now();
-    const result = await invokePiPrompt({
-        provider: 'openai',
-        apiKey,
-        prompt,
-        cwd,
-        timeoutMs,
-        extraEnv,
-        capabilityPreset: 'shell-focused',
-        ...(thinkingLevel ? { thinkingLevel } : {}),
-        ...(onProgress ? { onProgress } : {}),
+const TRIAGE_PROVIDER = 'openai';
+export async function invokeTriageModel({ prompt, apiKey, cwd, timeoutMs = ISSUE_TRIAGE_TIMEOUT_MS, extraEnv, thinkingLevel, modelName = DEFAULT_PI_MODELS[TRIAGE_PROVIDER], 
+// Callers on other paths (e.g. fix generation) pass their own phase name
+// so model telemetry stays separable per flow.
+phaseName = 'triage.model', }) {
+    return withPhase(phaseName, {
+        'gen_ai.operation.name': 'chat',
+        'gen_ai.provider.name': TRIAGE_PROVIDER,
+        'gen_ai.request.model': modelName,
+    }, async (span) => {
+        // pi emits tool start/end across separate onProgress callbacks, so
+        // tool spans are managed manually (the documented exception to
+        // "withPhase everywhere"). startToolSpan captures context.active()
+        // at call time, parenting each tool span under THIS model span.
+        const inFlightTools = new Map();
+        function toolKey(event) {
+            return event.toolCallId ?? event.toolName ?? '';
+        }
+        function onProgress(event) {
+            switch (event.type) {
+                case 'tool_start': {
+                    const toolCallId = event.toolCallId;
+                    const key = toolKey(event);
+                    // Overlapping same-name tools without a toolCallId
+                    // collide on the key; close the displaced span so it
+                    // is never leaked un-ended.
+                    const displaced = inFlightTools.get(key);
+                    if (displaced) {
+                        displaced.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: 'replaced by overlapping same-name tool without toolCallId',
+                        });
+                        displaced.end();
+                    }
+                    const toolSpan = startToolSpan(event.toolName, {
+                        'gen_ai.operation.name': 'execute_tool',
+                        'gen_ai.tool.name': event.toolName,
+                        ...(toolCallId ? { 'gen_ai.tool.call.id': toolCallId } : {}),
+                    });
+                    inFlightTools.set(key, toolSpan);
+                    return;
+                }
+                case 'tool_end': {
+                    const key = toolKey(event);
+                    const toolSpan = inFlightTools.get(key);
+                    if (toolSpan) {
+                        if (event.isError) {
+                            toolSpan.setStatus({
+                                code: SpanStatusCode.ERROR,
+                                message: 'tool reported error',
+                            });
+                        }
+                        toolSpan.end();
+                        inFlightTools.delete(key);
+                    }
+                    return;
+                }
+                case 'thinking':
+                case 'responding': {
+                    // Liveness signal for long model phases: pi already
+                    // throttles these to one per 30s. Emitted as point-in-time
+                    // events (correlated to this model span), NOT spans —
+                    // they are heartbeats, not boundaries.
+                    recordEvent('model.heartbeat', { state: event.type });
+                }
+                // agent_start/agent_end duplicate this phase span's own
+                // boundaries and tool_update is covered by the open tool
+                // span — intentionally no emission for those.
+            }
+        }
+        const startedAt = Date.now();
+        const result = await invokePiPrompt({
+            provider: TRIAGE_PROVIDER,
+            apiKey,
+            prompt,
+            cwd,
+            timeoutMs,
+            extraEnv,
+            capabilityPreset: 'shell-focused',
+            ...(thinkingLevel ? { thinkingLevel } : {}),
+            ...(modelName ? { modelName } : {}),
+            onProgress,
+        });
+        // Force-end any tool spans pi never closed (defensive — pi's stream
+        // is ordered, but if a tool_end was lost we don't want hanging spans).
+        for (const [, toolSpan] of inFlightTools) {
+            toolSpan.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: 'tool span did not receive matching end',
+            });
+            toolSpan.end();
+        }
+        inFlightTools.clear();
+        const durationMs = Date.now() - startedAt;
+        if (!result.ok) {
+            // Mark the model phase as failed. withPhase does NOT force OK on
+            // success, so this ERROR status survives to the phase.end line.
+            span.setStatus({ code: SpanStatusCode.ERROR, message: result.error });
+            return {
+                ok: false,
+                error: result.error,
+                durationMs,
+                timedOut: result.timedOut,
+            };
+        }
+        const output = result.output.trim();
+        if (!output) {
+            const message = 'Pi triage model did not produce an assistant response';
+            span.setStatus({ code: SpanStatusCode.ERROR, message });
+            return {
+                ok: false,
+                error: message,
+                durationMs,
+                timedOut: false,
+            };
+        }
+        return { ok: true, output, durationMs };
     });
-    const durationMs = Date.now() - startedAt;
-    if (!result.ok) {
-        return {
-            ok: false,
-            error: result.error,
-            durationMs,
-            timedOut: result.timedOut,
-        };
-    }
-    const output = result.output.trim();
-    if (!output) {
-        return {
-            ok: false,
-            error: 'Pi triage model did not produce an assistant response',
-            durationMs,
-            timedOut: false,
-        };
-    }
-    return {
-        ok: true,
-        output,
-        durationMs,
-    };
 }

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

@@ -1,4 +1,6 @@
+import { SpanStatusCode } from '@opentelemetry/api';
 import { fillPromptTemplate } from '../../core/prompt-template.js';
+import { withPhase } from '../../core/tracing.js';
 const REQUIRED_SECTIONS = [
     'Summary',
     'Findings',
@@ -121,3 +123,28 @@ export function parseFixAssessment(triageOutput) {
     };
 }
 export { REQUIRED_HEADINGS };
+export function validateTriageOutput(params) {
+    return withPhase('triage.output', { 'output.length': params.rawOutput.length }, async (span) => {
+        const normalized = ensureStructuredTriageOutput(params.rawOutput);
+        span.setAttributes({
+            'output.missing_sections.count': normalized.missingSections.length,
+            'output.quality_check.passed': normalized.missingSections.length === 0,
+        });
+        if (normalized.missingSections.length > 0) {
+            // Mirrors the failure path in current triage.ts (missingSections > 0).
+            const error = `Triage model returned incomplete output. Missing sections: ${normalized.missingSections.join(', ')}`;
+            // ensureStructuredTriageOutput does not throw; mark the span ERROR
+            // explicitly. withPhase does not force OK on a normal return, so this
+            // survives to phase.end.
+            span.setStatus({ code: SpanStatusCode.ERROR, message: error });
+            return { ok: false, error };
+        }
+        const assessment = parseFixAssessment(normalized.output);
+        return {
+            ok: true,
+            commentOutput: normalized.commentOutput,
+            output: normalized.output,
+            assessment,
+        };
+    });
+}

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

@@ -1,6 +1,7 @@
 import { execFileSync } from 'child_process';
 import fs from 'fs';
 import path from 'path';
+import { DOISTBOT_AUTO_FIX_LABEL, DOISTBOT_SPECULATIVE_FIX_LABEL } from 'doistbot-shared-contracts';
 import { logger } from '../../core/logging.js';
 import { fillPromptTemplate, loadPromptTemplateFile } from '../../core/prompt-template.js';
 const PR_TEMPLATE_PATHS = [
@@ -299,8 +300,8 @@ export async function openDraftFixPR(input) {
     });
     try {
         const prLabel = input.fixAssessment?.classification === 'speculative'
-            ? 'doistbot-speculative-fix'
-            : 'doistbot-auto-fix';
+            ? DOISTBOT_SPECULATIVE_FIX_LABEL
+            : DOISTBOT_AUTO_FIX_LABEL;
         await input.octokit.rest.issues.addLabels({
             owner: input.repoOwner,
             repo: input.repoName,

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

@@ -0,0 +1,26 @@
+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,
+            unknown_product_labels: result.parsedLabels.unknownProductLabels,
+            unknown_app_labels: result.parsedLabels.unknownAppLabels,
+            unknown_team_labels: result.parsedLabels.unknownTeamLabels,
+        });
+        span.setAttributes({
+            'resolution.status': result.status,
+            'resolution.confidence': result.confidence,
+            'resolution.repos.count': result.status === 'resolved' ? result.repositories.length : 0,
+        });
+        return result;
+    });
+}