@doist/doistbot-cli 1.0.5 → 1.0.7

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

@@ -1,38 +1,62 @@
+import { SpanStatusCode } from '@opentelemetry/api';
 import { logger } from '../../core/logging.js';
-import { buildPiImageContent, createPiInvoker } from '../../core/pi.js';
+import { buildPiImageContent, createPiInvoker, DEFAULT_OPENROUTER_MODELS } from '../../core/pi.js';
+import { withPhase } from '../../core/tracing.js';
 const ISSUE_SUMMARIZE_TIMEOUT_MS = 5 * 60 * 1000;
 const ISSUE_SUMMARIZE_MULTIMODAL_MODEL = 'google/gemini-2.5-pro';
+const SUMMARIZE_TEXT_PROVIDER = 'zai';
+// Single source of truth: inherit the repo-wide ZAI default so a default-model
+// bump in core/pi.ts moves summarize too, and the executed model matches the
+// recorded gen_ai.request.model.
+const SUMMARIZE_TEXT_MODEL = DEFAULT_OPENROUTER_MODELS.zai;
+const SUMMARIZE_MULTIMODAL_PROVIDER = 'gcp.gemini';
+// One model span per actual model.invoke. The final summary uses
+// `issue-summarize.model`; each chunk summary uses `issue-summarize.chunk`.
+const SUMMARIZE_MODEL_PHASE = 'issue-summarize.model';
+const SUMMARIZE_CHUNK_PHASE = 'issue-summarize.chunk';
 export function createIssueSummarizeModel(apiKey) {
     return createPiInvoker({
-        provider: 'gemini',
+        provider: 'zai',
         apiKey,
         piProviderId: 'openrouter',
         cwd: process.cwd(),
         capabilityPreset: 'read-only',
     });
 }
-async function invokeIssueSummarizeTextModel({ model, prompt, }) {
-    const result = await model.invoke({
-        prompt,
-        timeoutMs: ISSUE_SUMMARIZE_TIMEOUT_MS,
-    });
-    if (!result.ok) {
-        logger.warn('Issue summarize model request failed', {
-            error: result.error,
-            timedOut: result.timedOut,
+async function invokeIssueSummarizeTextModel({ model, prompt, phaseName, }) {
+    return withPhase(phaseName, {
+        'gen_ai.operation.name': 'chat',
+        'gen_ai.provider.name': SUMMARIZE_TEXT_PROVIDER,
+        'gen_ai.request.model': SUMMARIZE_TEXT_MODEL,
+    }, async (span) => {
+        const result = await model.invoke({
+            prompt,
+            modelName: SUMMARIZE_TEXT_MODEL,
+            timeoutMs: ISSUE_SUMMARIZE_TIMEOUT_MS,
         });
-        return null;
-    }
-    return result.output.trim() || null;
-}
-export async function invokeIssueSummarizeModel({ model, prompt, mediaImages, }) {
-    if (mediaImages.length === 0) {
-        logger.info('Using text-only summarize model request');
-        return await invokeIssueSummarizeTextModel({ model, prompt });
-    }
-    logger.info('Using multimodal summarize model request', {
-        mediaImages: mediaImages.length,
+        if (!result.ok) {
+            span.setStatus({ code: SpanStatusCode.ERROR, message: result.error });
+            logger.warn('Issue summarize model request failed', {
+                error: result.error,
+                timedOut: result.timedOut,
+            });
+            return null;
+        }
+        const output = result.output.trim() || null;
+        if (!output) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: 'summarize model produced no output',
+            });
+        }
+        return output;
     });
+}
+// One model span for the multimodal model.invoke (provider/model known at
+// start). On failure it returns null and the caller falls back to a separate
+// text request — which emits its own model span, so a fallback shows two real
+// model calls rather than one.
+async function invokeMultimodalSummarizeModel({ model, prompt, mediaImages, }) {
     const mediaContext = mediaImages
         .map((mediaImage, index) => [
         `Media item ${index + 1} of ${mediaImages.length}`,
@@ -43,40 +67,72 @@ export async function invokeIssueSummarizeModel({ model, prompt, mediaImages, })
         mediaImage.sourceContext,
     ].join('\n'))
         .join('\n\n');
-    try {
-        const result = await model.invoke({
-            modelName: ISSUE_SUMMARIZE_MULTIMODAL_MODEL,
-            prompt: `${prompt}\n\n<media_context>\n${mediaContext}\n</media_context>`,
-            timeoutMs: ISSUE_SUMMARIZE_TIMEOUT_MS,
-            images: mediaImages.map((mediaImage) => buildPiImageContent({
-                dataBase64: mediaImage.dataBase64,
-                contentType: mediaImage.contentType,
-            })),
-        });
-        if (!result.ok) {
-            logger.warn('Issue summarize multimodal request failed', {
-                error: result.error,
-                timedOut: result.timedOut,
-                mediaImages: mediaImages.length,
+    return withPhase(SUMMARIZE_MODEL_PHASE, {
+        'gen_ai.operation.name': 'chat',
+        'gen_ai.provider.name': SUMMARIZE_MULTIMODAL_PROVIDER,
+        'gen_ai.request.model': ISSUE_SUMMARIZE_MULTIMODAL_MODEL,
+    }, async (span) => {
+        try {
+            const result = await model.invoke({
+                modelName: ISSUE_SUMMARIZE_MULTIMODAL_MODEL,
+                prompt: `${prompt}\n\n<media_context>\n${mediaContext}\n</media_context>`,
+                timeoutMs: ISSUE_SUMMARIZE_TIMEOUT_MS,
+                images: mediaImages.map((mediaImage) => buildPiImageContent({
+                    dataBase64: mediaImage.dataBase64,
+                    contentType: mediaImage.contentType,
+                })),
             });
-            return await invokeIssueSummarizeTextModel({ model, prompt });
+            if (!result.ok) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: result.error });
+                logger.warn('Issue summarize multimodal request failed', {
+                    error: result.error,
+                    timedOut: result.timedOut,
+                    mediaImages: mediaImages.length,
+                });
+                return null;
+            }
+            const text = result.output.trim();
+            if (!text) {
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: 'multimodal summarize produced no output',
+                });
+                logger.warn('Issue summarize multimodal request returned empty output', {
+                    mediaImages: mediaImages.length,
+                });
+                return null;
+            }
+            return text;
         }
-        const text = result.output.trim();
-        if (!text) {
-            logger.warn('Issue summarize multimodal request returned empty output', {
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            span.setStatus({ code: SpanStatusCode.ERROR, message });
+            logger.warn('Issue summarize multimodal request errored', {
+                error: message,
                 mediaImages: mediaImages.length,
             });
-            return await invokeIssueSummarizeTextModel({ model, prompt });
+            return null;
         }
-        return text;
-    }
-    catch (error) {
-        logger.warn('Issue summarize multimodal request errored', {
-            error: error instanceof Error ? error.message : String(error),
-            mediaImages: mediaImages.length,
+    });
+}
+export async function invokeIssueSummarizeModel({ model, prompt, mediaImages, }) {
+    if (mediaImages.length === 0) {
+        logger.info('Using text-only summarize model request');
+        return await invokeIssueSummarizeTextModel({
+            model,
+            prompt,
+            phaseName: SUMMARIZE_MODEL_PHASE,
         });
-        return await invokeIssueSummarizeTextModel({ model, prompt });
     }
+    logger.info('Using multimodal summarize model request', {
+        mediaImages: mediaImages.length,
+    });
+    const multimodal = await invokeMultimodalSummarizeModel({ model, prompt, mediaImages });
+    if (multimodal) {
+        return multimodal;
+    }
+    // Multimodal failed — fall back to a separate text request (own model span).
+    return await invokeIssueSummarizeTextModel({ model, prompt, phaseName: SUMMARIZE_MODEL_PHASE });
 }
 function buildChunkSummaryPrompt({ chunk, chunkIndex, selectedChunkCount, totalChunks, }) {
     return `You are preparing an intermediate summary for a GitHub issue discussion.
@@ -97,6 +153,14 @@ ${chunk}
 </chunk_content>`;
 }
 export async function summarizeChunks({ model, chunks, totalChunks, }) {
+    // Workflow phase: it orchestrates one model request PER chunk, so it is not
+    // itself a single gen-AI operation and carries no gen_ai.* attrs.
+    return withPhase('issue-summarize.chunks', {
+        'chunks.selected': chunks.length,
+        'chunks.total': totalChunks,
+    }, async (span) => summarizeChunksInner({ model, chunks, totalChunks }, span));
+}
+async function summarizeChunksInner({ model, chunks, totalChunks, }, span) {
     const summaries = [];
     let missingChunkSummaries = 0;
     logger.info('Summarizing issue thread in chunks', {
@@ -113,6 +177,7 @@ export async function summarizeChunks({ model, chunks, totalChunks, }) {
         const chunkSummary = await invokeIssueSummarizeTextModel({
             model,
             prompt: chunkPrompt,
+            phaseName: SUMMARIZE_CHUNK_PHASE,
         });
         if (chunkSummary?.trim()) {
             summaries.push(`### Chunk ${index + 1}\n${chunkSummary.trim()}`);
@@ -121,7 +186,13 @@ export async function summarizeChunks({ model, chunks, totalChunks, }) {
             missingChunkSummaries += 1;
         }
     }
+    span.setAttributes({ 'chunks.summarized': summaries.length });
     if (summaries.length === 0) {
+        // No chunk produced a model summary — we fall back to raw chunk content.
+        span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: 'chunk summarization produced no model output',
+        });
         logger.warn('Chunk summarization returned no model output, using raw chunk content', {
             selectedChunks: chunks.length,
             totalChunks,

package/sandbox/dist/tasks/issue-summarize/prompt.js

@@ -1,8 +1,8 @@
-import { fillPromptTemplate, loadPromptTemplateFile } from '../../core/prompt-template.js';
+import { fillPromptTemplate, loadPromptTemplateFile, resolvePromptFile, } from '../../core/prompt-template.js';
 const PROMPT_FILE = 'issue-summarize-prompt.md';
 export function loadPromptTemplate() {
     return loadPromptTemplateFile({
-        fileName: PROMPT_FILE,
+        fileName: resolvePromptFile(import.meta.url, PROMPT_FILE),
         promptLabel: 'issue summarize',
     });
 }

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

@@ -1,8 +1,10 @@
+import { SpanStatusCode } from '@opentelemetry/api';
 import { App } from 'octokit';
 import { fetchIssue, fetchIssueComments } from '../../core/github-issues.js';
 import { logger } from '../../core/logging.js';
 import { removeIssueCommentReactionIfPresent } from '../../core/reactions.js';
 import { resolveWriteOctokit } from '../../core/shared.js';
+import { withPhase } from '../../core/tracing.js';
 import { parseSummarizeContext } from './context.js';
 import { buildMediaPromptImages, extractMediaReferences, formatMediaContext, inspectMediaReferences, } from './media.js';
 import { createIssueSummarizeModel, invokeIssueSummarizeModel, summarizeChunks } from './model.js';
@@ -109,108 +111,122 @@ async function main() {
         repository: `${ctx.owner}/${ctx.repo}`,
         issueNumber: ctx.issueNumber,
     });
-    logger.info('Issue summarize task started', {
-        dryRun: ctx.dryRun,
-        issueNumber: ctx.issueNumber,
-    });
-    const { readOctokit, writeOctokit } = await createGitHubClients(ctx);
-    try {
-        const issueParams = {
-            owner: ctx.owner,
-            repo: ctx.repo,
-            issueNumber: ctx.issueNumber,
-            mediaType: { format: 'full' },
-        };
-        const [issue, comments] = await Promise.all([
-            fetchIssue(readOctokit, issueParams),
-            fetchIssueComments(readOctokit, issueParams),
-        ]);
-        logger.info('Loaded issue summarize context', {
-            issueState: issue.state ?? 'unknown',
-            commentsCount: comments.length,
-        });
-        const entries = buildThreadEntries({
-            issue,
-            comments,
-            triggerCommentId: ctx.commentId,
-        });
-        logger.info('Prepared issue summarize thread entries', {
-            issueNumber: issue.number,
-            entryCount: entries.length,
-        });
-        const mediaReferences = extractMediaReferences(entries);
-        const mediaInspections = await inspectMediaReferences(mediaReferences);
-        const mediaInspectionStats = summarizeMediaInspectionStats(mediaInspections);
-        logger.info('Inspected issue summarize media references', {
-            mediaReferences: mediaReferences.length,
-            mediaInspections: mediaInspections.length,
-            mediaFetched: mediaInspectionStats.fetched,
-            mediaFetchFailed: mediaInspectionStats.fetchFailed,
-            mediaNotImage: mediaInspectionStats.notMedia,
-        });
-        const summary = await summarizeIssue({
-            ctx,
-            issue,
-            entries,
-            mediaReferences,
-            mediaInspections,
-        });
-        logger.info('Generated issue summary', {
-            issueNumber: ctx.issueNumber,
-            summaryChars: summary.length,
-        });
-        const summaryComment = `${SUMMARY_MARKER}\n\n${summary}`;
-        if (ctx.dryRun) {
-            logger.info('Dry run enabled, printing summarize output instead of posting comment', {
-                issueNumber: ctx.issueNumber,
-            });
-            process.stdout.write(`${summaryComment}\n`);
-        }
-        else {
-            await writeOctokit.rest.issues.createComment({
+    let exitCode = 0;
+    await withPhase('issue-summarize', {
+        task: 'issue-summarize',
+        'gen_ai.operation.name': 'invoke_agent',
+        'gen_ai.agent.name': 'doistbot.issue-summarize',
+        'issue.number': ctx.issueNumber,
+        'comment.id': ctx.commentId,
+        dry_run: ctx.dryRun,
+    }, async (span) => {
+        // Inside the span so auth/setup failures are captured by the root span.
+        const { readOctokit, writeOctokit } = await createGitHubClients(ctx);
+        try {
+            const issueParams = {
                 owner: ctx.owner,
                 repo: ctx.repo,
-                issue_number: ctx.issueNumber,
-                body: summaryComment,
-            });
-            logger.info('Posted issue summary comment', {
                 issueNumber: ctx.issueNumber,
+                mediaType: { format: 'full' },
+            };
+            const [issue, comments] = await Promise.all([
+                fetchIssue(readOctokit, issueParams),
+                fetchIssueComments(readOctokit, issueParams),
+            ]);
+            logger.info('Loaded issue summarize context', {
+                issueState: issue.state ?? 'unknown',
+                commentsCount: comments.length,
+            });
+            const entries = buildThreadEntries({
+                issue,
+                comments,
+                triggerCommentId: ctx.commentId,
+            });
+            logger.info('Prepared issue summarize thread entries', {
+                issueNumber: issue.number,
+                entryCount: entries.length,
+            });
+            const mediaReferences = extractMediaReferences(entries);
+            const mediaInspections = await inspectMediaReferences(mediaReferences);
+            const mediaInspectionStats = summarizeMediaInspectionStats(mediaInspections);
+            logger.info('Inspected issue summarize media references', {
                 mediaReferences: mediaReferences.length,
+                mediaInspections: mediaInspections.length,
+                mediaFetched: mediaInspectionStats.fetched,
+                mediaFetchFailed: mediaInspectionStats.fetchFailed,
+                mediaNotImage: mediaInspectionStats.notMedia,
             });
-        }
-    }
-    catch (error) {
-        logger.error('Issue summarize task failed', {
-            issueNumber: ctx.issueNumber,
-            error: error instanceof Error ? error.message : String(error),
-        });
-        if (!ctx.dryRun) {
-            try {
+            const summary = await summarizeIssue({
+                ctx,
+                issue,
+                entries,
+                mediaReferences,
+                mediaInspections,
+            });
+            logger.info('Generated issue summary', {
+                issueNumber: ctx.issueNumber,
+                summaryChars: summary.length,
+            });
+            const summaryComment = `${SUMMARY_MARKER}\n\n${summary}`;
+            if (ctx.dryRun) {
+                logger.info('Dry run enabled, printing summarize output instead of posting comment', { issueNumber: ctx.issueNumber });
+                process.stdout.write(`${summaryComment}\n`);
+            }
+            else {
                 await writeOctokit.rest.issues.createComment({
                     owner: ctx.owner,
                     repo: ctx.repo,
                     issue_number: ctx.issueNumber,
-                    body: 'Sorry, I encountered an error while summarizing this issue. Please try again or contact the team maintaining the bot.',
+                    body: summaryComment,
                 });
-            }
-            catch (replyError) {
-                logger.warn('Failed to post summarize error response', {
+                logger.info('Posted issue summary comment', {
                     issueNumber: ctx.issueNumber,
-                    error: replyError instanceof Error ? replyError.message : String(replyError),
+                    mediaReferences: mediaReferences.length,
                 });
             }
         }
-        process.exit(1);
-    }
-    finally {
-        await removeIssueCommentReactionIfPresent({
-            octokit: writeOctokit,
-            owner: ctx.owner,
-            repo: ctx.repo,
-            commentId: ctx.commentId,
-            reactionId: ctx.reactionId,
-            warnMessage: 'Failed to remove summarize reaction',
-        });
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error('Issue summarize task failed', {
+                issueNumber: ctx.issueNumber,
+                error: message,
+            });
+            // Set the span status before the run exits; deferring process.exit
+            // until after withPhase lets phase.end flush.
+            span.setStatus({ code: SpanStatusCode.ERROR, message });
+            if (!ctx.dryRun) {
+                try {
+                    await writeOctokit.rest.issues.createComment({
+                        owner: ctx.owner,
+                        repo: ctx.repo,
+                        issue_number: ctx.issueNumber,
+                        body: 'Sorry, I encountered an error while summarizing this issue. Please try again or contact the team maintaining the bot.',
+                    });
+                }
+                catch (replyError) {
+                    logger.warn('Failed to post summarize error response', {
+                        issueNumber: ctx.issueNumber,
+                        error: replyError instanceof Error
+                            ? replyError.message
+                            : String(replyError),
+                    });
+                }
+            }
+            exitCode = 1;
+        }
+        finally {
+            await removeIssueCommentReactionIfPresent({
+                octokit: writeOctokit,
+                owner: ctx.owner,
+                repo: ctx.repo,
+                commentId: ctx.commentId,
+                reactionId: ctx.reactionId,
+                warnMessage: 'Failed to remove summarize reaction',
+            });
+        }
+    });
+    if (exitCode !== 0) {
+        process.exit(exitCode);
     }
 }
 if (process.env.VITEST !== 'true') {

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

@@ -0,0 +1,40 @@
+import { logger } from '../../core/logging.js';
+import { withPhase } from '../../core/tracing.js';
+import { cloneRepository } from './shared.js';
+export async function cloneTriageRepositories(params) {
+    return withPhase('triage.clone', { 'repos.count': params.repositories.length }, async (span) => {
+        const cloneFn = params.cloneRepositoryImpl ?? cloneRepository;
+        const clonedRepositories = [];
+        const failedRepositories = [];
+        for (const repository of params.repositories) {
+            try {
+                const cloneResult = await cloneFn({
+                    app: params.app,
+                    repository,
+                    reposDir: params.reposDir,
+                    fallbackInstallationId: params.fallbackInstallationId,
+                });
+                clonedRepositories.push(cloneResult);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                // Keep per-repo diagnostics (auth/git errors) visible even
+                // when EVERY clone fails and the orchestrator bails early.
+                logger.warn('Repository clone failed', {
+                    repository: repository.fullName,
+                    error: message,
+                });
+                failedRepositories.push({
+                    repository: repository.fullName,
+                    error: message,
+                });
+            }
+        }
+        span.setAttributes({
+            'clone.success_count': clonedRepositories.length,
+            'clone.failed_count': failedRepositories.length,
+            'repos.count': params.repositories.length,
+        });
+        return { clonedRepositories, failedRepositories };
+    });
+}

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

@@ -1,4 +1,6 @@
 import { optionalPositiveInt, requiredEnv, requiredPositiveInt } from '../../core/shared.js';
+import { withPhase } from '../../core/tracing.js';
+import { extractLabelNames, fetchIssue, fetchIssueComments, } from './shared.js';
 function parseOptionalBoolean(value) {
     const normalized = value?.trim().toLowerCase();
     if (normalized === 'true')
@@ -28,6 +30,7 @@ export function parseIssueTriageContext(env = process.env) {
         privateKey: requiredEnv('PRIVATE_KEY', env),
         githubToken: requiredEnv('GITHUB_TOKEN', env),
         openaiApiKey: parseOpenAIApiKey(env),
+        geminiApiKey: env.GEMINI_API_KEY?.trim() || undefined,
         commentId,
         reactionId,
         placeholderCommentId: optionalPositiveInt(env.PLACEHOLDER_COMMENT_ID),
@@ -35,6 +38,27 @@ export function parseIssueTriageContext(env = process.env) {
         dryRun: env.DRY_RUN?.toLowerCase() === 'true',
         triggerType,
         enableAutoFixOverride: parseOptionalBoolean(env.ENABLE_AUTO_FIX),
-        openRouterApiKey: env.OPENROUTER_API_KEY?.trim() || undefined,
     };
 }
+export async function loadTriageContext(params) {
+    return withPhase('triage.context', { 'issue.number': params.issueNumber }, async (span) => {
+        const [issue, comments] = await Promise.all([
+            fetchIssue(params.octokit, {
+                owner: params.owner,
+                repo: params.repo,
+                issueNumber: params.issueNumber,
+            }),
+            fetchIssueComments(params.octokit, {
+                owner: params.owner,
+                repo: params.repo,
+                issueNumber: params.issueNumber,
+            }),
+        ]);
+        const labelNames = extractLabelNames(issue.labels);
+        span.setAttributes({
+            'comments.count': comments.length,
+            'labels.count': labelNames.length,
+        });
+        return { issue, comments, labelNames };
+    });
+}

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

@@ -1,6 +1,6 @@
 import { execFileSync } from 'child_process';
 import { logger } from '../../core/logging.js';
-import { fillPromptTemplate, loadPromptTemplateFile } from '../../core/prompt-template.js';
+import { fillPromptTemplate, loadPromptTemplateFile, resolvePromptFile, } from '../../core/prompt-template.js';
 import { validateDiff } from './diff-validator.js';
 import { CODEX_CANNOT_FIX_REASON, FIX_LOOP_FAILED_REASON_PREFIX } from './fix-failure-reasons.js';
 import { CX_HERO_MANUAL_HANDLE, resolveHeroGroup } from './hero-group-map.js';
@@ -24,7 +24,7 @@ export function buildFixAssessmentSkipReason(assessment) {
 }
 function loadFixPromptTemplate() {
     return loadPromptTemplateFile({
-        fileName: FIX_PROMPT_FILE,
+        fileName: resolvePromptFile(import.meta.url, FIX_PROMPT_FILE),
         promptLabel: 'issue triage fix',
     });
 }
@@ -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;