@blogic-cz/agent-tools 1.12.0 → 1.13.1

package/src/gh-tool/pr/checkbox-markdown.ts

@@ -0,0 +1,317 @@
+export type CheckboxOutlineEntry =
+  | { readonly type: "task"; readonly text: string; readonly checked: boolean }
+  | { readonly type: "heading"; readonly text: string; readonly level: number };
+
+export type CheckboxOutlineParser = (body: string) => readonly CheckboxOutlineEntry[] | null;
+
+type CheckboxLine = {
+  readonly before: string;
+  readonly offset: number;
+  readonly boxIndex: number;
+  readonly checked: boolean;
+};
+
+type ScannedEntry = CheckboxOutlineEntry & {
+  readonly offset?: number;
+  readonly boxIndex?: number;
+  readonly before?: string;
+};
+
+type Fence = {
+  readonly marker: "`" | "~";
+  readonly length: number;
+  readonly listIndent: number | null;
+};
+type ListItemIndent = { readonly indent: number; readonly contentIndent: number };
+
+const taskSuffix = /^[ \t]*\[([ xX])\][ \t]*(.*)$/;
+const listMarker = /^( {0,3})(?:[-*+]|[0-9]+[.)])([ \t]+)/;
+const quoteMarker = /^ {0,3}>[ \t]?/;
+const plainSourceText = (text: string) =>
+  text
+    .replace(/(\*\*|__|~~|\*|_)(\S(?:.*?\S)?)\1/g, "$2")
+    .replace(/&/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;|&apos;/g, "'")
+    .trim();
+
+const removeContainers = (line: string) => {
+  let cursor = 0;
+  for (;;) {
+    const rest = line.slice(cursor);
+    const quote = quoteMarker.exec(rest);
+    if (quote !== null) {
+      cursor += quote[0].length;
+      continue;
+    }
+    const list = listMarker.exec(rest);
+    if (list !== null) {
+      cursor += list[0].length;
+      continue;
+    }
+    return { text: line.slice(cursor), cursor };
+  }
+};
+
+const openingFence = (line: string, listIndent: number | null): Fence | null => {
+  const content = removeContainers(line).text;
+  const match = /^ {0,3}(`{3,}|~{3,})([^\r\n]*)\r?$/.exec(content);
+  if (match === null) return null;
+  const marker = match[1]?.[0];
+  const info = match[2] ?? "";
+  if ((marker !== "`" && marker !== "~") || (marker === "`" && info.includes("`"))) return null;
+  return { marker, length: match[1]?.length ?? 0, listIndent };
+};
+
+const closesFence = (line: string, fence: Fence) => {
+  const content = removeContainers(line).text;
+  const match = /^ {0,3}(`+|~+)[ \t]*\r?$/.exec(content);
+  const markers = match?.[1] ?? "";
+  return markers.length >= fence.length && markers[0] === fence.marker;
+};
+
+const headingFromLine = (line: string) => {
+  const { text } = removeContainers(line);
+  const match = /^ {0,3}(#{1,6})[ \t]+(.*?)\r?$/.exec(text);
+  if (match === null) return null;
+  return {
+    level: match[1]?.length ?? 0,
+    text: plainSourceText((match[2] ?? "").replace(/[ \t]+#+[ \t]*$/, "")),
+  };
+};
+
+const scanOutline = (body: string): ScannedEntry[] => {
+  const entries: ScannedEntry[] = [];
+  const lines = body.match(/[^\n]*(?:\n|$)/g) ?? [];
+  let offset = 0;
+  let fence: Fence | null = null;
+  const listItems: ListItemIndent[] = [];
+
+  for (const raw of lines) {
+    if (raw.length === 0) continue;
+    const line = (raw.endsWith("\n") ? raw.slice(0, -1) : raw).replace(/\r$/, "");
+    const lineStart = offset;
+    offset += raw.length;
+
+    const marker = listMarker.exec(line);
+    if (marker !== null) {
+      const indent = marker[1]?.length ?? 0;
+      while ((listItems.at(-1)?.indent ?? -1) >= indent) {
+        listItems.pop();
+      }
+      listItems.push({ indent, contentIndent: indent + marker[0].length });
+    } else if (line.trim() !== "") {
+      const leading = /^ */.exec(line)?.[0].length ?? 0;
+      while (listItems.length > 0 && leading < (listItems.at(-1)?.contentIndent ?? 0)) {
+        listItems.pop();
+      }
+    }
+
+    if (fence !== null) {
+      if (fence.listIndent !== null && line.trim() !== "") {
+        const leading = /^ */.exec(line)?.[0].length ?? 0;
+        if (leading < fence.listIndent) fence = null;
+      }
+      if (fence !== null) {
+        if (closesFence(line, fence)) fence = null;
+        continue;
+      }
+    }
+
+    const context = listItems.at(-1);
+    const opening = openingFence(line, context?.contentIndent ?? null);
+    if (opening !== null) {
+      fence = opening;
+      continue;
+    }
+
+    const heading = headingFromLine(line);
+    if (heading !== null) {
+      entries.push({ type: "heading", ...heading });
+      continue;
+    }
+
+    const { text, cursor } = removeContainers(line);
+    const task = taskSuffix.exec(text);
+    if (task === null) continue;
+    const checked = task[1] !== " ";
+    const boxIndex = cursor + (text.indexOf("[") + 1);
+    const content = plainSourceText(task[2] ?? "");
+    entries.push({
+      type: "task",
+      text: content,
+      checked,
+      offset: lineStart + boxIndex,
+      boxIndex,
+      before: line.replace(/\r$/, ""),
+    });
+  }
+  return entries;
+};
+
+const tokenPrefix = "\uE000checkbox:";
+const tokenSuffix = ":\uE001";
+const makeToken = (id: number) => `${tokenPrefix}${id}${tokenSuffix}`;
+const tokenPattern = /\uE000checkbox:(\d+):\uE001/g;
+
+export const bunMarkdownOutline: CheckboxOutlineParser = (body) => {
+  const markdown = (globalThis as typeof globalThis & { Bun?: typeof Bun }).Bun?.markdown;
+  if (markdown?.render === undefined) return null;
+
+  const nodes: Array<{ readonly entry: CheckboxOutlineEntry | null; readonly children: string }> =
+    [];
+  const token = (entry: CheckboxOutlineEntry | null, children: string) => {
+    const id = nodes.push({ entry, children }) - 1;
+    return makeToken(id);
+  };
+  const plain = (value: string) => value.replace(tokenPattern, "").trim();
+
+  const rendered = markdown.render(body, {
+    text: (children) => children,
+    strong: (children) => children,
+    emphasis: (children) => children,
+    strikethrough: (children) => children,
+    link: (children) => children,
+    image: (children) => children,
+    codespan: (children) => children,
+    heading: (children, meta) =>
+      token({ type: "heading", level: meta.level, text: plain(children) }, children),
+    listItem: (children, meta) =>
+      token(
+        typeof meta.checked === "boolean"
+          ? { type: "task", checked: meta.checked, text: plain(children) }
+          : null,
+        children,
+      ),
+  });
+
+  const outline: CheckboxOutlineEntry[] = [];
+  const expand = (value: string) => {
+    for (const match of value.matchAll(tokenPattern)) {
+      const idText = match[1];
+      const id = idText === undefined ? -1 : Number(idText);
+      const node = nodes[id];
+      if (node === undefined || match.index === undefined)
+        throw new Error("Invalid Bun Markdown callback outline");
+      if (node.entry !== null) outline.push(node.entry);
+      expand(node.children);
+    }
+  };
+  expand(rendered);
+  return outline;
+};
+
+const sameOutline = (scanned: readonly ScannedEntry[], parsed: readonly CheckboxOutlineEntry[]) => {
+  return (
+    scanned.length === parsed.length &&
+    scanned.every((entry, index) => {
+      const actual = parsed[index];
+      return (
+        actual !== undefined &&
+        entry.type === actual.type &&
+        entry.text === actual.text &&
+        (entry.type !== "heading" || (actual.type === "heading" && entry.level === actual.level)) &&
+        (entry.type !== "task" || (actual.type === "task" && entry.checked === actual.checked))
+      );
+    })
+  );
+};
+
+const sameEntry = (left: CheckboxOutlineEntry, right: CheckboxOutlineEntry) =>
+  left.type === right.type &&
+  left.text === right.text &&
+  (left.type !== "heading" || (right.type === "heading" && left.level === right.level)) &&
+  (left.type !== "task" || (right.type === "task" && left.checked === right.checked));
+
+export const validateCheckboxEdit = (
+  body: string,
+  offset: number,
+  replacement: " " | "x",
+  parseOutline: CheckboxOutlineParser = bunMarkdownOutline,
+) => {
+  const scanned = scanOutline(body);
+  const original = parseOutline(body);
+  const selectedIndex = scanned.findIndex(
+    (entry) => entry.type === "task" && entry.offset === offset,
+  );
+  if (
+    original === null ||
+    !sameOutline(scanned, original) ||
+    selectedIndex < 0 ||
+    original[selectedIndex]?.type !== "task" ||
+    body[offset] === undefined ||
+    (replacement !== " " && replacement !== "x")
+  ) {
+    throw new Error("PR body structure is ambiguous; tick this item in the GitHub UI");
+  }
+
+  const editedBody = `${body.slice(0, offset)}${replacement}${body.slice(offset + 1)}`;
+  const edited = parseOutline(editedBody);
+  if (edited === null || edited.length !== original.length) {
+    throw new Error("PR body structure is ambiguous; tick this item in the GitHub UI");
+  }
+
+  const expected = [...original];
+  const selected = expected[selectedIndex];
+  if (selected?.type === "task") {
+    expected[selectedIndex] = { ...selected, checked: replacement !== " " };
+  }
+  if (
+    !edited.every((entry, index) => {
+      const expectedEntry = expected[index];
+      return expectedEntry !== undefined && sameEntry(expectedEntry, entry);
+    })
+  ) {
+    throw new Error("PR body structure is ambiguous; tick this item in the GitHub UI");
+  }
+};
+
+export const findCheckboxLines = (
+  body: string,
+  match: string,
+  section: string | null,
+  parseOutline: CheckboxOutlineParser = bunMarkdownOutline,
+) => {
+  const scanned = scanOutline(body);
+  const parsed = parseOutline(body);
+  if (parsed === null || !sameOutline(scanned, parsed)) {
+    throw new Error("PR body structure is ambiguous; tick this item in the GitHub UI");
+  }
+
+  const matches: CheckboxLine[] = [];
+  let sectionLevel: number | null = null;
+  let inSection = section === null;
+
+  for (const entry of scanned) {
+    if (entry.type === "heading") {
+      if (sectionLevel !== null && entry.level <= sectionLevel) {
+        inSection = false;
+        sectionLevel = null;
+      }
+      if (section !== null && entry.text === section) {
+        inSection = true;
+        sectionLevel = entry.level;
+      }
+      continue;
+    }
+    if (!inSection || !entry.text.includes(match)) continue;
+    if (entry.offset === undefined || entry.boxIndex === undefined || entry.before === undefined)
+      continue;
+    matches.push({
+      before: entry.before,
+      offset: entry.offset,
+      boxIndex: entry.boxIndex,
+      checked: entry.checked,
+    });
+  }
+  return matches;
+};
+
+export const scanCheckboxOutline = (body: string): readonly CheckboxOutlineEntry[] =>
+  scanOutline(body).map((entry) =>
+    entry.type === "task"
+      ? { type: entry.type, text: entry.text, checked: entry.checked }
+      : { type: entry.type, text: entry.text, level: entry.level },
+  );

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

@@ -0,0 +1,113 @@
+import { Effect } from "effect";
+
+import { GitHubCommandError } from "#gh/errors";
+import {
+  bunMarkdownOutline,
+  findCheckboxLines,
+  validateCheckboxEdit,
+  type CheckboxOutlineParser,
+} from "#gh/pr/checkbox-markdown";
+import { repoSlug } from "#gh/read/keys";
+import { reads, resolveRepo } from "#gh/read/reads";
+import { writes } from "#gh/read/writes";
+import { validateOutboundText } from "#gh/text-input";
+
+type CheckboxState = "checked" | "unchecked";
+
+const readPRBody = Effect.fn("pr.checkbox.readPRBody")(function* (pr: number) {
+  const repo = yield* resolveRepo(null);
+  const body = yield* reads.prBody(repo, pr);
+  return { repo, body };
+});
+
+const checkboxMatchError = (pr: number, count: number) =>
+  new GitHubCommandError({
+    command: "gh-tool pr checkbox",
+    exitCode: 1,
+    stderr: `Found ${count} matching task items in PR #${pr}`,
+    message: `Expected one matching task item in PR #${pr}, found ${count}`,
+    hint: "Use --section to narrow the search or pass a longer --match.",
+  });
+
+export const togglePRCheckbox = Effect.fn("pr.togglePRCheckbox")(function* (
+  opts: {
+    pr: number;
+    match: string;
+    section: string | null;
+    state: CheckboxState;
+  },
+  parseOutline: CheckboxOutlineParser = bunMarkdownOutline,
+) {
+  yield* validateOutboundText(opts.match, "gh-tool pr checkbox");
+  if (opts.section !== null) {
+    yield* validateOutboundText(opts.section, "gh-tool pr checkbox");
+  }
+
+  if (opts.pr <= 0 || opts.match.length === 0 || opts.section === "") {
+    return yield* new GitHubCommandError({
+      command: "gh-tool pr checkbox",
+      exitCode: 1,
+      stderr: "--pr must be positive, --match must be non-empty, and --section must be non-empty",
+      message: "Invalid PR checkbox selection",
+    });
+  }
+
+  const first = yield* readPRBody(opts.pr);
+  const matches = yield* Effect.try({
+    try: () => findCheckboxLines(first.body, opts.match, opts.section, parseOutline),
+    catch: (cause) =>
+      new GitHubCommandError({
+        command: "gh-tool pr checkbox",
+        exitCode: 1,
+        stderr: String(cause),
+        message: "Cannot locate PR checkbox safely",
+        hint: "PR body structure is ambiguous; tick this item in the GitHub UI.",
+      }),
+  });
+  if (matches.length !== 1) return yield* checkboxMatchError(opts.pr, matches.length);
+
+  const selected = matches[0];
+  if (selected === undefined) return yield* checkboxMatchError(opts.pr, 0);
+
+  const alreadyRequested = opts.state === "checked" ? selected.checked : !selected.checked;
+  if (alreadyRequested) {
+    return {
+      pr: opts.pr,
+      state: "unchanged" as const,
+      before: selected.before,
+      after: selected.before,
+    };
+  }
+
+  const box = opts.state === "checked" ? "x" : " ";
+  yield* Effect.try({
+    try: () => validateCheckboxEdit(first.body, selected.offset, box, parseOutline),
+    catch: (cause) =>
+      new GitHubCommandError({
+        command: "gh-tool pr checkbox",
+        exitCode: 1,
+        stderr: String(cause),
+        message: "Cannot locate PR checkbox safely",
+        hint: "PR body structure is ambiguous; tick this item in the GitHub UI.",
+      }),
+  });
+  const after = `${selected.before.slice(0, selected.boxIndex)}${box}${selected.before.slice(selected.boxIndex + 1)}`;
+  yield* writes.prCheckbox(
+    {
+      repo: first.repo,
+      pr: opts.pr,
+      expectedBody: first.body,
+      boxOffset: selected.offset,
+      replacement: box,
+      selectionText: [opts.match, ...(opts.section === null ? [] : [opts.section])],
+    },
+    [`pr:${repoSlug(first.repo)}#${opts.pr}`, `pulls:${repoSlug(first.repo)}`],
+  );
+
+  return {
+    pr: opts.pr,
+    state: "updated" as const,
+    before: selected.before,
+    after,
+  };
+});

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

@@ -7,7 +7,7 @@ import type { CheckResult, PRStatusResult } from "#gh/types";
 
 import { formatOption, logFormatted, logText } from "#shared";
 import { GitHubService } from "#gh/read/transport";
-import { GitHubCommandError } from "#gh/errors";
+import { GitHubCommandError, GitHubTimeoutError } from "#gh/errors";
 
 const emptyBatchError = (batch: string) =>
   new GitHubCommandError({
@@ -33,6 +33,7 @@ import {
 } from "#gh/config";
 
 import { mergeStack, readStack, unstackStack } from "./stack";
+import { togglePRCheckbox } from "./checkbox";
 import {
   closePR,
   collectWithStableState,
@@ -721,6 +722,51 @@ export const prEditCommand = Command.make(
     ),
 ).pipe(Command.withDescription("Edit an existing PR's title, body, or other metadata"));
 
+export const prCheckboxCommand = Command.make(
+  "checkbox",
+  {
+    check: Flag.Boolean("check").pipe(
+      Flag.withDescription("Mark the matching task item as checked"),
+      Flag.withDefault(false),
+    ),
+    format: formatOption,
+    match: Flag.String("match").pipe(
+      Flag.withDescription("Plain text that identifies one task item"),
+    ),
+    pr: Flag.Int("pr").pipe(Flag.withDescription("PR number to update")),
+    repo: repoOption,
+    section: Flag.String("section").pipe(
+      Flag.withDescription("Limit the search to a Markdown heading"),
+      Flag.optional,
+    ),
+    uncheck: Flag.Boolean("uncheck").pipe(
+      Flag.withDescription("Mark the matching task item as unchecked"),
+      Flag.withDefault(false),
+    ),
+  },
+  ({ check, format, match, pr, repo, section, uncheck }) =>
+    withRepo(
+      repo,
+      Effect.gen(function* () {
+        if (check === uncheck) {
+          return yield* new GitHubCommandError({
+            command: "gh-tool pr checkbox",
+            exitCode: 1,
+            stderr: "Provide exactly one of --check or --uncheck",
+            message: "Provide exactly one of --check or --uncheck",
+          });
+        }
+        const result = yield* togglePRCheckbox({
+          pr,
+          match,
+          section: Option.getOrNull(section),
+          state: check ? "checked" : "unchecked",
+        });
+        yield* logFormatted(result, format);
+      }),
+    ),
+).pipe(Command.withDescription("Check or uncheck one task item in a PR body"));
+
 export const prCloseCommand = Command.make(
   "close",
   {
@@ -1013,6 +1059,25 @@ export const prRerunChecksCommand = Command.make(
           timeoutSeconds: timeout,
         });
         yield* logFormatted(result, format);
+        if (watch && (result.status === "watch_timeout" || result.status === "discovery_timeout")) {
+          return yield* new GitHubTimeoutError({
+            message: result.message,
+            timeoutMs: timeout * 1000,
+          });
+        }
+        if (
+          watch &&
+          result.runs !== undefined &&
+          result.runs.length > 0 &&
+          result.status !== "completed"
+        ) {
+          return yield* new GitHubCommandError({
+            command: "pr rerun-checks --watch",
+            exitCode: 1,
+            stderr: "",
+            message: result.message,
+          });
+        }
       }),
     ),
 ).pipe(

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

@@ -1,4 +1,4 @@
-import { Clock, Console, Effect, Option, Result } from "effect";
+import { Clock, Console, Effect, Option, Result, Semaphore } from "effect";
 
 import type {
   BranchPRDetail,
@@ -2027,7 +2027,7 @@ const readRerunState = (runId: string, withStatus: boolean) =>
   Effect.gen(function* () {
     const run = yield* reads.runView(yield* resolveRepo(null), Number(runId), "origin");
     const fields = withStatus
-      ? (["databaseId", "attempt", "status", "jobs"] as const)
+      ? (["databaseId", "attempt", "status", "conclusion", "jobs"] as const)
       : (["databaseId", "attempt", "jobs"] as const);
     return project(run, fields);
   });
@@ -2051,18 +2051,21 @@ const readJobDiagnosis = Effect.fn("pr.readJobDiagnosis")(function* (
 const discoverRerun = Effect.fn("pr.discoverRerun")(function* (
   runId: string,
   currentAttempt: number | null,
-  currentJobIds: readonly number[],
   deadline: number,
+  runViewReads: Semaphore.Semaphore,
 ) {
-  const read = readRerunState(runId, true).pipe(
-    Effect.catchTag("GitHubCommandError", () => Effect.succeed(null)),
-  );
+  const read = runViewReads
+    .withPermit(readRerunState(runId, true))
+    .pipe(Effect.catchTag("GitHubCommandError", () => Effect.succeed(null)));
   const outcome = yield* waits.until(
     read,
     (latest) =>
       latest !== null &&
-      ((latest.attempt ?? 0) > (currentAttempt ?? 0) ||
-        latest.jobs.some((job) => !currentJobIds.includes(job.databaseId))),
+      currentAttempt !== null &&
+      currentAttempt > 0 &&
+      latest.attempt !== undefined &&
+      latest.attempt !== null &&
+      latest.attempt === currentAttempt + 1,
     {
       intervalMs: 5000,
       timeoutMs: Math.max(0, deadline - Number(yield* Clock.currentTimeMillis)),
@@ -2107,12 +2110,19 @@ export const rerunChecks = Effect.fn("pr.rerunChecks")(function* (
       Effect.catchTag("GitHubCommandError", () => Effect.succeed(null)),
     );
     let evidence: RerunRetryEvidence = { state: "eligible", diagnosis: diagnoseLogEntries([]) };
+    if (
+      options.watch === true &&
+      (run?.attempt === undefined || run.attempt === null || run.attempt <= 0)
+    ) {
+      evidence = { state: "unavailable", reason: "current attempt unavailable for watched rerun" };
+    }
     if (failedOnly) {
       const jobIds = run === null ? null : resolveJobIdsForFailedChecks(runChecks, run.jobs);
       if (
         run === null ||
         run.attempt === null ||
         run.attempt === undefined ||
+        run.attempt <= 0 ||
         jobIds === null ||
         jobIds.length === 0
       ) {
@@ -2202,26 +2212,19 @@ export const rerunChecks = Effect.fn("pr.rerunChecks")(function* (
   }
 
   if (watch) {
-    const discoveries = yield* Effect.forEach(
-      candidates,
-      (candidate, index) =>
-        results[index]?.success
-          ? discoverRerun(
-              candidate.runId,
-              candidate.run?.attempt ?? null,
-              candidate.run?.jobs?.map((job) => job.databaseId) ?? [],
-              deadline,
-            )
-          : Effect.succeed(null),
-      { concurrency: 2 },
-    );
+    const runViewReads = yield* Semaphore.make(2);
     yield* Effect.forEach(
       candidates,
       (candidate, index) =>
         Effect.gen(function* () {
           const result = results[index];
           if (result === undefined || !result.success) return;
-          const next = discoveries[index] ?? null;
+          const next = yield* discoverRerun(
+            candidate.runId,
+            candidate.run?.attempt ?? null,
+            deadline,
+            runViewReads,
+          );
           result.newAttempt = next?.attempt ?? null;
           result.newJobIds = next?.jobs.map((job) => job.databaseId) ?? null;
           if (next === null) {
@@ -2232,8 +2235,17 @@ export const rerunChecks = Effect.fn("pr.rerunChecks")(function* (
           let latest = next;
           const outcome = yield* waits.until(
             Effect.suspend(() =>
-              readRerunState(candidate.runId, true).pipe(
+              runViewReads.withPermit(readRerunState(candidate.runId, true)).pipe(
                 Effect.catchTag("GitHubCommandError", () => Effect.succeed(latest)),
+                Effect.map((refreshed) =>
+                  refreshed.attempt !== undefined &&
+                  refreshed.attempt !== null &&
+                  next.attempt !== undefined &&
+                  next.attempt !== null &&
+                  refreshed.attempt < next.attempt
+                    ? latest
+                    : refreshed,
+                ),
                 Effect.tap((refreshed) =>
                   Effect.sync(() => {
                     latest = refreshed;
@@ -2241,7 +2253,11 @@ export const rerunChecks = Effect.fn("pr.rerunChecks")(function* (
                 ),
               ),
             ),
-            (value) => value.status === "completed",
+            (value) =>
+              next.attempt !== undefined &&
+              next.attempt !== null &&
+              value.attempt === next.attempt &&
+              value.status === "completed",
             {
               initial: { value: latest },
               intervalMs: 5000,
@@ -2250,17 +2266,34 @@ export const rerunChecks = Effect.fn("pr.rerunChecks")(function* (
           );
           latest = outcome.kind === "done" ? outcome.value : outcome.last;
           result.latestAttempt = latest;
-          result.status = latest.status === "completed" ? "completed" : "watch_timeout";
+          result.status = outcome.kind === "done" ? "completed" : "watch_timeout";
         }),
-      { concurrency: 2 },
+      { concurrency: "unbounded" },
     );
   }
+  const status = results.some((result) => !result.success)
+    ? "failed"
+    : !watch
+      ? "rerun_started"
+      : results.some((result) => result.status === "discovery_timeout")
+        ? "discovery_timeout"
+        : results.some((result) => result.status === "watch_timeout")
+          ? "watch_timeout"
+          : results.every((result) => result.latestAttempt?.conclusion === "success")
+            ? "completed"
+            : "failed";
   const report: RerunChecksReport = {
-    status: results.some((result) => !result.success) ? "failed" : "rerun_started",
+    status,
     rerun: results.filter((result) => result.success).length,
     failed: results.filter((result) => !result.success).length,
     runs: results,
-    message: `Rerun ${results.filter((result) => result.success).length}/${results.length} GitHub Actions runs`,
+    message: watch
+      ? status === "watch_timeout" || status === "discovery_timeout"
+        ? "Rerun watch timed out; this is not a CI verdict"
+        : status === "completed"
+          ? "Watched reruns completed successfully"
+          : "Watched reruns did not complete successfully"
+      : `Rerun ${results.filter((result) => result.success).length}/${results.length} GitHub Actions runs`,
   };
   return report;
 });

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

@@ -9,6 +9,7 @@ export {
   prDiscussionSummaryCommand,
   prDraftCommand,
   prEditCommand,
+  prCheckboxCommand,
   prFeedbackCommand,
   prIssueCommentsCommand,
   prIssueCommentsLatestCommand,