@blogic-cz/agent-tools 0.14.57 → 0.14.59

package/src/gh-tool/pr/index.ts

@@ -25,4 +25,5 @@ export {
   prReviewTriageCommand,
   prReviewTriageBatchCommand,
   prViewCommand,
+  prWatchCommand,
 } from "./commands";

package/src/gh-tool/pr/review.ts

@@ -8,6 +8,7 @@ import type {
   PullRequestReview,
   ReviewComment,
   ReviewThread,
+  FeedbackOrigin,
 } from "#gh/types";
 
 import { GitHubCommandError } from "#gh/errors";
@@ -27,7 +28,7 @@ const REVIEW_THREADS_QUERY = `
           nodes {
             id
             isResolved
-            comments(first: 1) {
+            comments(first: 100) {
               nodes {
                 id
                 databaseId
@@ -35,7 +36,9 @@ const REVIEW_THREADS_QUERY = `
                 line
                 body
                 author { login }
+                commit { oid }
               }
+              pageInfo { hasNextPage endCursor }
             }
           }
           pageInfo {
@@ -48,6 +51,27 @@ const REVIEW_THREADS_QUERY = `
   }
 `;
 
+const REVIEW_THREAD_COMMENTS_QUERY = `
+  query($threadId: ID!, $after: String) {
+    node(id: $threadId) {
+      ... on PullRequestReviewThread {
+        comments(first: 100, after: $after) {
+          nodes {
+            id
+            databaseId
+            path
+            line
+            body
+            author { login }
+            commit { oid }
+          }
+          pageInfo { hasNextPage endCursor }
+        }
+      }
+    }
+  }
+`;
+
 const RESOLVE_THREAD_MUTATION = `
   mutation($threadId: ID!) {
     resolveReviewThread(input: {threadId: $threadId}) {
@@ -143,10 +167,16 @@ type ThreadNode = {
       line: number;
       body: string;
       author: { login: string };
+      commit: { oid: string } | null;
     }>;
+    pageInfo?: { hasNextPage: boolean; endCursor: string | null };
   };
 };
 
+type ThreadCommentsQueryResult = {
+  node: { comments: ThreadNode["comments"] } | null;
+};
+
 type ThreadsQueryResult = {
   repository: {
     pullRequest: {
@@ -225,6 +255,7 @@ type RawReviewComment = {
   path: string;
   line: number;
   created_at: string;
+  commit_id?: string | null;
 };
 
 type RawIssueComment = {
@@ -242,6 +273,7 @@ type RawPullRequestReview = {
   body: string | null;
   submitted_at: string | null;
   html_url: string;
+  commit_id?: string | null;
 };
 
 type ReviewCommentById = {
@@ -252,6 +284,13 @@ type ReviewCommentById = {
 
 const REST_PAGE_SIZE = 100;
 
+const feedbackOrigin = (commitSha: string | null, currentHeadSha: string | null): FeedbackOrigin =>
+  commitSha === null || currentHeadSha === null
+    ? "unknown"
+    : commitSha === currentHeadSha
+      ? "current_head"
+      : "pre_existing";
+
 const parseJson = <T>(
   stdout: string,
   command: string,
@@ -312,7 +351,20 @@ const fetchAllThreadNodes = Effect.fn("pr.fetchAllThreadNodes")(function* (pr: n
     })) as ThreadsQueryResult;
 
     const page = response.repository.pullRequest.reviewThreads;
-    nodes.push(...page.nodes);
+    for (const node of page.nodes) {
+      let commentsAfter = node.comments.pageInfo?.endCursor ?? null;
+      while (node.comments.pageInfo?.hasNextPage && commentsAfter !== null) {
+        const commentsResponse = (yield* service.runGraphQL(REVIEW_THREAD_COMMENTS_QUERY, {
+          threadId: node.id,
+          after: commentsAfter,
+        })) as ThreadCommentsQueryResult;
+        if (commentsResponse.node === null) break;
+        node.comments.nodes.push(...commentsResponse.node.comments.nodes);
+        node.comments.pageInfo = commentsResponse.node.comments.pageInfo;
+        commentsAfter = commentsResponse.node.comments.pageInfo?.endCursor ?? null;
+      }
+      nodes.push(node);
+    }
 
     if (!page.pageInfo.hasNextPage || page.pageInfo.endCursor === null) {
       return nodes;
@@ -322,7 +374,11 @@ const fetchAllThreadNodes = Effect.fn("pr.fetchAllThreadNodes")(function* (pr: n
   }
 });
 
-const enrichThreads = (threads: ThreadNode[], reviewComments: ReviewComment[]): ReviewThread[] => {
+const enrichThreads = (
+  threads: ThreadNode[],
+  reviewComments: ReviewComment[],
+  currentHeadSha: string | null,
+): ReviewThread[] => {
   const repliesByRootCommentId = new Map<number, ReviewComment[]>();
 
   for (const comment of reviewComments) {
@@ -358,6 +414,8 @@ const enrichThreads = (threads: ThreadNode[], reviewComments: ReviewComment[]):
       return {
         threadId: node.id,
         commentId: comment.databaseId,
+        commitSha: comment.commit?.oid ?? null,
+        feedbackOrigin: feedbackOrigin(comment.commit?.oid ?? null, currentHeadSha),
         path: comment.path,
         line: comment.line,
         body: comment.body,
@@ -368,6 +426,7 @@ const enrichThreads = (threads: ThreadNode[], reviewComments: ReviewComment[]):
         isVisibleOpen: !node.isResolved || needsHumanReply,
         lastReplyAuthor: lastReply?.author ?? null,
         lastReplyAt: lastReply?.createdAt ?? null,
+        duplicateThreadIds: [] as string[],
       };
     })
     .filter((thread): thread is ReviewThread => thread !== null);
@@ -383,21 +442,30 @@ const enrichThreads = (threads: ThreadNode[], reviewComments: ReviewComment[]):
       continue;
     }
     const existing = deduped[existingIndex];
-    if (existing !== undefined && existing.isResolved && !thread.isResolved) {
+    if (existing === undefined) {
+      continue;
+    }
+    if (existing.isResolved && !thread.isResolved) {
+      thread.duplicateThreadIds = [existing.threadId, ...existing.duplicateThreadIds];
       deduped[existingIndex] = thread;
+    } else {
+      existing.duplicateThreadIds.push(thread.threadId);
     }
   }
 
   return deduped;
 };
 
-const fetchThreadState = Effect.fn("pr.fetchThreadState")(function* (pr: number) {
+const fetchThreadState = Effect.fn("pr.fetchThreadState")(function* (
+  pr: number,
+  currentHeadSha: string | null = null,
+) {
   const [threads, reviewComments] = yield* Effect.all([
     fetchAllThreadNodes(pr),
     fetchComments(pr, null),
   ]);
 
-  return enrichThreads(threads, reviewComments);
+  return enrichThreads(threads, reviewComments, currentHeadSha);
 });
 
 // ---------------------------------------------------------------------------
@@ -406,6 +474,8 @@ const fetchThreadState = Effect.fn("pr.fetchThreadState")(function* (pr: number)
 
 const mapRawIssueComment = (comment: RawIssueComment): IssueComment => ({
   id: comment.id as IssueCommentId,
+  commitSha: null,
+  feedbackOrigin: "unknown",
   author: comment.user.login,
   body: comment.body,
   createdAt: comment.created_at as IsoTimestamp,
@@ -420,9 +490,10 @@ export const fetchThreads = Effect.fn("pr.fetchThreads")(function* (
   pr: number | null,
   unresolvedOnly: boolean,
   visibleOpenOnly = false,
+  currentHeadSha: string | null = null,
 ) {
   const resolvedPr = pr ?? (yield* viewPR(null)).number;
-  const threads = yield* fetchThreadState(resolvedPr);
+  const threads = yield* fetchThreadState(resolvedPr, currentHeadSha);
 
   if (visibleOpenOnly) {
     return threads.filter((thread) => thread.isVisibleOpen);
@@ -438,6 +509,7 @@ export const fetchThreads = Effect.fn("pr.fetchThreads")(function* (
 export const fetchComments = Effect.fn("pr.fetchComments")(function* (
   pr: number | null,
   since: string | null,
+  currentHeadSha: string | null = null,
 ) {
   const service = yield* GitHubService;
   const repoInfo = yield* service.getRepoInfo();
@@ -452,6 +524,8 @@ export const fetchComments = Effect.fn("pr.fetchComments")(function* (
 
   const comments: ReviewComment[] = raw.map((c) => ({
     id: c.id,
+    commitSha: c.commit_id ?? null,
+    feedbackOrigin: feedbackOrigin(c.commit_id ?? null, currentHeadSha),
     inReplyToId: c.in_reply_to_id,
     author: c.user.login,
     body: c.body,
@@ -519,6 +593,7 @@ export const fetchReviews = Effect.fn("pr.fetchReviews")(function* (
   author: string | null,
   bodyContains: string | null,
   state: string | null,
+  currentHeadSha: string | null = null,
 ) {
   const service = yield* GitHubService;
   const repoInfo = yield* service.getRepoInfo();
@@ -534,6 +609,8 @@ export const fetchReviews = Effect.fn("pr.fetchReviews")(function* (
   let reviews: PullRequestReview[] = raw
     .map((review) => ({
       id: review.id,
+      commitSha: review.commit_id ?? null,
+      feedbackOrigin: feedbackOrigin(review.commit_id ?? null, currentHeadSha),
       author: review.user?.login ?? "unknown",
       state: review.state,
       body: review.body ?? "",
@@ -565,13 +642,15 @@ export const fetchReviews = Effect.fn("pr.fetchReviews")(function* (
  * all review threads with resolution state, inline review comments, and issue
  * (discussion) comments. Collapses the four separate fetches agents otherwise stitch.
  */
-export const fetchFeedback = Effect.fn("pr.fetchFeedback")(function* (pr: number | null) {
+export const fetchFeedback = Effect.fn("pr.fetchFeedback")(function* (
+  pr: number | null,
+  currentHeadSha: string | null = null,
+) {
   const resolvedPr = pr ?? (yield* viewPR(null)).number;
-
   const [reviews, threads, inlineComments, issueComments] = yield* Effect.all([
-    fetchReviews(resolvedPr, null, null, null),
-    fetchThreads(resolvedPr, false),
-    fetchComments(resolvedPr, null),
+    fetchReviews(resolvedPr, null, null, null, currentHeadSha),
+    fetchThreads(resolvedPr, false, false, currentHeadSha),
+    fetchComments(resolvedPr, null, currentHeadSha),
     fetchIssueComments(resolvedPr, null, null, null),
   ]);
 
@@ -796,6 +875,101 @@ export const replyToComment = Effect.fn("pr.replyToComment")(function* (
   return { success: true as const, commentId: parsed.id };
 });
 
+/**
+ * Reply to a review comment, infer and validate its PR and thread, then resolve that thread.
+ */
+export const replyAndResolveComment = Effect.fn("pr.replyAndResolveComment")(function* (
+  pr: number | null,
+  commentId: number,
+  threadId: string | null,
+  body: string,
+) {
+  const target = yield* fetchReviewCommentById(commentId).pipe(
+    Effect.catchTags({
+      GitHubNotFoundError: () =>
+        Effect.fail(
+          new GitHubCommandError({
+            command: "gh-tool pr reply-and-resolve",
+            exitCode: 1,
+            stderr: `Review comment ${commentId} was not found; it may be deleted`,
+            message: `Review comment ${commentId} was not found; it may be deleted`,
+          }),
+        ),
+      GitHubCommandError: () =>
+        Effect.fail(
+          new GitHubCommandError({
+            command: "gh-tool pr reply-and-resolve",
+            exitCode: 1,
+            stderr: `Could not load review comment ${commentId}`,
+            message: `Could not load review comment ${commentId}`,
+          }),
+        ),
+    }),
+  );
+  const inferredPr = Number(target.pull_request_url.match(/\/pulls\/(\d+)\/?$/)?.[1]);
+  if (!Number.isInteger(inferredPr) || inferredPr < 1) {
+    return yield* Effect.fail(
+      new GitHubCommandError({
+        command: "gh-tool pr reply-and-resolve",
+        exitCode: 1,
+        stderr: `Comment ${commentId} has no usable pull request URL`,
+        message: `Comment ${commentId} has no usable pull request URL`,
+      }),
+    );
+  }
+  if (pr !== null && pr !== inferredPr) {
+    return yield* Effect.fail(
+      new GitHubCommandError({
+        command: "gh-tool pr reply-and-resolve",
+        exitCode: 1,
+        stderr: `Comment ${commentId} belongs to PR #${inferredPr}, not explicit PR #${pr}`,
+        message: `Comment ${commentId} belongs to PR #${inferredPr}, not explicit PR #${pr}`,
+      }),
+    );
+  }
+  const rootCommentId = target.in_reply_to_id ?? target.id;
+  const matches = (yield* fetchAllThreadNodes(inferredPr)).filter((thread) =>
+    thread.comments.nodes.some(
+      (comment) => comment.databaseId === target.id || comment.databaseId === rootCommentId,
+    ),
+  );
+  if (matches.length === 0) {
+    return yield* Effect.fail(
+      new GitHubCommandError({
+        command: "gh-tool pr reply-and-resolve",
+        exitCode: 1,
+        stderr: `Comment ${commentId} has no review thread; it may be deleted`,
+        message: `Comment ${commentId} has no review thread; it may be deleted`,
+      }),
+    );
+  }
+  if (matches.length > 1) {
+    return yield* Effect.fail(
+      new GitHubCommandError({
+        command: "gh-tool pr reply-and-resolve",
+        exitCode: 1,
+        stderr: `Comment ${commentId} matches multiple review threads`,
+        message: `Comment ${commentId} matches multiple review threads`,
+      }),
+    );
+  }
+  const inferredThreadId = matches[0]?.id;
+  if (inferredThreadId === undefined) return yield* Effect.die("matched thread missing");
+  if (threadId !== null && threadId !== inferredThreadId) {
+    return yield* Effect.fail(
+      new GitHubCommandError({
+        command: "gh-tool pr reply-and-resolve",
+        exitCode: 1,
+        stderr: `Comment ${commentId} belongs to thread ${inferredThreadId}, not explicit thread ${threadId}`,
+        message: `Comment ${commentId} belongs to thread ${inferredThreadId}, not explicit thread ${threadId}`,
+      }),
+    );
+  }
+  const reply = yield* replyToComment(inferredPr, commentId, body);
+  const resolve = yield* resolveThread(inferredThreadId);
+  return { reply, resolve, pr: inferredPr, threadId: inferredThreadId };
+});
+
 /**
  * Resolve a review thread via GraphQL mutation.
  */

package/src/gh-tool/types.ts

@@ -18,14 +18,21 @@ export type ReviewRequest =
   | { __typename: "Team"; name: string; slug: string };
 
 export type PRViewInfo = PRInfo & {
+  headSha: string | null;
+  baseSha: string | null;
   body: string;
   author: { login: string; is_bot: boolean };
   reviewDecision: "APPROVED" | "CHANGES_REQUESTED" | "REVIEW_REQUIRED" | "";
   reviewRequests: ReviewRequest[];
 };
 
+export const FeedbackOrigin = Schema.Literals(["current_head", "pre_existing", "unknown"]);
+export type FeedbackOrigin = typeof FeedbackOrigin.Type;
+
 export type ReviewThread = {
   threadId: string;
+  commitSha: string | null;
+  feedbackOrigin: FeedbackOrigin;
   commentId: number;
   path: string;
   line: number;
@@ -37,10 +44,14 @@ export type ReviewThread = {
   isVisibleOpen: boolean;
   lastReplyAuthor: string | null;
   lastReplyAt: string | null;
+  /** Thread ids of exact duplicates collapsed into this representative (encounter order). */
+  duplicateThreadIds: string[];
 };
 
 export type ReviewComment = {
   id: number;
+  commitSha: string | null;
+  feedbackOrigin: FeedbackOrigin;
   inReplyToId: number | null;
   author: string;
   body: string;
@@ -60,6 +71,8 @@ export type GitHubIssueCommentUrl = typeof GitHubIssueCommentUrl.Type;
 
 export type IssueComment = {
   id: IssueCommentId;
+  commitSha: null;
+  feedbackOrigin: "unknown";
   author: string;
   body: string;
   createdAt: IsoTimestamp;
@@ -68,6 +81,8 @@ export type IssueComment = {
 
 export type PullRequestReview = {
   id: number;
+  commitSha: string | null;
+  feedbackOrigin: FeedbackOrigin;
   author: string;
   state: string;
   body: string;
@@ -84,6 +99,8 @@ export type CheckResult = {
 
 export type FailedCheckJob = {
   databaseId: number;
+  jobId: number;
+  checkId: number | null;
   name: string;
   status: string;
   conclusion: string | null;
@@ -93,6 +110,7 @@ export type FailedCheckJob = {
 
 export type FailedCheckRunContext = {
   runId: number;
+  attempt: number | null;
   url: string | null;
   workflowName: string | null;
   status: string;
@@ -104,9 +122,83 @@ export type FailedCheckDetail = CheckResult & {
   runId: number | null;
   run: FailedCheckRunContext | null;
   failedStepLogs?: string;
+  diagnosis?: LogDiagnosis;
+};
+
+export const LogDiagnosisCategory = Schema.Literals([
+  "infrastructure",
+  "network",
+  "timeout",
+  "test_failure",
+  "build_failure",
+  "lint_failure",
+  "unknown",
+]);
+export type LogDiagnosisCategory = typeof LogDiagnosisCategory.Type;
+
+export type LogDiagnosis = {
+  category: LogDiagnosisCategory;
+  fingerprint: string;
+  testsStarted: boolean | null;
+  firstRelevantError: string | null;
+};
+
+export const RerunRetryEvidenceState = Schema.Literals(["eligible", "ineligible", "unavailable"]);
+export type RerunRetryEvidenceState = typeof RerunRetryEvidenceState.Type;
+
+export type RerunRetryEvidence =
+  | { state: "eligible"; diagnosis: LogDiagnosis }
+  | { state: "ineligible"; diagnosis: LogDiagnosis; reason: string }
+  | { state: "unavailable"; reason: string };
+
+export const RerunCheckStatus = Schema.Literals([
+  "blocked",
+  "evidence_unavailable",
+  "escalation_required",
+  "rerun_started",
+  "failed",
+  "discovery_timeout",
+  "completed",
+  "watch_timeout",
+]);
+export type RerunCheckStatus = typeof RerunCheckStatus.Type;
+
+export type RerunCheckJob = {
+  databaseId: number;
+  name: string;
+  status: string;
+  conclusion: string | null;
+};
+
+export type RerunCheckAttempt = {
+  databaseId: number;
+  attempt?: number | null;
+  jobs: RerunCheckJob[];
+  status?: string;
+};
+
+export type RerunChecksRun = {
+  runId: string;
+  success: boolean;
+  currentAttempt: number | null;
+  currentJobIds: number[] | null;
+  evidence: RerunRetryEvidence;
+  status: RerunCheckStatus;
+  newAttempt?: number | null;
+  newJobIds?: number[] | null;
+  latestAttempt?: RerunCheckAttempt | null;
+};
+
+export type RerunChecksReport = {
+  rerun: number;
+  failed?: number;
+  message: string;
+  status?: "evidence_unavailable" | "escalation_required" | "failed" | "rerun_started";
+  runs?: RerunChecksRun[];
 };
 
 export type FailedChecksReport = {
+  evidence: { headSha: string | null; baseSha: string | null } | null;
   status: "failed" | "no_failures";
   message: string;
   summary: {
@@ -123,6 +215,7 @@ export type FailedChecksReport = {
 
 export type WorkflowRunDetail = {
   databaseId: number;
+  attempt: number | null;
   url: string;
   workflowName: string | null;
   status: string;

package/src/gh-tool/workflow.ts

@@ -5,7 +5,7 @@ import { formatOption, logFormatted } from "#shared";
 import { CI_CHECK_WATCH_TIMEOUT_MS } from "#gh/config";
 import { GitHubCommandError, GitHubNotFoundError } from "./errors";
 import { GitHubService } from "./service";
-import type { CheckRunAnnotation, JobAnnotations } from "./types";
+import type { CheckRunAnnotation, JobAnnotations, LogDiagnosis } from "./types";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -45,7 +45,7 @@ type WorkflowRunDetail = WorkflowRun & {
   jobs: WorkflowJob[];
 };
 
-type LogEntry = {
+export type LogEntry = {
   step: string;
   message: string;
 };
@@ -438,6 +438,60 @@ export function formatLogEntries(entries: LogEntry[]): string {
 // Job-level log handlers
 // ---------------------------------------------------------------------------
 
+const normalizeFingerprint = (message: string) =>
+  message
+    .toLowerCase()
+    .replace(/https?:\/\/\S+/g, "<url>")
+    .replace(/(?:0x)?[0-9a-f]{8,}/gi, "<id>")
+    .replace(/\b\d+\b/g, "<n>")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 240);
+
+export const diagnoseLogEntries = (entries: readonly LogEntry[]): LogDiagnosis => {
+  const lines = entries.map((entry) => entry.message);
+  const text = lines.join("\n");
+  const find = (pattern: RegExp) => lines.find((line) => pattern.test(line)) ?? null;
+  const testsStarted =
+    /\b(vitest|jest|pytest|go test|cargo test|test suites?|tests? (?:run|failed))\b/i.test(text)
+      ? true
+      : /\b(install|checkout|restore|setup)\b/i.test(text)
+        ? false
+        : null;
+  const matched = [
+    [
+      "infrastructure",
+      /no space left on device|disk full|corrupt.*nuget|nuget.*corrupt|address already in use|socket.*bind/i,
+    ],
+    [
+      "network",
+      /econnreset|enotfound|network.*(?:error|timeout)|connection (?:reset|refused)|could not resolve host/i,
+    ],
+    ["timeout", /timed? ?out|deadline exceeded/i],
+    ["lint_failure", /\b(?:eslint|oxlint|lint)\b.*(?:error|failed)|lint failed/i],
+    ["build_failure", /\b(?:build|compile|typescript)\b.*(?:error|failed)|compilation failed/i],
+    ["test_failure", /\b(?:test|tests|vitest|jest|pytest)\b.*(?:fail|error)|\d+ failing/i],
+  ] as const;
+  for (const [category, pattern] of matched) {
+    const error = find(pattern);
+    if (error !== null) {
+      return {
+        category,
+        fingerprint: `${category}:${normalizeFingerprint(error)}`,
+        testsStarted,
+        firstRelevantError: error,
+      };
+    }
+  }
+  const firstRelevantError = find(/\b(error|failed|fatal|exception)\b/i);
+  return {
+    category: "unknown",
+    fingerprint: `unknown:${normalizeFingerprint(firstRelevantError ?? lines[0] ?? "no-log-output")}`,
+    testsStarted,
+    firstRelevantError,
+  };
+};
+
 const resolveJobId = Effect.fn("workflow.resolveJobId")(function* (
   runId: number,
   jobName: string,
@@ -500,6 +554,7 @@ export const fetchJobLogs = Effect.fn("workflow.fetchJobLogs")(function* (opts:
   jobId?: number | null;
   failedStepNames?: readonly string[] | null;
   failedStepsOnly: boolean;
+  diagnose?: boolean;
   format: string;
   repo: string | null;
 }) {
@@ -549,13 +604,12 @@ export const fetchJobLogs = Effect.fn("workflow.fetchJobLogs")(function* (opts:
     }
   }
 
+  if (opts.diagnose) {
+    return { runId: opts.runId, job: opts.job, jobId, diagnosis: diagnoseLogEntries(entries) };
+  }
+
   if (opts.format === "json") {
-    return {
-      runId: opts.runId,
-      job: opts.job,
-      jobId,
-      entries,
-    };
+    return { runId: opts.runId, job: opts.job, jobId, entries };
   }
 
   return {
@@ -770,6 +824,10 @@ export const workflowWatchCommand = Command.make(
 export const workflowJobLogsCommand = Command.make(
   "job-logs",
   {
+    diagnose: Flag.boolean("diagnose").pipe(
+      Flag.withDescription("Return concise failure diagnosis metadata without log entries"),
+      Flag.withDefault(false),
+    ),
     failedStepsOnly: Flag.boolean("failed-steps-only").pipe(
       Flag.withDescription("Only show logs from failed steps (default: false)"),
       Flag.withDefault(false),
@@ -781,13 +839,14 @@ export const workflowJobLogsCommand = Command.make(
     repo: repoOption,
     run: Flag.integer("run").pipe(Flag.withDescription("Workflow run ID")),
   },
-  ({ failedStepsOnly, format, job, repo, run }) =>
+  ({ diagnose, failedStepsOnly, format, job, repo, run }) =>
     Effect.gen(function* () {
       const resolvedRepo = yield* resolveRepoArg(repo);
       const result = yield* fetchJobLogs({
         runId: run,
         job,
         failedStepsOnly,
+        diagnose,
         format,
         repo: resolvedRepo,
       });