@blogic-cz/agent-tools 1.2.1 → 1.3.0

package/src/gh-tool/api.ts

@@ -0,0 +1,166 @@
+import { Effect } from "effect";
+
+import { retryTransient } from "#shared/retry-transient";
+
+import { GitHubAuthError, GitHubCommandError, GitHubNotFoundError } from "./errors";
+import type { GitHubApiError } from "./errors";
+
+// Direct HTTP, not `gh api`: the CLI collapses every failure into a non-zero exit and
+// loses the status code, but merge-async answers 202 (accepted), 200 (already merged or
+// queued) and 409 (a request already exists, UUID returned) as three different outcomes.
+const GITHUB_API_ROOT = "https://api.github.com";
+const GITHUB_ACCEPT = "application/vnd.github+json";
+const GITHUB_API_VERSION = "2022-11-28";
+
+export type GitHubApiResponse<T> = {
+  status: number;
+  body: T;
+};
+
+const authFailure = (message: string) =>
+  new GitHubAuthError({
+    message,
+    hint: "Set GITHUB_TOKEN or GH_TOKEN, or authenticate the GitHub CLI with 'gh auth login'.",
+    nextCommand: "gh auth login",
+  });
+
+// Environment first, GH_TOKEN before GITHUB_TOKEN to match the gh CLI: the active gh
+// account is directory-scoped global state and the shell exports the matching token.
+// `gh auth token` only covers shells that export none.
+export const resolveGitHubToken = Effect.fn("gh.resolveGitHubToken")(function* () {
+  const fromEnv = [process.env["GH_TOKEN"], process.env["GITHUB_TOKEN"]].find(
+    (candidate) => candidate !== undefined && candidate.length > 0,
+  );
+  if (fromEnv !== undefined && fromEnv.length > 0) {
+    return fromEnv;
+  }
+
+  // Bun.spawn rather than the ChildProcessSpawner service on purpose: routing it through
+  // the service would put that requirement in the error channel of every command that
+  // reads the API, and token resolution is not what those commands are testing.
+  const token = yield* Effect.tryPromise({
+    try: async () => {
+      const proc = Bun.spawn(["gh", "auth", "token", "--hostname", "github.com"], {
+        stdout: "pipe",
+        stderr: "ignore",
+      });
+      const stdout = await new Response(proc.stdout).text();
+      const exitCode = await proc.exited;
+      return exitCode === 0 ? stdout.trim() : "";
+    },
+    catch: () => authFailure("No GitHub token available."),
+  }).pipe(Effect.orElseSucceed(() => ""));
+  if (token.length === 0) {
+    return yield* authFailure("No GitHub token available.");
+  }
+
+  return token;
+});
+
+export type GitHubApiRequest = {
+  path: string;
+  method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+  body?: unknown;
+  alsoAcceptStatus?: number[];
+};
+
+const MAX_API_RETRIES = 2;
+
+const githubApiAttempt = Effect.fn("gh.githubApiAttempt")(function* <T>(opts: GitHubApiRequest) {
+  const token = yield* resolveGitHubToken();
+  const method = opts.method ?? "GET";
+  const url = `${GITHUB_API_ROOT}/${opts.path.replace(/^\//, "")}`;
+
+  const response = yield* Effect.tryPromise({
+    try: () =>
+      fetch(url, {
+        method,
+        headers: {
+          Accept: GITHUB_ACCEPT,
+          Authorization: `Bearer ${token}`,
+          "X-GitHub-Api-Version": GITHUB_API_VERSION,
+          ...(opts.body === undefined ? {} : { "Content-Type": "application/json" }),
+        },
+        ...(opts.body === undefined ? {} : { body: JSON.stringify(opts.body) }),
+      }),
+    catch: (cause) =>
+      new GitHubCommandError({
+        message: `GitHub API request failed: ${String(cause)}`,
+        command: `${method} ${opts.path}`,
+        exitCode: -1,
+        stderr: String(cause),
+        retryable: true,
+        hint: "Check network connectivity and VPN state, then retry.",
+      }),
+  });
+
+  const text = yield* Effect.tryPromise({
+    try: () => response.text(),
+    catch: (cause) =>
+      new GitHubCommandError({
+        message: `GitHub API response could not be read: ${String(cause)}`,
+        command: `${method} ${opts.path}`,
+        exitCode: -1,
+        stderr: String(cause),
+        hint: "The connection dropped mid-response. Re-read the resource before retrying a mutation.",
+      }),
+  });
+  const parsed: unknown = text.length === 0 ? null : safeJsonParse(text);
+
+  const accepted = new Set([200, ...(opts.alsoAcceptStatus ?? [])]);
+  if (accepted.has(response.status)) {
+    return { status: response.status, body: parsed as T };
+  }
+
+  if (response.status === 401) {
+    return yield* authFailure("GitHub credentials rejected (HTTP 401).");
+  }
+
+  if (response.status === 404) {
+    return yield* new GitHubNotFoundError({
+      message: `GitHub API returned 404 for ${opts.path}`,
+      identifier: opts.path,
+      resource: "github-api",
+      hint: "Verify the resource exists, that you have access, and that the feature is enabled for this repository.",
+    });
+  }
+
+  return yield* new GitHubCommandError({
+    message: apiErrorMessage(parsed, response.status),
+    command: `${method} ${opts.path}`,
+    exitCode: response.status,
+    stderr: text,
+    ...(response.status >= 500 ? { retryable: true } : {}),
+  });
+});
+
+// Mirrors GitHubService.runGh: replay a transient failure, and only for an idempotent read.
+export const githubApi = <T>(
+  opts: GitHubApiRequest,
+): Effect.Effect<GitHubApiResponse<T>, GitHubApiError> =>
+  retryTransient({
+    attempt: () => githubApiAttempt<T>(opts),
+    isTransient: (error) =>
+      error._tag === "GitHubCommandError" &&
+      error.retryable === true &&
+      (opts.method ?? "GET") === "GET",
+    maxRetries: MAX_API_RETRIES,
+  });
+
+const safeJsonParse = (text: string): unknown => {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+};
+
+const apiErrorMessage = (body: unknown, status: number): string => {
+  if (typeof body === "object" && body !== null && "message" in body) {
+    const message = (body as { message?: unknown }).message;
+    if (typeof message === "string") {
+      return `GitHub API error (HTTP ${status}): ${message}`;
+    }
+  }
+  return `GitHub API error (HTTP ${status})`;
+};

package/src/gh-tool/config.ts

@@ -5,3 +5,6 @@ export const GRAPHQL_PAGE_SIZE = 100 as const;
 export const GH_BINARY = "gh" as const;
 
 export const MERGE_STRATEGIES = ["squash", "merge", "rebase"] as const;
+
+export const REVIEW_EVENTS = ["comment", "approve", "request-changes"] as const;
+export const DEFAULT_REVIEW_EVENT = "comment" as const;

package/src/gh-tool/errors.ts

@@ -63,3 +63,5 @@ export type GitHubServiceError =
   | GitHubAuthError
   | GitHubMergeError
   | GitHubTimeoutError;
+
+export type GitHubApiError = GitHubCommandError | GitHubAuthError | GitHubNotFoundError;

package/src/gh-tool/index.ts

@@ -27,6 +27,7 @@ import {
   prEditCommand,
   prMergeCommand,
   prReadyCommand,
+  prStackCommand,
   prRequestReviewCommand,
   prThreadsCommand,
   prCommentsCommand,
@@ -37,6 +38,7 @@ import {
   prFeedbackCommand,
   prReplyCommand,
   prResolveCommand,
+  prReviewCommand,
   prReviewsCommand,
   prLastHumanReviewerCommand,
   prSubmitReviewCommand,
@@ -92,6 +94,7 @@ const prCommand = Command.make("pr", {}).pipe(
     prEditCommand,
     prMergeCommand,
     prReadyCommand,
+    prStackCommand,
     prRequestReviewCommand,
     prWaitMergeableCommand,
     prThreadsCommand,
@@ -105,6 +108,7 @@ const prCommand = Command.make("pr", {}).pipe(
     prDiscussionSummaryCommand,
     prReplyCommand,
     prResolveCommand,
+    prReviewCommand,
     prSubmitReviewCommand,
     prChecksCommand,
     prChecksFailedCommand,
@@ -199,7 +203,8 @@ WORKFLOW FOR AI AGENTS:
   1. Use 'pr view' to inspect current PR
   2. Use 'pr discussion-summary' for overview (counts + latest discussion comment)
   3. Use 'pr threads' and 'pr issue-comments-latest --author <username> --body-contains "Review"' for review context
-  4. Use 'pr submit-review', 'pr reply', 'pr comment' and 'pr resolve' to handle feedback
+  4. Use 'pr reply', 'pr comment' and 'pr resolve' to handle feedback
+  4b. Use 'pr review --event request-changes|approve|comment --confirm' to post a verdict, or 'pr submit-review' for a pending one
   5. Use 'pr checks' to monitor CI status; 'pr trigger-checks --workflow <file.yml>' when zero checks were reported
   6. Use 'pr merge' to merge (dry-run by default)
   7. Use 'issue list' to list open/closed issues

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

@@ -24,9 +24,12 @@ import {
   CI_CHECK_WATCH_TIMEOUT_MS,
   DEFAULT_DELETE_BRANCH,
   DEFAULT_MERGE_STRATEGY,
+  DEFAULT_REVIEW_EVENT,
   MERGE_STRATEGIES,
+  REVIEW_EVENTS,
 } from "#gh/config";
 
+import { mergeStack, readStack } from "./stack";
 import {
   closePR,
   collectWithStableState,
@@ -47,6 +50,7 @@ import {
   waitForMergeable,
 } from "./core";
 import {
+  createReview,
   fetchComments,
   fetchDiscussionSummary,
   fetchFeedback,
@@ -1336,6 +1340,68 @@ export const prResolveCommand = Command.make(
     ),
 ).pipe(Command.withDescription("Resolve a review thread via GraphQL"));
 
+const reviewEventOption = Flag.choice("event", REVIEW_EVENTS).pipe(
+  Flag.withDescription("Review verdict: comment, approve, or request-changes"),
+  Flag.withDefault(DEFAULT_REVIEW_EVENT),
+);
+
+const reviewConfirmOption = Flag.boolean("confirm").pipe(
+  Flag.withDescription("Required for --event approve and --event request-changes"),
+  Flag.withDefault(false),
+);
+
+export const prReviewCommand = Command.make(
+  "review",
+  {
+    body: Flag.string("body").pipe(Flag.withDescription("Review body text"), Flag.optional),
+    bodyFile: Flag.string("body-file").pipe(
+      Flag.withDescription("Read review body from a file path or '-' for stdin"),
+      Flag.optional,
+    ),
+    bodyStdin: Flag.boolean("body-stdin").pipe(
+      Flag.withDescription("Read review body from stdin"),
+      Flag.withDefault(false),
+    ),
+    confirm: reviewConfirmOption,
+    event: reviewEventOption,
+    format: formatOption,
+    pr: Flag.integer("pr").pipe(
+      Flag.withDescription("PR number (default: current branch PR)"),
+      Flag.optional,
+    ),
+    repo: repoOption,
+  },
+  ({ body, bodyFile, bodyStdin, confirm, event, format, pr, repo }) =>
+    withRepo(
+      repo,
+      Effect.gen(function* () {
+        const resolvedBody = yield* resolveDefaultTextInput({
+          command: "gh-tool pr review",
+          value: Option.getOrNull(body),
+          fileValue: Option.getOrNull(bodyFile),
+          stdin: bodyStdin,
+          valueFlag: "--body",
+          fileFlag: "--body-file",
+          stdinFlag: "--body-stdin",
+          label: "body",
+          defaultValue: "",
+        });
+
+        const result = yield* createReview({
+          pr: Option.getOrNull(pr),
+          event,
+          body: resolvedBody,
+          confirm,
+        });
+        yield* logFormatted(result, format);
+      }),
+    ),
+).pipe(
+  Command.withDescription(
+    "Create and submit a review (--event comment, approve, or request-changes; verdicts need --confirm)",
+  ),
+);
+
 export const prSubmitReviewCommand = Command.make(
   "submit-review",
   {
@@ -1347,6 +1413,8 @@ export const prSubmitReviewCommand = Command.make(
       Flag.withDescription("Read review body from a file path or '-' for stdin"),
       Flag.optional,
     ),
+    confirm: reviewConfirmOption,
+    event: reviewEventOption,
     format: formatOption,
     pr: Flag.integer("pr").pipe(
       Flag.withDescription("PR number (default: current branch PR)"),
@@ -1360,7 +1428,7 @@ export const prSubmitReviewCommand = Command.make(
       Flag.optional,
     ),
   },
-  ({ body, bodyFile, format, pr, repo, reviewId }) =>
+  ({ body, bodyFile, confirm, event, format, pr, repo, reviewId }) =>
     withRepo(
       repo,
       Effect.gen(function* () {
@@ -1374,13 +1442,19 @@ export const prSubmitReviewCommand = Command.make(
           fileFlag: "--body-file",
           label: "body",
         });
-        const result = yield* submitPendingReview(prNumber, reviewIdValue, bodyValue);
+        const result = yield* submitPendingReview(
+          prNumber,
+          reviewIdValue,
+          bodyValue,
+          event,
+          confirm,
+        );
         yield* logFormatted(result, format);
       }),
     ),
 ).pipe(
   Command.withDescription(
-    "Submit a pending review as COMMENT (auto-detects your pending review if --review-id is omitted)",
+    "Submit a pending review (--event comment by default; verdicts need --confirm; auto-detects your pending review if --review-id is omitted)",
   ),
 );
 
@@ -1536,3 +1610,54 @@ export const prReplyAndResolveCommand = Command.make(
     "Composite: reply to a review comment and resolve its thread (PR/thread inferred from comment)",
   ),
 );
+
+const prStackViewCommand = Command.make(
+  "view",
+  {
+    format: formatOption,
+    pr: Flag.integer("pr").pipe(Flag.withDescription("PR number to read the stack of")),
+    repo: repoOption,
+  },
+  ({ format, pr, repo }) =>
+    withRepo(
+      repo,
+      Effect.gen(function* () {
+        const result = yield* readStack({ pr });
+        yield* logFormatted(result, format);
+      }),
+    ),
+).pipe(Command.withDescription("Show every PR in the stack containing this PR, bottom-up"));
+
+const prStackMergeCommand = Command.make(
+  "merge",
+  {
+    confirm: Flag.boolean("confirm").pipe(
+      Flag.withDescription("Actually merge (without this flag, only shows the ordered plan)"),
+      Flag.withDefault(false),
+    ),
+    format: formatOption,
+    pr: Flag.integer("pr").pipe(Flag.withDescription("Any PR in the stack to merge")),
+    repo: repoOption,
+    strategy: Flag.choice("strategy", MERGE_STRATEGIES).pipe(
+      Flag.withDescription("Merge strategy: squash, merge, or rebase"),
+      Flag.withDefault(DEFAULT_MERGE_STRATEGY),
+    ),
+  },
+  ({ confirm, format, pr, repo, strategy }) =>
+    withRepo(
+      repo,
+      Effect.gen(function* () {
+        const result = yield* mergeStack({ confirm, pr, strategy });
+        yield* logFormatted(result, format);
+      }),
+    ),
+).pipe(
+  Command.withDescription(
+    "Merge every open PR in the stack in one request (dry-run by default, use --confirm)",
+  ),
+);
+
+export const prStackCommand = Command.make("stack", {}).pipe(
+  Command.withSubcommands([prStackViewCommand, prStackMergeCommand]),
+  Command.withDescription("Stacked pull request operations"),
+);

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

@@ -22,7 +22,9 @@ import { GitHubService } from "#gh/service";
 import { logText } from "#shared";
 
 import type { ButStatusJson, PRViewJsonResult } from "./helpers";
+import { pollUntilResolved } from "#shared/poll-until-resolved";
 import { runLocalCommand } from "./helpers";
+import { readStack } from "./stack-read";
 import {
   diagnoseLogEntries,
   discoverDispatchedRun,
@@ -200,7 +202,7 @@ const fetchWorkflowRunFailureContext = Effect.fn("pr.fetchWorkflowRunFailureCont
 // is an ordinary state, so map it to [] and keep the zero-check paths downstream reachable.
 export const NO_CHECKS_REPORTED_RE = /no checks reported/i;
 
-const fetchCheckResults = Effect.fn("pr.fetchCheckResults")(function* (pr: number | null) {
+export const fetchCheckResults = Effect.fn("pr.fetchCheckResults")(function* (pr: number | null) {
   const gh = yield* GitHubService;
 
   const args = ["pr", "checks"];
@@ -763,26 +765,13 @@ const mergeViaAsyncApi = Effect.fn("pr.mergeViaAsyncApi")(function* (opts: {
   ]);
 
   const uuid = latest.details?.uuid;
-  if (latest.status === "pending" && uuid !== undefined) {
-    const start = yield* Clock.currentTimeMillis;
-    const deadlineMs = Number(start) + MAX_ASYNC_MERGE_WAIT_SECONDS * 1000;
-    let timedOut = false;
-
-    // Effect.whileLoop (not recursion) so TestClock.adjust can advance Effect.sleep without real waits.
-    yield* Effect.whileLoop({
-      while: () => latest.status === "pending" && !timedOut,
-      body: () =>
-        Effect.gen(function* () {
-          const now = yield* Clock.currentTimeMillis;
-          if (Number(now) >= deadlineMs) {
-            timedOut = true;
-            return;
-          }
-          const remaining = deadlineMs - Number(now);
-          yield* Effect.sleep(Duration.millis(Math.min(ASYNC_MERGE_POLL_INTERVAL_MS, remaining)));
-          latest = yield* gh.runGhJson<AsyncMergeResult>(["api", `${asyncPath}/${uuid}`]);
-        }),
-      step: () => undefined,
+  if (uuid !== undefined) {
+    latest = yield* pollUntilResolved({
+      initial: latest,
+      isPending: (value) => value.status === "pending",
+      fetchLatest: () => gh.runGhJson<AsyncMergeResult>(["api", `${asyncPath}/${uuid}`]),
+      intervalMs: ASYNC_MERGE_POLL_INTERVAL_MS,
+      budgetSeconds: MAX_ASYNC_MERGE_WAIT_SECONDS,
     });
   }
 
@@ -832,6 +821,57 @@ export const mergePR = Effect.fn("pr.mergePR")(function* (opts: {
 
   const repo = opts.deleteBranch ? yield* gh.getRepoInfo() : null;
 
+  // merge-async lands the requested PR AND every unmerged PR below it in its stack, and
+  // `gh pr merge` falls back to that endpoint for a stacked PR. Merging one member can
+  // therefore land members this command never named. Refuse instead of merging silently.
+  // Fail closed: readStack already reports a repository without a stacks surface as
+  // unstacked, so a failure here leaves membership genuinely unknown, and proceeding
+  // would land whatever sits below this PR without naming it.
+  const stackView = yield* readStack({ pr: opts.pr }).pipe(
+    Effect.catch((error) =>
+      Effect.fail(
+        new GitHubMergeError({
+          message: `Could not determine whether PR #${opts.pr} belongs to a stack: ${error.message}`,
+          reason: "unknown",
+          hint: "Merging a stack member lands every open PR below it, so the merge is refused while membership is unknown. Retry, or read the stack with 'pr stack view'.",
+          nextCommand: `agent-tools-gh pr stack view --pr ${opts.pr}`,
+        }),
+      ),
+    ),
+  );
+  const ownPosition = stackView.members.find((entry) => entry.number === opts.pr)?.position;
+
+  // The stack was fetched by querying this PR, so it must be among its own members. If it
+  // is not, the PR left the stack between the list call and the detail call and membership
+  // is unknown again — the same reason the lookup failure above refuses.
+  if (stackView.isStacked && ownPosition === undefined) {
+    return yield* new GitHubMergeError({
+      message: `PR #${opts.pr} is missing from stack #${stackView.stackNumber}, which was read for that PR`,
+      reason: "unknown",
+      hint: "The stack changed while it was being read. Re-read it with 'pr stack view' before merging.",
+      nextCommand: `agent-tools-gh pr stack view --pr ${opts.pr}`,
+    });
+  }
+
+  const openBelow =
+    !stackView.isStacked || ownPosition === undefined
+      ? []
+      : stackView.members.filter(
+          (member) => member.state === "open" && member.position < ownPosition,
+        );
+
+  if (openBelow.length > 0) {
+    return yield* new GitHubMergeError({
+      message:
+        `PR #${opts.pr} sits above ${openBelow.length} open PR(s) in stack #${stackView.stackNumber}: ` +
+        openBelow.map((member) => `#${member.number}`).join(", ") +
+        ". Merging it would land them too.",
+      reason: "unknown",
+      hint: "Use 'pr stack merge' to merge a stack: it checks every member first and reports the whole plan.",
+      nextCommand: `agent-tools-gh pr stack merge --pr ${opts.pr}`,
+    });
+  }
+
   // A long-lived branch (default/env branch) as PR head means a promotion PR
   // (e.g. main -> staging). PRs based on it are unrelated work, not a stack —
   // retargeting them would mass-rewrite their base — and the branch itself

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

@@ -14,11 +14,13 @@ export {
   prListCommand,
   prMergeCommand,
   prReadyCommand,
+  prStackCommand,
   prRequestReviewCommand,
   prReplyCommand,
   prRerunChecksCommand,
   prReplyAndResolveCommand,
   prResolveCommand,
+  prReviewCommand,
   prReviewsCommand,
   prStatusCommand,
   prSubmitReviewCommand,

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

@@ -11,6 +11,8 @@ import type {
   FeedbackOrigin,
 } from "#gh/types";
 
+import type { REVIEW_EVENTS } from "#gh/config";
+
 import { GitHubCommandError } from "#gh/errors";
 import { GitHubService } from "#gh/service";
 
@@ -967,12 +969,110 @@ export const resolveThread = Effect.fn("pr.resolveThread")(function* (threadId:
   };
 });
 
+export type ReviewEvent = (typeof REVIEW_EVENTS)[number];
+
+const REVIEW_EVENT_API = {
+  approve: "APPROVE",
+  comment: "COMMENT",
+  "request-changes": "REQUEST_CHANGES",
+} as const satisfies Record<ReviewEvent, string>;
+
+// APPROVE and REQUEST_CHANGES change whether the PR can merge, so they need the same explicit
+// opt-in as `pr merge`. COMMENT carries no verdict and stays free.
+const requireVerdictConfirm = Effect.fn("pr.requireVerdictConfirm")(function* (opts: {
+  command: string;
+  event: ReviewEvent;
+  confirm: boolean;
+}) {
+  if (opts.event === "comment" || opts.confirm) {
+    return;
+  }
+
+  const detail = `--event ${opts.event} posts a verdict review; pass --confirm to submit it`;
+
+  return yield* Effect.fail(
+    new GitHubCommandError({
+      command: opts.command,
+      exitCode: 1,
+      stderr: detail,
+      message: detail,
+      hint: "APPROVE and REQUEST_CHANGES change the merge state of the PR. Re-run with --confirm once the verdict is intended.",
+    }),
+  );
+});
+
+/**
+ * Create and submit a review in one call — the path for a verdict an agent reached from a diff
+ * it just read, with no pending review to submit.
+ */
+export const createReview = Effect.fn("pr.createReview")(function* (opts: {
+  pr: number | null;
+  event: ReviewEvent;
+  body: string;
+  confirm: boolean;
+}) {
+  const service = yield* GitHubService;
+  const command = "gh-tool pr review";
+
+  yield* requireVerdictConfirm({ command, event: opts.event, confirm: opts.confirm });
+
+  // GitHub rejects a bodyless COMMENT or REQUEST_CHANGES review; only APPROVE may be silent.
+  if (opts.event !== "approve" && opts.body.trim() === "") {
+    const detail = `--event ${opts.event} requires a non-empty body`;
+
+    return yield* Effect.fail(
+      new GitHubCommandError({
+        command,
+        exitCode: 1,
+        stderr: detail,
+        message: detail,
+        hint: "Pass --body, --body-file, or --body-stdin with what has to change.",
+      }),
+    );
+  }
+
+  const repoInfo = yield* service.getRepoInfo();
+  const resolvedPr = opts.pr ?? (yield* viewPR(null)).number;
+
+  const args = [
+    "api",
+    "--method",
+    "POST",
+    `repos/${repoInfo.owner}/${repoInfo.name}/pulls/${resolvedPr}/reviews`,
+    "-f",
+    `event=${REVIEW_EVENT_API[opts.event]}`,
+  ];
+
+  if (opts.body !== "") {
+    args.push("-f", `body=${opts.body}`);
+  }
+
+  const result = yield* service.runGhJson<{
+    id: number;
+    state: string;
+    html_url: string;
+  }>(args);
+
+  return {
+    submitted: true as const,
+    pr: resolvedPr,
+    reviewId: result.id,
+    state: result.state,
+    url: result.html_url,
+  };
+});
+
 export const submitPendingReview = Effect.fn("pr.submitPendingReview")(function* (
   pr: number | null,
   reviewId: string | null,
   body: string | null,
+  event: ReviewEvent = "comment",
+  confirm = false,
 ) {
   const service = yield* GitHubService;
+
+  yield* requireVerdictConfirm({ command: "gh-tool pr submit-review", event, confirm });
+
   const repoInfo = yield* service.getRepoInfo();
 
   const resolvedPr = pr ?? (yield* viewPR(null)).number;
@@ -1007,7 +1107,7 @@ export const submitPendingReview = Effect.fn("pr.submitPendingReview")(function*
 
   const result = (yield* service.runGraphQL(SUBMIT_REVIEW_MUTATION, {
     reviewId: targetReviewId,
-    event: "COMMENT",
+    event: REVIEW_EVENT_API[event],
     body: body ?? "",
   })) as SubmitReviewResult;