feat(server): agents read failing CI logs and re-run checks through MCP tools

apps/server/src/mcp/McpHttpServer.test.ts

@@ -1618,13 +1618,17 @@ it.effect(
             "pull_request_read",
             "pull_request_review",
             "pull_request_merge",
+            "ci_logs",
+            "ci_rerun",
           ]),
         );
         const noForgeTools = yield* listedTools("noForgeToken");
         expect(noForgeTools).toEqual(
           expect.arrayContaining(["link_pull_request", "watch_pull_request"]),
         );
-        expect(noForgeTools.filter((name) => name.startsWith("pull_request_"))).toEqual([]);
+        expect(
+          noForgeTools.filter((name) => name.startsWith("pull_request_") || name.startsWith("ci_")),
+        ).toEqual([]);
       }),
     ).pipe(Effect.provide(NodeHttpServer.layerTest)),
 );

apps/server/src/mcp/toolkits/pullRequests/handlers.test.ts

@@ -936,6 +936,46 @@ describe("source control tools", () => {
     }),
   );
 
+  it.effect("re-running checks reopens a watch that saw its checks finish", () =>
+    Effect.gen(function* () {
+      const watch = {
+        startedAt: "2026-08-20T00:00:00.000Z",
+        headSha: "abc123",
+        failedChecks: ["test"],
+        passed: false,
+        passedChecks: [],
+        remarksThrough: "2026-08-20T00:00:00.000Z",
+        remarkIds: [],
+        conflicting: false,
+        wakes: 0,
+      };
+      const rerun = (checksPending: boolean | undefined, reran: boolean) =>
+        Effect.gen(function* () {
+          const harness = yield* makeHarness({
+            thread: {
+              ...branchThread,
+              pullRequests: [
+                makeLink(42, {
+                  watch: checksPending === undefined ? watch : { ...watch, checksPending },
+                }),
+              ],
+            },
+            pullRequests: {
+              rerunChecks: () => Effect.succeed([{ name: "test", rerun: reran, detail: null }]),
+            },
+          });
+          yield* harness.call("ci_rerun", {});
+          return yield* Ref.get(harness.commands);
+        });
+      expect(yield* rerun(false, true)).toMatchObject([
+        { type: "thread.pull-request-watch.checks-reopen", threadId: THREAD_ID },
+      ]);
+      // Nothing re-ran, or the watch has no answer to clear.
+      expect(yield* rerun(false, false)).toEqual([]);
+      expect(yield* rerun(undefined, true)).toEqual([]);
+    }),
+  );
+
   it.effect("opens a PR from the thread's worktree and links it even if dismissed", () =>
     Effect.gen(function* () {
       const opened: Array<{ readonly cwd: string; readonly draft: boolean | undefined }> = [];

apps/server/src/mcp/toolkits/pullRequests/handlers.ts

@@ -1105,6 +1105,46 @@ const make = Effect.gen(function* () {
         return { ...identityOf(target), state: after.state };
       }),
     ),
+    ci_logs: McpToolAccess.reads((input) =>
+      Effect.gen(function* () {
+        const { target, ref } = yield* locate(input);
+        const checks = yield* pullRequests
+          .checkLogs({
+            ...ref,
+            tailLines: input.tailLines ?? 200,
+            ...(input.check === undefined ? {} : { check: input.check }),
+          })
+          .pipe(Effect.mapError(forgeFailure));
+        return { ...identityOf(target), checks };
+      }),
+    ),
+    ci_rerun: McpToolAccess.writesWithCapability((input) =>
+      Effect.gen(function* () {
+        const { thread, target, ref } = yield* locate(input);
+        const checks = yield* pullRequests
+          .rerunChecks({ ...ref, ...(input.check === undefined ? {} : { check: input.check }) })
+          .pipe(Effect.mapError(forgeFailure));
+        // Like a push, a rerun makes a watch's finished checks stale, so the thread keeps working
+        // until a read sees them run. The rerun already happened, so a failed reopen only logs.
+        if (
+          checks.some((check) => check.rerun) &&
+          threadPullRequestsOf(thread).some((link) => link.watch?.checksPending !== undefined)
+        ) {
+          yield* engine
+            .dispatch({
+              type: "thread.pull-request-watch.checks-reopen",
+              commandId: yield* commandId("mcp-ci-rerun-checks", thread.id),
+              threadId: thread.id,
+            })
+            .pipe(
+              Effect.catchCause((cause) =>
+                Effect.logWarning("reopening a watch's checks after a rerun failed", cause),
+              ),
+            );
+        }
+        return { ...identityOf(target), checks };
+      }),
+    ),
   } satisfies McpToolAccess.Handlers<typeof PullRequestsToolkit.tools>;
 });
 

apps/server/src/mcp/toolkits/pullRequests/tools.ts

@@ -764,6 +764,72 @@ const MergePullRequestTool = Tool.make("pull_request_merge", {
   .annotate(Tool.OpenWorld, true)
   .annotate(McpSchema.EnabledWhen, McpInvocationContext.hiddenWithoutForge);
 
+export const CheckLogsResult = Schema.Struct({
+  ...PullRequestIdentity,
+  checks: Schema.Array(
+    Schema.Struct({
+      name: Schema.String,
+      url: Schema.NullOr(Schema.String),
+      log: Schema.NullOr(Schema.String),
+      truncated: Schema.Boolean,
+      detail: Schema.NullOr(Schema.String),
+    }),
+  ),
+});
+export type CheckLogsResult = typeof CheckLogsResult.Type;
+
+export const RerunChecksResult = Schema.Struct({
+  ...PullRequestIdentity,
+  checks: Schema.Array(
+    Schema.Struct({
+      name: Schema.String,
+      rerun: Schema.Boolean,
+      detail: Schema.NullOr(Schema.String),
+    }),
+  ),
+});
+export type RerunChecksResult = typeof RerunChecksResult.Type;
+
+const CheckLogsTool = Tool.make("ci_logs", {
+  description:
+    "Read the tail of a PR's failing check logs, or one named check's. Use instead of gh run view.",
+  parameters: Schema.Struct({
+    ...ThreadPullRequestInput.fields,
+    check: Schema.optional(TrimmedNonEmptyString),
+    tailLines: Schema.optional(
+      Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 2000 })).annotate({
+        description: "Default: 200.",
+      }),
+    ),
+  }),
+  success: CheckLogsResult,
+  failure: PullRequestToolError,
+  dependencies: forgeDependencies,
+})
+  .annotate(Tool.Title, "Read CI logs")
+  .annotate(Tool.Readonly, true)
+  .annotate(Tool.Destructive, false)
+  .annotate(Tool.Idempotent, true)
+  .annotate(Tool.OpenWorld, true)
+  .annotate(McpSchema.EnabledWhen, McpInvocationContext.hiddenWithoutForge);
+
+const RerunChecksTool = Tool.make("ci_rerun", {
+  description: "Re-run a PR's failing checks, or one named check.",
+  parameters: Schema.Struct({
+    ...ThreadPullRequestInput.fields,
+    check: Schema.optional(TrimmedNonEmptyString),
+  }),
+  success: RerunChecksResult,
+  failure: PullRequestToolError,
+  dependencies: forgeDependencies,
+})
+  .annotate(Tool.Title, "Re-run CI")
+  .annotate(Tool.Readonly, false)
+  .annotate(Tool.Destructive, false)
+  .annotate(Tool.Idempotent, false)
+  .annotate(Tool.OpenWorld, true)
+  .annotate(McpSchema.EnabledWhen, McpInvocationContext.hiddenWithoutForge);
+
 export const PullRequestsToolkit = Toolkit.make(
   LinkPullRequestTool,
   LinkPullRequestsTool,
@@ -781,4 +847,6 @@ export const PullRequestsToolkit = Toolkit.make(
   RespondToPullRequestTool,
   ReviewPullRequestTool,
   MergePullRequestTool,
+  CheckLogsTool,
+  RerunChecksTool,
 );