mergestorm 0.3.64 → 0.3.67

package/README.md

@@ -45,12 +45,12 @@ On a TTY, bare `mergestorm` (or `mergestorm shell`) opens a branded REPL: a comp
 
 ```
 ╭──────────────────────────────────────────────────────────────────────────────╮
-│  ▀▀▀▀▀▀▀▀▀▀▘  mergestorm v0.3.64                                             │
+│  ▀▀▀▀▀▀▀▀▀▀▘  mergestorm v0.3.67                                             │
 │ ▀▀▀▀▀▀▀▀▀     ● msk_live_… · maelstrom                                       │
 │  ▀▀▀▀▀▀       [████████░░░░░░░░░░░░░░░░░░░░░░] 25% used                      │
 │   ▝▀▀▀▀▀      local reviews + stacked PRs · mergestorm.ai                    │
 │     ▝▀▀▘      review a diff · usage for tabs · /help for all commands        │
-│       ▀       New in v0.3.64: Memory commands and Overdrive merge batches    │
+│       ▀       New in v0.3.67: Issue review: reply once, then one re-check    │
 ╰──────────────────────────────────────────────────────────────────────────────╯
 mergestorm
 ╭──────────────────────────────────────────────────────────────────────────────╮
@@ -75,11 +75,14 @@ One-shot subcommands work the same inside the shell and from argv (scripts/CI):
 ```
 mergestorm                      Interactive shell (TTY only)
 mergestorm shell                Explicit shell entry
-mergestorm login                Sign in via browser; stores an API key in ~/.mergestorm/config.json
+mergestorm login                Sign in via browser and add the account (up to 3 saved)
 mergestorm login --start        Print a sign-in URL and code, then exit (agents)
 mergestorm login --finish       Store the API key once the code from --start is approved
 mergestorm login --key          Paste an existing API key instead (headless/CI)
-mergestorm logout               Remove the stored API key
+mergestorm logout               Log out of the active account (or --account <name>) and revoke its key
+mergestorm account list [--json]  Saved accounts (up to 3), the active one marked
+mergestorm account use <name>   Make <name> the active account
+mergestorm account remove <name>  Log out of <name> and revoke its key
 mergestorm review [base] [head] Review git diff base...head (default: origin/HEAD or main or master)
 mergestorm status <job_id>      Fetch a review job (envelope; --json --wait --timeout)
 mergestorm status               Tabbed Status / Usage / Jobs browser (TTY)
@@ -87,10 +90,11 @@ mergestorm credits [--json]     Usage panel (bar + last 5 jobs); tabbed browser
 mergestorm jobs [n] [--json]    Recent review jobs (default 10, max 50)
 mergestorm branches [n]         Recently reviewed branches (arrow-pick on TTY)
 mergestorm chain [slug]         Branch review-chain timeline (default: current branch)
-mergestorm whoami [--json]      Key prefix, plan, API base, config path
+mergestorm whoami [--json]      Active account, key prefix, plan, API base, config path
 mergestorm skill install --claude|--cursor|--agents  Copy the Mergestorm skills into this repo
 mergestorm thread <slug>        Jobs in a review thread
-mergestorm issue create --title <t>  Open a GitHub issue through Mergestorm, no `gh` (`--body`, `--body-file`, `--label`, `--repo`)
+mergestorm issue create --title <t>  Open a GitHub issue through Mergestorm, no `gh` (`--body`, `--body-file`, `--label`, `--repo`, `--wait`)
+mergestorm issue wait <n>       Wait for the Vortex issue review; exits 0 once approved, 4 with points to answer
 mergestorm stack create [name]  New local stack layer (optional `--onto` / `--trunk` / `--extend`)
 mergestorm stack submit         Push layers, open PRs (`gh`), register via adopt (optional `--extend`, `--server-side`)
 mergestorm stack publish        Publish the current branch through Mergestorm with no GitHub credentials (`--base <branch> --extend` to stack, `--status` to read it)
@@ -167,25 +171,39 @@ mg stack publish --status               # absent | pushed | opened | registered
 ```
 
 - **Issues too.** `mg issue create` opens the issue a PR needs through the same Surge App, with existing labels only. Running it again with the same title returns the issue it already opened. Put `Fixes #<n>` in the commit message; `stack submit` carries it into the PR body.
+- **Issue reviews first.** On a repository with Vortex issue reviews on, Vortex reviews each new issue before any PR. `mg issue wait <n>` (or `mg issue create --wait`) waits for that review: it exits 0 once the issue is approved, or exits 4 with the numbered points to answer. Reply once in a comment on the issue, accepting each blocking point's suggested fix or saying why not, and wait again; Vortex re-checks only the blocking points, once, and approves the issue. Notes never block; the PR review checks them against the code. A person can approve early with an issue comment whose first line is `mergestorm-issue: approve`. `stack submit` refuses to open a PR whose tip commit links an issue that is not approved yet, or links no issue at all while issue reviews are on.
 - **Exact contents.** Every commit travels with its Git tree SHA and the whole content of each changed file, so binaries, deletions, renames, executable bits and symlinks arrive unchanged. Mergestorm moves the branch only when GitHub builds the same tree, and `mg` checks the returned tree against your local branch.
 - **Never overwrites surprises.** `mg` looks at the branch on GitHub first. If its files match one of your local commits, only the commits after that one are appended. If they match none (someone else pushed, or you rebased), `mg` stops with `head_changed`; `--replace-head <sha>` replaces exactly that head and nothing else. Mergestorm refuses `main`, `master`, the default branch, protected branches and its own `mg-stack-*`, `mg-park-*` and `mq-batch-*` branches.
 - **Safe to run again.** After a timeout or an error, run the same command again. It finds the branch, pull request and stack it already made and finishes the missing step; it does not create duplicates.
 - **Read-only home directory.** `mg` keeps the saved login and the local stack state of `stack create` / `stack submit` under `~/.mergestorm`. Where the home directory cannot be written, set `MERGESTORM_HOME` to a writable directory (outside the repository) and every command uses that instead. `MERGESTORM_API_KEY` supplies the key without `mg login`.
+- **Several accounts.** `mg login` keeps up to three accounts signed in; `mg account use <name>` picks the active one, and `--account <name>` or `MERGESTORM_ACCOUNT` runs one command as another.
 - **Limits.** 20 commits, 500 changed paths, 2 MiB a file and 8 MiB in total per publication. Submodules and merge commits are refused with the path or the reason. `stack submit --server-side` publishes the first two layers of a stack; a third layer needs a park freeze, which this mode does not create, so add it once the first two are registered.
 
 If local authoring state is stale or malformed, use `mg stack reset --force`; this clears only pre-submit CLI state and never deletes branches, PRs, or registered stacks.
 
 ### `login`
 
-Runs a browser device-authorization flow: prints a short code, opens `https://mergestorm.ai/cli/auth`, and — once you approve — mints and stores an API key in `~/.mergestorm/config.json` (mode `600`), or in `$MERGESTORM_HOME/config.json` when `MERGESTORM_HOME` is set. No key copy/paste needed.
+Runs a browser device-authorization flow: prints a short code, opens `https://mergestorm.ai/cli/auth`, and — once you approve — mints an API key and saves it as an account in `~/.mergestorm/config.json` (mode `600`), or in `$MERGESTORM_HOME/config.json` when `MERGESTORM_HOME` is set. No key copy/paste needed. The account is named by its GitHub login (or its email when there is no GitHub login), as `mg whoami` reports it, and becomes the active account.
+
+Up to three accounts can stay logged in at once. `mg login` again adds another account, or replaces the key of an account that is already saved. A fourth login is refused with the three names; remove one first. A login saved by an older `mg` migrates on first read into an account named by its key prefix (`msk_live_abcd`), and takes its real name the next time a command such as `mg whoami` reaches the API. The file also keeps the active account's key at its top level, so an older `mg` or `mergestorm-mcp` on the same machine keeps signing in as the active account.
 
 For headless or CI environments, use `mergestorm login --key` to paste an existing `msk_live_…` key (create one on the dashboard [Settings → API](https://mergestorm.ai/settings#api)). On a TTY the paste is hidden (not echoed); the CLI verifies the key with the API before saving.
 
 For an agent, which cannot sit in a prompt while a person signs in, use two steps. `mergestorm login --start` prints the URL and the short code and exits. Give both to the account owner, who opens [mergestorm.ai/cli/auth](https://mergestorm.ai/cli/auth) on any device, signs in, and approves the code. Then `mergestorm login --finish` stores the API key. The code lasts 10 minutes, and `--finish` can be run again if it is interrupted before the approval.
 
+### `account`
+
+```bash
+mg account list            # saved accounts, the active one marked ● (--json for machines)
+mg account use work        # make "work" the active account for every later command
+mg account remove work     # log "work" out: revoke its API key and drop it
+```
+
+Every command runs as the active account. To run one command as another saved account without switching, pass `--account <name>` anywhere on the command line (`mg --account work stack submit`, `mg whoami --account work`), or set `MERGESTORM_ACCOUNT=<name>`; the flag wins over the variable, and both win over the active account. An unknown name stops the command and lists the saved accounts. `MERGESTORM_API_KEY` still overrides every saved account. The `mergestorm-mcp` server reads the same store, so `MERGESTORM_ACCOUNT` in its environment picks the account it serves.
+
 ### `logout`
 
-Removes `~/.mergestorm/config.json` (or `$MERGESTORM_HOME/config.json` when `MERGESTORM_HOME` is set) so the stored key is no longer used.
+Logs out of the active account (or the one named with `--account`): revokes that API key on the server when it can, then drops the account from the store. The next saved account, if any, becomes active. `mg account remove <name>` does the same for a named account.
 
 ### `review [base] [head]`
 
@@ -234,7 +252,8 @@ Require a logged-in key and API support for `GET /api/v1/me` and `GET /api/v1/re
 
 | Variable | Purpose | Default |
 |----------|---------|---------|
-| `MERGESTORM_API_KEY` | API key (overrides the stored config) | — |
+| `MERGESTORM_API_KEY` | API key (overrides every saved account) | — |
+| `MERGESTORM_ACCOUNT` | Saved account to run as; `--account <name>` on a command wins over it | the active account |
 | `MERGESTORM_API_URL` | API base URL | `https://api.mergestorm.ai` |
 | `MERGESTORM_HOME` | Directory for the saved login and local stack state, for machines whose home directory is read-only | `~/.mergestorm` |
 | `NO_COLOR` | Disable ANSI colors | — |

package/dist/api.d.ts

@@ -30,14 +30,20 @@ export declare function devicePost(base: string, route: string, json: unknown, o
     status: number;
     body: any;
 }>;
-export type SurgeUsage = {
+type SurgeUsage = {
     includedMinutes: number;
     usedMinutes: number;
     walletMinutes: number;
     windowStart: string;
     pricePerMinuteUsd: number;
 };
+export type AccountIdentity = {
+    github_login: string | null;
+    email: string | null;
+};
+export declare function accountLabel(account: AccountIdentity | null | undefined): string | null;
 export type MeResponse = {
+    account?: AccountIdentity;
     key: {
         prefix: string;
         name: string;
@@ -182,10 +188,10 @@ export type SettingsResponse = import("./automation-catalog.js").BearerSettingsV
     github_connected: boolean;
     stacks_ready?: boolean;
 };
-export declare const REPO_SETTINGS_SWITCH_KEYS: readonly ["auto_patch_enabled", "auto_review_enabled", "auto_land_default", "merge_queue_batch_enabled", "merge_queue_overdrive"];
-export declare const REPO_SETTINGS_KEYS: readonly ["auto_patch_enabled", "auto_review_enabled", "auto_land_default", "merge_queue_batch_enabled", "merge_queue_overdrive", "merge_queue_batch_size", "merge_queue_lands_alone_paths"];
+export declare const REPO_SETTINGS_SWITCH_KEYS: readonly ["auto_patch_enabled", "auto_review_enabled", "auto_land_default", "merge_queue_batch_enabled", "merge_queue_overdrive", "issue_review_enabled", "issue_auto_review_enabled"];
+export declare const REPO_SETTINGS_KEYS: readonly ["auto_patch_enabled", "auto_review_enabled", "auto_land_default", "merge_queue_batch_enabled", "merge_queue_overdrive", "issue_review_enabled", "issue_auto_review_enabled", "merge_queue_batch_size", "merge_queue_lands_alone_paths"];
 export type RepoSettingsKey = (typeof REPO_SETTINGS_KEYS)[number];
-export type RepoSettingsValues = Record<(typeof REPO_SETTINGS_SWITCH_KEYS)[number], boolean | null> & {
+type RepoSettingsValues = Record<(typeof REPO_SETTINGS_SWITCH_KEYS)[number], boolean | null> & {
     merge_queue_batch_size: number | null;
     merge_queue_lands_alone_paths: string[] | null;
 };
@@ -219,6 +225,9 @@ export declare function patchSettings(patch: SettingsPatch, cfg?: Config, opts?:
 export declare function getMe(cfg?: Config, opts?: {
     timeoutMs?: number;
 }): Promise<MeResponse | null>;
+export declare function revokeOwnKey(cfg: Config, opts?: {
+    timeoutMs?: number;
+}): Promise<boolean>;
 export declare function listJobs(limit?: number, cfg?: Config, opts?: {
     timeoutMs?: number;
 }): Promise<JobListItem[]>;
@@ -257,16 +266,11 @@ export type StackPolicyPatch = {
 export declare function stackPolicyBody(policy: StackPolicyPatch | undefined): StackPolicyPatch;
 /** Adopt an open PR chain (Bearer POST /api/v1/stacks/adopt). */
 export declare function adoptStack(owner: string, repo: string, prNumber: number, cfg?: Config, policy?: StackPolicyPatch): Promise<unknown>;
-export declare const SURGE_REFUSAL_FALLBACK = "Mergestorm Surge is not installed or not ready on this repository. Install it from Agents.";
-export declare function surgeRefusal(body: unknown): CommandError | null;
-export declare const GITHUB_UNREADABLE_MESSAGE = "GitHub could not be read just now; try again.";
 /** Mint or reuse the PR3+ park freeze (Bearer POST /api/v1/stacks/:id/ensure-upper-park). */
 export declare function ensureUpperPark(stackId: string, cfg?: Config): Promise<{
     freezeBranch: string;
     created: boolean;
 }>;
-export declare const SURGE_INSTALL_URL = "https://github.com/apps/mergestorm-surge/installations/new";
-export declare function surgeNotInstalledMessage(owner: string, repo: string, installUrl?: string): string;
 export declare class LandedQueueReadError extends CommandError {
     readonly status: number;
     readonly retryAfterSeconds?: number | undefined;
@@ -336,7 +340,7 @@ export type StackPublicationRequest = {
     };
     autoLand?: boolean;
 };
-export type StackPublicationStack = {
+type StackPublicationStack = {
     id: string;
     autoPatchOverride: boolean | null;
     autoLand: boolean;
@@ -383,7 +387,6 @@ export type StackPublication = {
     };
     stack: StackPublicationStack;
 };
-export declare const STACK_PUBLICATION_TIMEOUT_MS = 180000;
 export declare function getStackPublication(cfg: Config, input: {
     owner: string;
     repo: string;
@@ -401,6 +404,69 @@ export declare function openStackIssue(input: {
     url: string;
     created: boolean;
 }>;
+export declare const ISSUE_REVIEW_STATES: readonly ["approved", "needs_answers", "pending", "unreviewed", "capped", "off"];
+export type IssueReviewState = (typeof ISSUE_REVIEW_STATES)[number];
+export type IssueReviewPoint = {
+    kind: string;
+    text: string;
+    blocking?: boolean;
+};
+export declare const ISSUE_REVIEW_MODES: readonly ["off", "mention", "auto"];
+export type IssueReviewMode = (typeof ISSUE_REVIEW_MODES)[number];
+export declare const ISSUE_REVIEW_TAG = "@mergestorm-vortex";
+export type IssueReviewStatus = {
+    owner: string;
+    repo: string;
+    number: number;
+    enabled: boolean;
+    mode: IssueReviewMode;
+    state: IssueReviewState;
+    approvedBy: "vortex" | "human" | null;
+    round: number | null;
+    maxRounds: number;
+    verdict: "ready" | "ready_with_notes" | "needs_answers" | null;
+    summary: string | null;
+    points: IssueReviewPoint[];
+    commentUrl: string | null;
+    next: string;
+};
+export type IssueReviewTarget = {
+    owner: string;
+    repo: string;
+    number: number;
+};
+export declare const ISSUE_REVIEW_POLL_INTERVAL_MS = 10000;
+export declare const ISSUE_REVIEW_DEFAULT_TIMEOUT_MS = 900000;
+export declare function parseIssueReviewStatus(body: unknown, target: IssueReviewTarget): IssueReviewStatus | null;
+export declare function getIssueReview(cfg: Config, target: IssueReviewTarget, opts?: {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<IssueReviewStatus | null>;
+export declare function getIssueReviewMode(cfg: Config, target: {
+    owner: string;
+    repo: string;
+}, opts?: {
+    timeoutMs?: number;
+}): Promise<IssueReviewMode | null>;
+export declare function issueReviewSettled(status: IssueReviewStatus): boolean;
+export declare function issueReviewBlocksPr(status: IssueReviewStatus): boolean;
+export declare class IssueReviewTimeoutError extends CommandError {
+    readonly lastStatus: IssueReviewStatus;
+    constructor(lastStatus: IssueReviewStatus);
+}
+export type PollIssueReviewOptions = {
+    timeoutMs?: number;
+    intervalMs?: number;
+    now?: () => number;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    signal?: AbortSignal;
+    onTick?: (status: IssueReviewStatus | null) => void;
+};
+export declare function pollIssueReview(cfg: Config, target: IssueReviewTarget, opts?: PollIssueReviewOptions): Promise<IssueReviewStatus | null>;
+export declare function issueReviewLines(status: IssueReviewStatus): string[];
+export declare function issueNotApprovedError(issues: IssueReviewStatus[], message?: string | null): CommandError;
+export declare const NO_LINKED_ISSUE = "no_linked_issue";
+export declare function issueNotApprovedRefusal(status: number, body: unknown, owner: string, repo: string): CommandError | null;
 /**
  * Patch any subset of one owned stack's automation policy
  * (Bearer PATCH /api/v1/stacks/:id). `null` clears an override.

package/dist/api.js

@@ -157,6 +157,13 @@ export async function devicePost(base, route, json, opts = {}) {
     }
     return { status: res.status, body: parsed };
 }
+export function accountLabel(account) {
+    const login = account?.github_login?.trim();
+    if (login)
+        return login;
+    const email = account?.email?.trim();
+    return email || null;
+}
 export function isPositiveInteger(value) {
     return typeof value === "number" && Number.isInteger(value) && value >= 1;
 }
@@ -180,6 +187,8 @@ export const REPO_SETTINGS_SWITCH_KEYS = [
     "auto_land_default",
     "merge_queue_batch_enabled",
     "merge_queue_overdrive",
+    "issue_review_enabled",
+    "issue_auto_review_enabled",
 ];
 export const REPO_SETTINGS_KEYS = [...REPO_SETTINGS_SWITCH_KEYS, "merge_queue_batch_size", "merge_queue_lands_alone_paths"];
 function repoSettingsFailure(status, body, retryAfterSeconds, action) {
@@ -293,6 +302,20 @@ export async function getMe(cfg, opts) {
         return null;
     }
 }
+export async function revokeOwnKey(cfg, opts) {
+    try {
+        const { status } = await apiFetch(cfg, "/api/v1/me/key", {
+            method: "DELETE",
+            timeoutMs: opts?.timeoutMs,
+        });
+        return status === 200;
+    }
+    catch (err) {
+        if (err instanceof CommandError)
+            return err.code === "auth_invalid";
+        return false;
+    }
+}
 export async function listJobs(limit = 10, cfg, opts) {
     const resolved = cfg ?? (await loadConfig());
     const capped = Math.min(Math.max(limit, 1), 50);
@@ -432,6 +455,9 @@ export async function adoptStack(owner, repo, prNumber, cfg, policy) {
     if (status === 429) {
         throw new CommandError(rateLimitedMessage(retryAfterSeconds), REVIEW_EXIT.rate_limited, "rate_limited", { retryAfterSeconds });
     }
+    const issueRefusal = issueNotApprovedRefusal(status, body, owner, repo);
+    if (issueRefusal)
+        throw issueRefusal;
     if (status !== 200) {
         const error = body && typeof body === "object" && "error" in body && typeof body.error === "string"
             ? body.error
@@ -469,13 +495,14 @@ const INFRASTRUCTURE_REFUSAL_CODES = [
     "cyclone_not_connected",
     "cyclone_not_installed",
     "cyclone_permission_missing",
+    "surge_other_account",
 ];
 function refusalReason(body) {
     const reason = (body && typeof body === "object" ? body.reason : undefined);
     return typeof reason === "string" && plainServerText(reason).trim() ? plainServerText(reason).trim() : undefined;
 }
-export const SURGE_REFUSAL_FALLBACK = "Mergestorm Surge is not installed or not ready on this repository. Install it from Agents.";
-export function surgeRefusal(body) {
+const SURGE_REFUSAL_FALLBACK = "Mergestorm Surge is not installed or not ready on this repository. Install it from Agents.";
+function surgeRefusal(body) {
     if (!body || typeof body !== "object")
         return null;
     const refusal = body;
@@ -489,7 +516,7 @@ export function surgeRefusal(body) {
     const installUrl = githubAppInstallUrl(refusal.installUrl) ?? "";
     return new CommandError(installUrl && !message.includes(installUrl) ? `${message} (${installUrl})` : message, 1, error, { reason });
 }
-export const GITHUB_UNREADABLE_MESSAGE = "GitHub could not be read just now; try again.";
+const GITHUB_UNREADABLE_MESSAGE = "GitHub could not be read just now; try again.";
 function serverMessage(message) {
     if (typeof message !== "string")
         return null;
@@ -518,8 +545,8 @@ export async function ensureUpperPark(stackId, cfg) {
         created: body.created === true,
     };
 }
-export const SURGE_INSTALL_URL = "https://github.com/apps/mergestorm-surge/installations/new";
-export function surgeNotInstalledMessage(owner, repo, installUrl = SURGE_INSTALL_URL) {
+const SURGE_INSTALL_URL = "https://github.com/apps/mergestorm-surge/installations/new";
+function surgeNotInstalledMessage(owner, repo, installUrl = SURGE_INSTALL_URL) {
     return (`Opening PRs needs either the GitHub CLI (gh auth login) or Mergestorm Surge installed on ` +
         `${owner}/${repo} (${installUrl}).`);
 }
@@ -533,6 +560,9 @@ function stackPullFailure(status, body, owner, repo, failLabel) {
     const surge = surgeRefusal(body);
     if (surge)
         return surge;
+    const issueRefusal = issueNotApprovedRefusal(status, body, owner, repo);
+    if (issueRefusal)
+        return issueRefusal;
     const text = `${String(rejection.error ?? "")} ${String(rejection.message ?? "")}`;
     if (rejection.error === "cyclone_not_installed" ||
         /not installed|installation[^\n]*not found/i.test(text)) {
@@ -599,7 +629,7 @@ export async function openStackPull(cfg, input) {
         created: row.created === true,
     };
 }
-export const STACK_PUBLICATION_TIMEOUT_MS = 180_000;
+const STACK_PUBLICATION_TIMEOUT_MS = 180_000;
 const PUBLICATION_ERROR_CODES = [
     "head_changed",
     "base_changed",
@@ -661,6 +691,198 @@ export async function openStackIssue(input, cfg) {
     }
     return { number: row.number, url: typeof row.url === "string" ? row.url : "", created: row.created === true };
 }
+export const ISSUE_REVIEW_STATES = ["approved", "needs_answers", "pending", "unreviewed", "capped", "off"];
+export const ISSUE_REVIEW_MODES = ["off", "mention", "auto"];
+export const ISSUE_REVIEW_TAG = "@mergestorm-vortex";
+export const ISSUE_REVIEW_POLL_INTERVAL_MS = 10_000;
+export const ISSUE_REVIEW_DEFAULT_TIMEOUT_MS = 900_000;
+const ISSUE_REVIEW_MAX_POINTS = 8;
+const ISSUE_REVIEW_DEFAULT_MAX_ROUNDS = 2;
+function issueReviewText(value) {
+    if (typeof value !== "string")
+        return null;
+    const plain = plainServerText(value).trim();
+    return plain ? plain : null;
+}
+export function parseIssueReviewStatus(body, target) {
+    if (!body || typeof body !== "object")
+        return null;
+    const row = body;
+    const state = ISSUE_REVIEW_STATES.find((known) => known === row.state);
+    if (!state)
+        return null;
+    const points = Array.isArray(row.points)
+        ? row.points
+            .flatMap((point) => {
+            const text = issueReviewText(point?.text);
+            if (!text)
+                return [];
+            return [{ kind: issueReviewText(point.kind) ?? "note", text, blocking: point.blocking !== false }];
+        })
+            .slice(0, ISSUE_REVIEW_MAX_POINTS)
+        : [];
+    const verdict = row.verdict === "ready" || row.verdict === "ready_with_notes" || row.verdict === "needs_answers" ? row.verdict : null;
+    return {
+        owner: typeof row.owner === "string" && row.owner ? row.owner : target.owner,
+        repo: typeof row.repo === "string" && row.repo ? row.repo : target.repo,
+        number: isPositiveInteger(row.number) ? row.number : target.number,
+        enabled: row.enabled === true,
+        mode: ISSUE_REVIEW_MODES.find((known) => known === row.mode) ?? (row.enabled === true ? "auto" : "off"),
+        state,
+        approvedBy: row.approvedBy === "vortex" || row.approvedBy === "human" ? row.approvedBy : null,
+        round: isPositiveInteger(row.round) ? row.round : null,
+        maxRounds: isPositiveInteger(row.maxRounds) ? row.maxRounds : ISSUE_REVIEW_DEFAULT_MAX_ROUNDS,
+        verdict,
+        summary: issueReviewText(row.summary),
+        points,
+        commentUrl: issueReviewText(row.commentUrl),
+        next: issueReviewText(row.next) ?? "",
+    };
+}
+export async function getIssueReview(cfg, target, opts = {}) {
+    const query = new URLSearchParams({ owner: target.owner, repo: target.repo }).toString();
+    const { status, body, retryAfterSeconds } = await apiFetch(cfg, `/api/v1/stacks/issues/${encodeURIComponent(String(target.number))}/review?${query}`, opts);
+    if (status === 404) {
+        const message = serverMessage(body?.message);
+        if (!message)
+            return null;
+        throw new CommandError(`${message} Connect it in Mergestorm, then try again.`, 1, "not_found");
+    }
+    if (status === 429) {
+        throw new CommandError(rateLimitedMessage(retryAfterSeconds), REVIEW_EXIT.rate_limited, "rate_limited", retryAfterSeconds !== undefined ? { retryAfterSeconds } : undefined);
+    }
+    const parsed = status === 200 ? parseIssueReviewStatus(body, target) : null;
+    if (!parsed) {
+        const message = serverMessage(body?.message);
+        throw new CommandError(message ?? `Failed to read the issue review of ${target.owner}/${target.repo}#${target.number} (HTTP ${status})`, 1, status >= 500 ? "issue_review_unavailable" : undefined);
+    }
+    return parsed;
+}
+export async function getIssueReviewMode(cfg, target, opts = {}) {
+    const query = new URLSearchParams({ owner: target.owner, repo: target.repo }).toString();
+    const { status, body, retryAfterSeconds } = await apiFetch(cfg, `/api/v1/stacks/issues/review-mode?${query}`, opts);
+    if (status === 404)
+        return null;
+    if (status === 429) {
+        throw new CommandError(rateLimitedMessage(retryAfterSeconds), REVIEW_EXIT.rate_limited, "rate_limited", retryAfterSeconds !== undefined ? { retryAfterSeconds } : undefined);
+    }
+    const mode = status === 200 ? ISSUE_REVIEW_MODES.find((known) => known === body?.mode) : undefined;
+    if (!mode) {
+        const message = serverMessage(body?.message);
+        throw new CommandError(message ?? `Failed to read the issue review mode of ${target.owner}/${target.repo} (HTTP ${status})`);
+    }
+    return mode;
+}
+export function issueReviewSettled(status) {
+    if (status.state === "pending")
+        return false;
+    return !(status.state === "unreviewed" && status.mode === "auto");
+}
+export function issueReviewBlocksPr(status) {
+    return status.mode === "auto" && status.state !== "approved" && status.state !== "off";
+}
+export class IssueReviewTimeoutError extends CommandError {
+    lastStatus;
+    constructor(lastStatus) {
+        super(`Timed out waiting for the Vortex review of ${lastStatus.owner}/${lastStatus.repo}#${lastStatus.number}. Run \`mergestorm issue wait ${lastStatus.number}\` again.`, REVIEW_EXIT.timeout, "review_timeout");
+        this.name = "IssueReviewTimeoutError";
+        this.lastStatus = lastStatus;
+    }
+}
+function abortableSleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const abortError = () => Object.assign(new Error("Aborted"), { name: "AbortError" });
+        if (signal?.aborted) {
+            reject(abortError());
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(abortError());
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function isTransientIssueReviewError(err) {
+    if (!(err instanceof Error) || err.name === "AbortError")
+        return false;
+    if (err instanceof CommandError) {
+        return err.code === "api_timeout" || err.code === "issue_review_unavailable" || err.code === "rate_limited";
+    }
+    return /fetch failed|ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|socket hang up|network/i.test(err.message);
+}
+export async function pollIssueReview(cfg, target, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? ISSUE_REVIEW_DEFAULT_TIMEOUT_MS;
+    const intervalMs = opts.intervalMs ?? ISSUE_REVIEW_POLL_INTERVAL_MS;
+    const now = opts.now ?? Date.now;
+    const wait = opts.sleep ?? abortableSleep;
+    const deadline = now() + timeoutMs;
+    let last = null;
+    let failure = null;
+    for (;;) {
+        try {
+            const status = await getIssueReview(cfg, target, { signal: opts.signal });
+            if (!status || issueReviewSettled(status))
+                return status;
+            last = status;
+            opts.onTick?.(status);
+        }
+        catch (err) {
+            if (!isTransientIssueReviewError(err) || now() >= deadline)
+                throw err;
+            failure = err;
+            opts.onTick?.(null);
+        }
+        const remaining = deadline - now();
+        if (remaining <= 0) {
+            if (last)
+                throw new IssueReviewTimeoutError(last);
+            throw failure;
+        }
+        await wait(Math.min(intervalMs, remaining), opts.signal);
+    }
+}
+export function issueReviewLines(status) {
+    const round = status.round ? ` (round ${status.round} of ${status.maxRounds})` : "";
+    const lines = [`${status.owner}/${status.repo}#${status.number}: ${status.state}${round}`];
+    if (status.summary)
+        lines.push(`  ${status.summary}`);
+    status.points.forEach((point, i) => lines.push(`  ${i + 1}. [${point.blocking === false ? "note: " : ""}${point.kind}] ${point.text}`));
+    if (status.commentUrl)
+        lines.push(`  Review: ${status.commentUrl}`);
+    if (status.next)
+        lines.push(`  Next: ${status.next}`);
+    return lines;
+}
+export function issueNotApprovedError(issues, message) {
+    const lines = [message?.trim() || "Vortex has not approved the linked issue yet; refusing to open the pull request."];
+    for (const issue of issues) {
+        lines.push(...issueReviewLines(issue));
+        const reply = issue.state === "needs_answers" ? `Reply once in a comment on #${issue.number}, accepting each blocking point's suggested fix or saying why not; then run` : "Run";
+        lines.push(`  ${reply} \`mergestorm issue wait ${issue.number}\`.`);
+    }
+    return new CommandError(lines.join("\n"), REVIEW_EXIT.failed, "issue_not_approved", issues.length === 0 ? { reason: NO_LINKED_ISSUE } : undefined);
+}
+export const NO_LINKED_ISSUE = "no_linked_issue";
+export function issueNotApprovedRefusal(status, body, owner, repo) {
+    if (status !== 409 || !body || typeof body !== "object")
+        return null;
+    const refusal = body;
+    if (refusal.error !== "issue_not_approved")
+        return null;
+    const issues = Array.isArray(refusal.issues)
+        ? refusal.issues.flatMap((issue) => {
+            const n = issue?.number;
+            const parsed = parseIssueReviewStatus(issue, { owner, repo, number: isPositiveInteger(n) ? n : 0 });
+            return parsed ? [parsed] : [];
+        })
+        : [];
+    return issueNotApprovedError(issues, serverMessage(refusal.message));
+}
 async function stackMutation(stackId, pathSuffix, method, json, failLabel, cfg) {
     const resolved = cfg ?? (await loadConfig());
     const { status, body } = await apiFetch(resolved, `/api/v1/stacks/${encodeURIComponent(stackId)}${pathSuffix}`, method === "PATCH"

package/dist/automation-catalog.d.ts

@@ -42,6 +42,14 @@ export declare const BEARER_SETTINGS: readonly [{
     readonly key: "vortex_seam_specialist_enabled";
     readonly flag: "--vortex-seam";
     readonly label: "Vortex seam specialist";
+}, {
+    readonly key: "issue_review_enabled";
+    readonly flag: "--issue-review";
+    readonly label: "Vortex issue reviews";
+}, {
+    readonly key: "issue_auto_review_enabled";
+    readonly flag: "--issue-auto-review";
+    readonly label: "Vortex issue auto review";
 }, {
     readonly key: "auto_land_default";
     readonly flag: "--auto-land";
@@ -112,4 +120,4 @@ export type BearerSettingsValues = {
         values: readonly (infer Value)[];
     } ? Value : boolean;
 };
-export declare const BEARER_BOOLEAN_SETTINGS_KEYS: ("auto_review_enabled" | "auto_patch_enabled" | "auto_resolve_conflicts_enabled" | "auto_fix_ci_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "merge_queue_batch_enabled" | "merge_queue_batch_size" | "merge_queue_lands_alone_paths" | "merge_queue_overdrive" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check")[];
+export declare const BEARER_BOOLEAN_SETTINGS_KEYS: ("auto_review_enabled" | "auto_patch_enabled" | "auto_resolve_conflicts_enabled" | "auto_fix_ci_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "issue_review_enabled" | "issue_auto_review_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "merge_queue_batch_enabled" | "merge_queue_batch_size" | "merge_queue_lands_alone_paths" | "merge_queue_overdrive" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check")[];

package/dist/automation-catalog.js

@@ -10,6 +10,8 @@ export const BEARER_SETTINGS = [
     { key: "vortex_auto_overflow_enabled", flag: "--vortex-auto-overflow", label: "Vortex auto overflow" },
     { key: "vortex_skip_all_clear_comments", flag: "--vortex-skip-all-clear", label: "Vortex skip All-clear comments" },
     { key: "vortex_seam_specialist_enabled", flag: "--vortex-seam", label: "Vortex seam specialist" },
+    { key: "issue_review_enabled", flag: "--issue-review", label: "Vortex issue reviews" },
+    { key: "issue_auto_review_enabled", flag: "--issue-auto-review", label: "Vortex issue auto review" },
     { key: "auto_land_default", flag: "--auto-land", label: "Auto land (new stacks)" },
     { key: "auto_land_settle_seconds", flag: "--auto-land-settle", label: "Auto land settle (seconds)", kind: "seconds", min: 15, max: 300 },
     { key: "merge_queue_batch_enabled", flag: "--merge-queue-batch", label: "Merge queue batching" },

package/dist/cli.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { stdin as input, stdout as output } from "node:process";
+import { splitAccountFlag, withAccount } from "./config.js";
 import { CommandError } from "./errors.js";
 import { dispatchCommand, formatUsageBody, } from "./commands/registry.js";
 import { isSupportedNode, unsupportedNodeMessage, } from "./node-version.js";
@@ -17,37 +18,38 @@ function usage() {
 ${formatUsageBody()}
 `);
 }
-async function runCommand(cmd, args) {
+async function runCommand(cmd, args, account) {
     if (cmd === "help" || cmd === "?") {
         usage();
         return;
     }
-    const ok = await dispatchCommand(cmd, args, { mode: "oneshot" });
+    const ok = await dispatchCommand(cmd, args, { mode: "oneshot", account });
     if (!ok) {
         usage();
         throw new CommandError(`unknown command: ${cmd}`);
     }
 }
 async function main() {
-    const [, , cmd, ...args] = process.argv;
-    if (!cmd) {
-        if (input.isTTY && output.isTTY) {
-            await runShell();
+    try {
+        const { account, args: argv } = splitAccountFlag(process.argv.slice(2));
+        const [cmd, ...args] = argv;
+        if (!cmd) {
+            if (input.isTTY && output.isTTY) {
+                await withAccount(account, () => runShell());
+                return;
+            }
+            usage();
             return;
         }
-        usage();
-        return;
-    }
-    if (cmd === "-h" || cmd === "--help" || cmd === "help" || cmd === "?") {
-        usage();
-        return;
-    }
-    if (cmd === "-v" || cmd === "--version" || cmd === "version") {
-        console.log(cliVersion());
-        return;
-    }
-    try {
-        await runCommand(cmd, args);
+        if (cmd === "-h" || cmd === "--help" || cmd === "help" || cmd === "?") {
+            usage();
+            return;
+        }
+        if (cmd === "-v" || cmd === "--version" || cmd === "version") {
+            console.log(cliVersion());
+            return;
+        }
+        await runCommand(cmd, args, account);
     }
     catch (err) {
         if (err instanceof CommandError) {