mergestorm-mcp 0.2.30 → 0.2.31

package/dist/index.js

@@ -163,6 +163,8 @@ import {
   IssueReviewTimeoutError,
   NO_LINKED_ISSUE,
   getIssueReview,
+  issueReviewStallAdvice,
+  issueReviewWaitAfter,
   loadConfig as loadConfig2,
   pollIssueReview
 } from "mergestorm/client";
@@ -172,7 +174,9 @@ var issueReviewWaitSchema = {
   owner: z2.string().trim().regex(/^[A-Za-z0-9_.-]{1,100}$/),
   repo: z2.string().trim().regex(/^[A-Za-z0-9_.-]{1,100}$/),
   number: z2.number().int().min(1),
-  timeout_s: z2.number().min(0).max(ISSUE_REVIEW_WAIT_MAX_S).optional()
+  timeout_s: z2.number().min(0).max(ISSUE_REVIEW_WAIT_MAX_S).optional(),
+  after_round: z2.number().int().min(1).optional(),
+  waiting_since: z2.string().datetime({ offset: true }).optional()
 };
 var inputSchema2 = z2.object(issueReviewWaitSchema);
 function blockingCount(status) {
@@ -181,14 +185,36 @@ function blockingCount(status) {
 function issueReviewSummary(status) {
   const ref = `${status.owner}/${status.repo}#${status.number}`;
   const round = status.round ? ` (round ${status.round} of ${status.maxRounds})` : "";
-  const head = status.state === "approved" ? status.approvedBy === null ? `The Vortex review of ${ref} failed, so it does not hold the pull request back; you may open it.` : `${ref} is approved by ${status.approvedBy === "human" ? "a person" : "Vortex"}; you may open the pull request.` : status.state === "off" ? `Issue reviews are off for ${status.owner}/${status.repo}; ${ref} needs no approval.` : status.mode === "mention" && status.state === "unreviewed" ? `Issue reviews for ${status.owner}/${status.repo} run on mention; ${ref} needs no approval, so you may open the pull request.` : status.state === "pending" ? `${ref}: Vortex is still reviewing${round}; call issue_review_wait again.` : `${ref}: ${status.state}${round}, ${blockingCount(status)} point${blockingCount(status) === 1 ? "" : "s"} to answer.${status.mode === "auto" ? " Do not open the pull request yet." : ""}`;
+  const wait = status.wait;
+  if (wait.status === "stalled") {
+    const since = wait.minutes !== null ? ` for ${wait.minutes} min` : "";
+    return `${ref}: stalled, no new Vortex round${since} (reason: ${wait.reason}). ${issueReviewStallAdvice(wait.reason, status.mode)} Tell the human once and stop; do not call issue_review_wait in a loop.`;
+  }
+  if (wait.status === "answered_waiting_for_round" && wait.reason === "answer_not_seen") {
+    return `${ref}: Vortex has not seen an answer after round ${wait.verdictRound ?? status.round} yet. If you have not posted your answer, post it now in one issue comment; then call issue_review_wait again with next_args. Do not poll GitHub.`;
+  }
+  if (wait.status === "answered_waiting_for_round") {
+    return `${ref}: Vortex has an answer after round ${wait.verdictRound ?? status.round}; the next round has not finished. Call issue_review_wait again with next_args; do not poll GitHub.`;
+  }
+  if (wait.status === "round_running" && status.state !== "pending") {
+    return `${ref}: Vortex is running a round${round}; call issue_review_wait again with next_args.`;
+  }
+  const head = status.state === "approved" ? status.approvedBy === null ? `The Vortex review of ${ref} failed, so it does not hold the pull request back; you may open it.` : `${ref} is approved by ${status.approvedBy === "human" ? "a person" : "Vortex"}; you may open the pull request.` : status.state === "off" ? `Issue reviews are off for ${status.owner}/${status.repo}; ${ref} needs no approval.` : status.mode === "mention" && status.state === "unreviewed" ? `Issue reviews for ${status.owner}/${status.repo} run on mention; ${ref} needs no approval, so you may open the pull request.` : status.state === "pending" ? `${ref}: Vortex is still reviewing${round}; call issue_review_wait again with next_args.` : `${ref}: ${status.state}${round}, ${blockingCount(status)} point${blockingCount(status) === 1 ? "" : "s"} to answer.${status.mode === "auto" ? " Do not open the pull request yet." : ""} After you answer in one issue comment, call issue_review_wait once with next_args.`;
   return status.next ? `${head} ${status.next}` : head;
 }
-var ISSUE_NOT_APPROVED_HINT = "Do not open the pull request yet: reply once in a comment on each issue, accepting each blocking point's suggested fix or saying why not (notes do not block), call issue_review_wait until it returns approved, then try again.";
+var ISSUE_NOT_APPROVED_HINT = "Do not open the pull request yet: reply once in a comment on each issue, accepting each blocking point's suggested fix or saying why not (notes do not block), call issue_review_wait with its next_args until it returns approved or stalled, then try again. Never poll GitHub.";
 function withIssueReviewHint(err, message) {
   return err instanceof CommandError3 && err.code === "issue_not_approved" && err.reason !== NO_LINKED_ISSUE ? `${message}
 ${ISSUE_NOT_APPROVED_HINT}` : message;
 }
+function nextArgs(status, input, waitingSince) {
+  const target2 = { owner: input.owner, repo: input.repo, number: input.number };
+  const wait = status.wait;
+  if (wait.status === "approved" || wait.status === "stalled") return null;
+  if (wait.status === "points") return wait.verdictRound ? { ...target2, after_round: wait.verdictRound } : target2;
+  const after = input.after_round ?? wait.verdictRound ?? void 0;
+  return { ...target2, ...after ? { after_round: after } : {}, waiting_since: waitingSince };
+}
 function failure(code, message, extra = {}) {
   return { summary: message, data: { error: { code, message, ...extra } }, isError: true };
 }
@@ -197,12 +223,22 @@ async function issueReviewWait(input, cfg, deps = {}) {
   if (!parsed.success) {
     return failure("invalid_input", `issue_review_wait needs owner, repo, a positive issue number and timeout_s from 0 to ${ISSUE_REVIEW_WAIT_MAX_S}`);
   }
-  const { owner, repo: repo2, number, timeout_s } = parsed.data;
+  const { owner, repo: repo2, number, timeout_s, after_round, waiting_since } = parsed.data;
   const target2 = { owner, repo: repo2, number };
+  const now = deps.now ?? Date.now;
+  const since = Math.min(waiting_since ? Date.parse(waiting_since) : now(), now());
+  const sinceIso = new Date(since).toISOString();
+  const withNext = (status) => {
+    const next = nextArgs(status, parsed.data, sinceIso);
+    return { summary: issueReviewSummary(status), data: { ...status, ...next ? { next_args: next } : {} } };
+  };
   try {
     const resolved = cfg ?? await loadConfig2();
-    const status = timeout_s === 0 ? await (deps.getIssueReview ?? getIssueReview)(resolved, target2) : await (deps.pollIssueReview ?? pollIssueReview)(resolved, target2, {
+    const read = timeout_s === 0 ? await (deps.getIssueReview ?? getIssueReview)(resolved, target2) : null;
+    const status = timeout_s === 0 ? read && { ...read, wait: issueReviewWaitAfter(read, { afterRound: after_round, waitedMs: now() - since, nowMs: now() }) } : await (deps.pollIssueReview ?? pollIssueReview)(resolved, target2, {
       timeoutMs: Math.max(1, Math.round((timeout_s ?? ISSUE_REVIEW_WAIT_MAX_S) * 1e3)),
+      ...after_round !== void 0 ? { afterRound: after_round } : {},
+      waitingSince: since,
       ...deps.pollIntervalMs !== void 0 ? { intervalMs: deps.pollIntervalMs } : {}
     });
     if (!status) {
@@ -211,11 +247,9 @@ async function issueReviewWait(input, cfg, deps = {}) {
         "This Mergestorm server does not review issues yet. Open the pull request as before."
       );
     }
-    return { summary: issueReviewSummary(status), data: { ...status } };
+    return withNext(status);
   } catch (err) {
-    if (err instanceof IssueReviewTimeoutError) {
-      return { summary: issueReviewSummary(err.lastStatus), data: { ...err.lastStatus } };
-    }
+    if (err instanceof IssueReviewTimeoutError) return withNext(err.lastStatus);
     const message = err instanceof Error ? err.message : String(err);
     return failure(
       err instanceof CommandError3 ? err.code ?? "issue_review_wait_failed" : "issue_review_wait_failed",
@@ -1873,7 +1907,7 @@ var MCP_HOSTED_SERVER_INSTRUCTIONS = [
 // src/server.ts
 var BATCH_SIZE_ROW = BEARER_SETTINGS2.find((row) => row.key === "merge_queue_batch_size");
 var MCP_SERVER_NAME = "mergestorm";
-var MCP_SERVER_VERSION = "0.2.30";
+var MCP_SERVER_VERSION = "0.2.31";
 var MCP_TOOL_NAMES = [
   "whoami",
   "credits",
@@ -2232,7 +2266,7 @@ function createMergestormMcpServer(options = {}) {
     "issue_review_wait",
     {
       title: "Wait for issue review",
-      description: "Read the Vortex review of a GitHub issue, which on repositories with issue reviews on must approve the issue before any pull request is opened for it. Returns the review state (approved, needs_answers, pending, unreviewed, capped or off), the round, the verdict, the summary, up to 8 points, the review comment link and next, one sentence saying what to do. timeout_s: 0 reads it once; otherwise it waits while the review is pending for one slice of up to 45s (the default) and returns pending when the slice ends, so call again. Open the pull request only on approved or off. On needs_answers, reply once in a comment on the issue: for each blocking point, accept its suggested fix or say why not (notes do not block; the PR review checks them against the code). Vortex then re-checks only the blocking points and approves the issue. On unreviewed, comment on the issue tagging @mergestorm-vortex to start a review, unless mode is mention, where an unreviewed issue needs no approval. Then call again. A person can also approve with an issue comment whose first line is mergestorm-issue: approve.",
+      description: "Wait for the next Vortex verdict on a GitHub issue. Returns the review state (approved, needs_answers, pending, unreviewed or off), the round, the verdict, the summary, up to 8 points, the review comment link, next (one sentence saying what to do), wait.status and, while there is more to wait for, next_args. wait.status is answered_waiting_for_round (Vortex has an answer after the last verdict and the next round has not finished; with wait.reason answer_not_seen Vortex has no answer after the verdict yet, so post yours), round_running, points (a verdict with points to answer), approved (approved, off, a failed review, the round cap, or unreviewed on a mention-mode repo) or stalled (no round started: about 10 minutes after a queued answer, at once when an answer failed or was skipped without starting a round, about 10 minutes into the wait when no review has started at all, or about 10 minutes after the verdict with no answer seen once the wait is at least 2 minutes old; wait.reason says why). timeout_s: 0 reads it once; otherwise it waits for one slice of up to 45s (the default). Call it again with exactly next_args: after_round is the round whose verdict you already saw, so the stale verdict is never returned again, and waiting_since carries the stall clock across slices. Open the pull request only on approved, or when the summary says the issue needs no approval (issue reviews off, or unreviewed on a mention-mode repo). On points, answer in ONE new comment on the issue as the author or a maintainer: for each blocking point, accept its suggested fix or say why not (notes do not block). On a mention-mode repo the comment must tag @mergestorm-vortex and the next round starts at once; on an auto-mode repo it starts about 90s later. Editing the body or an earlier comment starts nothing. Then call once with next_args. On stalled, follow the summary's advice for wait.reason and do not loop on this tool. Never poll GitHub or loop on this tool beyond next_args. A person can also approve with an issue comment whose first line is mergestorm-issue: approve.",
       inputSchema: issueReviewWaitSchema,
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
     },

package/dist/lib/server.d.ts

@@ -3,7 +3,7 @@ import { type Config } from "mergestorm/client";
 import { MCP_HOSTED_SERVER_INSTRUCTIONS } from "./pr-loop-instructions.js";
 export { MCP_HOSTED_SERVER_INSTRUCTIONS };
 export declare const MCP_SERVER_NAME = "mergestorm";
-export declare const MCP_SERVER_VERSION = "0.2.30";
+export declare const MCP_SERVER_VERSION = "0.2.31";
 export declare const MCP_TOOL_NAMES: readonly ["whoami", "credits", "review_list", "review_submit", "review_wait", "review_wait_pr", "review_dismiss", "review_start_pr", "review_stop_pr", "cyclone_start", "cyclone_job", "issue_create", "issue_review_wait", "stack_adopt", "stack_enqueue", "stack_list", "stack_publish", "stack_publish_status", "stack_restack", "stack_set", "stack_status", "stack_wait", "queue_status", "settings_get", "settings_set", "repo_settings_get", "repo_settings_set", "surge_setup", "list_memories", "search_memory", "remember", "update_memory", "forget_memory", "get_memory_mode", "set_memory_mode", "web_search", "read_web_page"];
 export declare const MCP_SERVER_INSTRUCTIONS: string;
 export declare function fail(err: unknown): {

package/dist/lib/server.js

@@ -32,7 +32,7 @@ import { whoami } from "./tools/whoami.js";
 import { MCP_FINDING_DEFERRAL_RULE, MCP_HOSTED_SERVER_INSTRUCTIONS, MCP_STACK_DONE_INSTRUCTIONS, MCP_PR_LOOP_INSTRUCTIONS, MCP_STACK_BASE_INSTRUCTIONS, MCP_STACK_WATCH_INSTRUCTIONS, } from "./pr-loop-instructions.js";
 export { MCP_HOSTED_SERVER_INSTRUCTIONS };
 export const MCP_SERVER_NAME = "mergestorm";
-export const MCP_SERVER_VERSION = "0.2.30";
+export const MCP_SERVER_VERSION = "0.2.31";
 export const MCP_TOOL_NAMES = [
     "whoami",
     "credits",
@@ -351,7 +351,7 @@ export function createMergestormMcpServer(options = {}) {
     });
     addTool("issue_review_wait", {
         title: "Wait for issue review",
-        description: "Read the Vortex review of a GitHub issue, which on repositories with issue reviews on must approve the issue before any pull request is opened for it. Returns the review state (approved, needs_answers, pending, unreviewed, capped or off), the round, the verdict, the summary, up to 8 points, the review comment link and next, one sentence saying what to do. timeout_s: 0 reads it once; otherwise it waits while the review is pending for one slice of up to 45s (the default) and returns pending when the slice ends, so call again. Open the pull request only on approved or off. On needs_answers, reply once in a comment on the issue: for each blocking point, accept its suggested fix or say why not (notes do not block; the PR review checks them against the code). Vortex then re-checks only the blocking points and approves the issue. On unreviewed, comment on the issue tagging @mergestorm-vortex to start a review, unless mode is mention, where an unreviewed issue needs no approval. Then call again. A person can also approve with an issue comment whose first line is mergestorm-issue: approve.",
+        description: "Wait for the next Vortex verdict on a GitHub issue. Returns the review state (approved, needs_answers, pending, unreviewed or off), the round, the verdict, the summary, up to 8 points, the review comment link, next (one sentence saying what to do), wait.status and, while there is more to wait for, next_args. wait.status is answered_waiting_for_round (Vortex has an answer after the last verdict and the next round has not finished; with wait.reason answer_not_seen Vortex has no answer after the verdict yet, so post yours), round_running, points (a verdict with points to answer), approved (approved, off, a failed review, the round cap, or unreviewed on a mention-mode repo) or stalled (no round started: about 10 minutes after a queued answer, at once when an answer failed or was skipped without starting a round, about 10 minutes into the wait when no review has started at all, or about 10 minutes after the verdict with no answer seen once the wait is at least 2 minutes old; wait.reason says why). timeout_s: 0 reads it once; otherwise it waits for one slice of up to 45s (the default). Call it again with exactly next_args: after_round is the round whose verdict you already saw, so the stale verdict is never returned again, and waiting_since carries the stall clock across slices. Open the pull request only on approved, or when the summary says the issue needs no approval (issue reviews off, or unreviewed on a mention-mode repo). On points, answer in ONE new comment on the issue as the author or a maintainer: for each blocking point, accept its suggested fix or say why not (notes do not block). On a mention-mode repo the comment must tag @mergestorm-vortex and the next round starts at once; on an auto-mode repo it starts about 90s later. Editing the body or an earlier comment starts nothing. Then call once with next_args. On stalled, follow the summary's advice for wait.reason and do not loop on this tool. Never poll GitHub or loop on this tool beyond next_args. A person can also approve with an issue comment whose first line is mergestorm-issue: approve.",
         inputSchema: issueReviewWaitSchema,
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async (args) => {

package/dist/lib/tools/issue-review-wait.d.ts

@@ -7,31 +7,47 @@ export declare const issueReviewWaitSchema: {
     repo: z.ZodString;
     number: z.ZodNumber;
     timeout_s: z.ZodOptional<z.ZodNumber>;
+    after_round: z.ZodOptional<z.ZodNumber>;
+    waiting_since: z.ZodOptional<z.ZodString>;
 };
 declare const inputSchema: z.ZodObject<{
     owner: z.ZodString;
     repo: z.ZodString;
     number: z.ZodNumber;
     timeout_s: z.ZodOptional<z.ZodNumber>;
+    after_round: z.ZodOptional<z.ZodNumber>;
+    waiting_since: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     number: number;
     owner: string;
     repo: string;
     timeout_s?: number | undefined;
+    after_round?: number | undefined;
+    waiting_since?: string | undefined;
 }, {
     number: number;
     owner: string;
     repo: string;
     timeout_s?: number | undefined;
+    after_round?: number | undefined;
+    waiting_since?: string | undefined;
 }>;
 export type IssueReviewWaitInput = z.infer<typeof inputSchema>;
 export type IssueReviewWaitDeps = {
     getIssueReview?: typeof getIssueReview;
     pollIssueReview?: typeof pollIssueReview;
     pollIntervalMs?: number;
+    now?: () => number;
+};
+export type IssueReviewWaitNextArgs = {
+    owner: string;
+    repo: string;
+    number: number;
+    after_round?: number;
+    waiting_since?: string;
 };
 export declare function issueReviewSummary(status: IssueReviewStatus): string;
-export declare const ISSUE_NOT_APPROVED_HINT = "Do not open the pull request yet: reply once in a comment on each issue, accepting each blocking point's suggested fix or saying why not (notes do not block), call issue_review_wait until it returns approved, then try again.";
+export declare const ISSUE_NOT_APPROVED_HINT = "Do not open the pull request yet: reply once in a comment on each issue, accepting each blocking point's suggested fix or saying why not (notes do not block), call issue_review_wait with its next_args until it returns approved or stalled, then try again. Never poll GitHub.";
 export declare function withIssueReviewHint(err: unknown, message: string): string;
 export declare function issueReviewWait(input: IssueReviewWaitInput, cfg?: Config, deps?: IssueReviewWaitDeps): Promise<ToolPayload>;
 export {};

package/dist/lib/tools/issue-review-wait.js

@@ -1,4 +1,4 @@
-import { CommandError, IssueReviewTimeoutError, NO_LINKED_ISSUE, getIssueReview, loadConfig, pollIssueReview, } from "mergestorm/client";
+import { CommandError, IssueReviewTimeoutError, NO_LINKED_ISSUE, getIssueReview, issueReviewStallAdvice, issueReviewWaitAfter, loadConfig, pollIssueReview, } from "mergestorm/client";
 import { z } from "zod";
 export const ISSUE_REVIEW_WAIT_MAX_S = 45;
 export const issueReviewWaitSchema = {
@@ -6,6 +6,8 @@ export const issueReviewWaitSchema = {
     repo: z.string().trim().regex(/^[A-Za-z0-9_.-]{1,100}$/),
     number: z.number().int().min(1),
     timeout_s: z.number().min(0).max(ISSUE_REVIEW_WAIT_MAX_S).optional(),
+    after_round: z.number().int().min(1).optional(),
+    waiting_since: z.string().datetime({ offset: true }).optional(),
 };
 const inputSchema = z.object(issueReviewWaitSchema);
 function blockingCount(status) {
@@ -14,6 +16,20 @@ function blockingCount(status) {
 export function issueReviewSummary(status) {
     const ref = `${status.owner}/${status.repo}#${status.number}`;
     const round = status.round ? ` (round ${status.round} of ${status.maxRounds})` : "";
+    const wait = status.wait;
+    if (wait.status === "stalled") {
+        const since = wait.minutes !== null ? ` for ${wait.minutes} min` : "";
+        return `${ref}: stalled, no new Vortex round${since} (reason: ${wait.reason}). ${issueReviewStallAdvice(wait.reason, status.mode)} Tell the human once and stop; do not call issue_review_wait in a loop.`;
+    }
+    if (wait.status === "answered_waiting_for_round" && wait.reason === "answer_not_seen") {
+        return `${ref}: Vortex has not seen an answer after round ${wait.verdictRound ?? status.round} yet. If you have not posted your answer, post it now in one issue comment; then call issue_review_wait again with next_args. Do not poll GitHub.`;
+    }
+    if (wait.status === "answered_waiting_for_round") {
+        return `${ref}: Vortex has an answer after round ${wait.verdictRound ?? status.round}; the next round has not finished. Call issue_review_wait again with next_args; do not poll GitHub.`;
+    }
+    if (wait.status === "round_running" && status.state !== "pending") {
+        return `${ref}: Vortex is running a round${round}; call issue_review_wait again with next_args.`;
+    }
     const head = status.state === "approved"
         ? status.approvedBy === null
             ? `The Vortex review of ${ref} failed, so it does not hold the pull request back; you may open it.`
@@ -23,14 +39,24 @@ export function issueReviewSummary(status) {
             : status.mode === "mention" && status.state === "unreviewed"
                 ? `Issue reviews for ${status.owner}/${status.repo} run on mention; ${ref} needs no approval, so you may open the pull request.`
                 : status.state === "pending"
-                    ? `${ref}: Vortex is still reviewing${round}; call issue_review_wait again.`
-                    : `${ref}: ${status.state}${round}, ${blockingCount(status)} point${blockingCount(status) === 1 ? "" : "s"} to answer.${status.mode === "auto" ? " Do not open the pull request yet." : ""}`;
+                    ? `${ref}: Vortex is still reviewing${round}; call issue_review_wait again with next_args.`
+                    : `${ref}: ${status.state}${round}, ${blockingCount(status)} point${blockingCount(status) === 1 ? "" : "s"} to answer.${status.mode === "auto" ? " Do not open the pull request yet." : ""} After you answer in one issue comment, call issue_review_wait once with next_args.`;
     return status.next ? `${head} ${status.next}` : head;
 }
-export const ISSUE_NOT_APPROVED_HINT = "Do not open the pull request yet: reply once in a comment on each issue, accepting each blocking point's suggested fix or saying why not (notes do not block), call issue_review_wait until it returns approved, then try again.";
+export const ISSUE_NOT_APPROVED_HINT = "Do not open the pull request yet: reply once in a comment on each issue, accepting each blocking point's suggested fix or saying why not (notes do not block), call issue_review_wait with its next_args until it returns approved or stalled, then try again. Never poll GitHub.";
 export function withIssueReviewHint(err, message) {
     return err instanceof CommandError && err.code === "issue_not_approved" && err.reason !== NO_LINKED_ISSUE ? `${message}\n${ISSUE_NOT_APPROVED_HINT}` : message;
 }
+function nextArgs(status, input, waitingSince) {
+    const target = { owner: input.owner, repo: input.repo, number: input.number };
+    const wait = status.wait;
+    if (wait.status === "approved" || wait.status === "stalled")
+        return null;
+    if (wait.status === "points")
+        return wait.verdictRound ? { ...target, after_round: wait.verdictRound } : target;
+    const after = input.after_round ?? wait.verdictRound ?? undefined;
+    return { ...target, ...(after ? { after_round: after } : {}), waiting_since: waitingSince };
+}
 function failure(code, message, extra = {}) {
     return { summary: message, data: { error: { code, message, ...extra } }, isError: true };
 }
@@ -39,25 +65,34 @@ export async function issueReviewWait(input, cfg, deps = {}) {
     if (!parsed.success) {
         return failure("invalid_input", `issue_review_wait needs owner, repo, a positive issue number and timeout_s from 0 to ${ISSUE_REVIEW_WAIT_MAX_S}`);
     }
-    const { owner, repo, number, timeout_s } = parsed.data;
+    const { owner, repo, number, timeout_s, after_round, waiting_since } = parsed.data;
     const target = { owner, repo, number };
+    const now = deps.now ?? Date.now;
+    const since = Math.min(waiting_since ? Date.parse(waiting_since) : now(), now());
+    const sinceIso = new Date(since).toISOString();
+    const withNext = (status) => {
+        const next = nextArgs(status, parsed.data, sinceIso);
+        return { summary: issueReviewSummary(status), data: { ...status, ...(next ? { next_args: next } : {}) } };
+    };
     try {
         const resolved = cfg ?? (await loadConfig());
+        const read = timeout_s === 0 ? await (deps.getIssueReview ?? getIssueReview)(resolved, target) : null;
         const status = timeout_s === 0
-            ? await (deps.getIssueReview ?? getIssueReview)(resolved, target)
+            ? read && { ...read, wait: issueReviewWaitAfter(read, { afterRound: after_round, waitedMs: now() - since, nowMs: now() }) }
             : await (deps.pollIssueReview ?? pollIssueReview)(resolved, target, {
                 timeoutMs: Math.max(1, Math.round((timeout_s ?? ISSUE_REVIEW_WAIT_MAX_S) * 1000)),
+                ...(after_round !== undefined ? { afterRound: after_round } : {}),
+                waitingSince: since,
                 ...(deps.pollIntervalMs !== undefined ? { intervalMs: deps.pollIntervalMs } : {}),
             });
         if (!status) {
             return failure("issue_review_unavailable", "This Mergestorm server does not review issues yet. Open the pull request as before.");
         }
-        return { summary: issueReviewSummary(status), data: { ...status } };
+        return withNext(status);
     }
     catch (err) {
-        if (err instanceof IssueReviewTimeoutError) {
-            return { summary: issueReviewSummary(err.lastStatus), data: { ...err.lastStatus } };
-        }
+        if (err instanceof IssueReviewTimeoutError)
+            return withNext(err.lastStatus);
         const message = err instanceof Error ? err.message : String(err);
         return failure(err instanceof CommandError ? err.code ?? "issue_review_wait_failed" : "issue_review_wait_failed", message, err instanceof CommandError && err.retryAfterSeconds !== undefined ? { retry_after_seconds: err.retryAfterSeconds } : {});
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm-mcp",
-  "version": "0.2.30",
+  "version": "0.2.31",
   "description": "Mergestorm MCP server — identity, review, and read-only stack tools over stdio",
   "license": "MIT",
   "type": "module",
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "mergestorm": "0.3.67",
+    "mergestorm": "0.3.68",
     "zod": "^3.24.2"
   },
   "devDependencies": {