mergestorm 0.3.29 → 0.3.30

package/README.md

@@ -45,7 +45,7 @@ On a TTY, bare `mergestorm` (or `mergestorm shell`) opens a branded REPL: a comp
 
 ```
 ╭──────────────────────────────────────────────────────────────────────────────╮
-│  ▀▀▀▀▀▀▀▀▀▀▘  mergestorm v0.3.29                                             │
+│  ▀▀▀▀▀▀▀▀▀▀▘  mergestorm v0.3.30                                             │
 │ ▀▀▀▀▀▀▀▀▀     ● msk_live_… · maelstrom                                       │
 │  ▀▀▀▀▀▀       [████████░░░░░░░░░░░░░░░░░░░░░░] 25% used                      │
 │   ▝▀▀▀▀▀      local reviews + stacked PRs · mergestorm.ai                    │
@@ -114,7 +114,7 @@ mergestorm dismiss <owner/repo>#<n> --head <sha> --review <id> --finding <id> --
 - `--ignore <text>` keeps it silent on the first attention whose blocker contains that text (case-insensitive), until the blocker, its PR or its head changes. Use it for a blocker a human has taken over. Repeat the flag for more than one.
 - `--until landed` keeps running after an attention, printing each new attention once, and exits only when the watch is done or reads keep failing.
 - `--max <minutes>` caps the whole watch; when it runs out it prints `MS-WATCH TIMEOUT` and exits 5. The stack is not landed then.
-- `--json` adds the full `mergestorm.stack_watch/v1` envelope as one JSON line after each marker line.
+- `--json` writes exactly one JSON document to stdout: the final `mergestorm.stack_watch/v1` envelope, or `{ stackId, outcome }` when there is none (a repeated failed read, `--max` timeout, or abort). The MS-WATCH marker lines go to stderr, so do not merge the streams (2>&1) before parsing stdout.
 
 ```bash
 mg stack watch 11111111-1111-4111-8111-111111111111 --head "$(git rev-parse HEAD)"

package/dist/commands/stack.js

@@ -56,6 +56,7 @@ const STACK_USAGE = `usage:
     Loops stack wait with the cursor and stays silent while the stack is waiting or in progress.
     Prints one MS-WATCH ATTENTION line and exits 3 on attention or a repeated failed read; prints
     MS-WATCH LANDED and exits 0 once the watch is done. Run it as a background command.
+    --json writes exactly one JSON document to stdout and sends the MS-WATCH lines to stderr.
   mergestorm stack set <stack-id> [--auto-land on|off] [--auto-review on|off|default] [--auto-patch on|off|default] [--json]
   mergestorm stack adopt <owner/repo>#<pr> [--auto-land on|off] [--auto-review on|off] [--auto-patch on|off] [--json]
   mergestorm stack restack <stack-id> [--json]

package/dist/stack-dto.d.ts

@@ -392,6 +392,11 @@ export type MergeQueueBounceDetail = {
     conflictPaths?: string[];
     message?: string;
     warning?: string;
+    batch?: MergeQueueBounceBatch;
+};
+export type MergeQueueBounceBatch = {
+    id: string;
+    withPrNumbers: number[];
 };
 export type MergeQueueBatchState = "verifying" | "landing" | "landed" | "stopped" | "bounced" | "abandoned";
 export type MergeQueueEntryBatchDto = {

package/dist/stack-dto.js

@@ -84,7 +84,11 @@ export function mergeQueueBounceLabel(entry) {
             (detail?.conflictPaths?.length ? detail.conflictPaths.join(", ") : null) ??
             detail?.message ??
             (detail?.prNumber != null ? `PR #${detail.prNumber}` : null);
-        return specifics ? `${kindLabel} — ${specifics}` : kindLabel;
+        const withPrNumbers = detail?.batch?.withPrNumbers ?? [];
+        const batch = withPrNumbers.length
+            ? ` in a red batch with ${withPrNumbers.map((prNumber) => `#${prNumber}`).join(", ")}`
+            : "";
+        return specifics ? `${kindLabel} — ${specifics}${batch}` : `${kindLabel}${batch}`;
     }
     return entry.bounceReason?.trim() || "bounced";
 }

package/dist/stack-watch-loop.d.ts

@@ -20,6 +20,7 @@ export type RunStackWatchOptions = {
     cursor?: StackWatchCursor;
     signal?: AbortSignal;
     write?: (line: string) => void;
+    writeMarker?: (line: string) => void;
     poll?: typeof pollStackWatch;
     sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
     now?: () => number;

package/dist/stack-watch-loop.js

@@ -29,14 +29,15 @@ export async function runStackWatch(cfg, stackId, opts = {}) {
     const until = opts.until ?? "attention";
     const ignore = opts.ignore ?? [];
     const write = opts.write ?? ((line) => console.log(line));
+    const writeMarker = opts.json ? opts.writeMarker ?? ((line) => console.error(line)) : write;
     const poll = opts.poll ?? pollStackWatch;
     const now = opts.now ?? Date.now;
     const wait = opts.sleep ?? ((ms, signal) => sleep(ms, undefined, { signal }));
     const deadline = opts.maxMs !== undefined ? now() + opts.maxMs : Number.POSITIVE_INFINITY;
-    const emit = (line, envelope) => {
-        write(line);
-        if (opts.json && envelope)
-            write(JSON.stringify(envelope));
+    const emit = (line, envelope, outcome) => {
+        writeMarker(line);
+        if (opts.json && outcome)
+            write(JSON.stringify(envelope ?? { stackId: id, outcome }));
     };
     const pause = async (ms) => {
         const remaining = Math.min(ms, Math.max(0, deadline - now()));
@@ -48,7 +49,7 @@ export async function runStackWatch(cfg, stackId, opts = {}) {
     const ignoredKeys = new Map();
     let reportedKey = null;
     const landed = (envelope) => {
-        emit(stackWatchLandedLine(envelope), envelope);
+        emit(stackWatchLandedLine(envelope), envelope, "landed");
         if (!opts.json)
             write(envelope.watch.message);
         return { outcome: "landed", exitCode: STACK_WATCH_EXIT.landed, envelope };
@@ -56,7 +57,7 @@ export async function runStackWatch(cfg, stackId, opts = {}) {
     const failed = async (message, envelope) => {
         failures += 1;
         if (failures >= 2) {
-            emit(stackWatchFailedLine(id, message), envelope);
+            emit(stackWatchFailedLine(id, message), envelope, "failed");
             return { outcome: "failed", exitCode: STACK_WATCH_EXIT.attention, envelope };
         }
         await pause(STACK_WATCH_FAILED_RETRY_MS);
@@ -106,7 +107,7 @@ export async function runStackWatch(cfg, stackId, opts = {}) {
                 }
                 const silent = [...ignoredKeys.values()].includes(key) || key === reportedKey;
                 if (!silent) {
-                    emit(stackWatchAttentionLine(envelope), envelope);
+                    emit(stackWatchAttentionLine(envelope), envelope, until === "attention" ? "attention" : null);
                     if (until === "attention")
                         return { outcome: "attention", exitCode: STACK_WATCH_EXIT.attention, envelope };
                     reportedKey = key;
@@ -116,10 +117,13 @@ export async function runStackWatch(cfg, stackId, opts = {}) {
         }
     }
     catch (err) {
-        if (isAbort(err, opts.signal))
+        if (isAbort(err, opts.signal)) {
+            if (opts.json)
+                write(JSON.stringify({ stackId: id, outcome: "aborted" }));
             return { outcome: "aborted", exitCode: 130, envelope: null };
+        }
         throw err;
     }
-    emit(stackWatchTimeoutLine(id, opts.maxMs ?? 0), null);
+    emit(stackWatchTimeoutLine(id, opts.maxMs ?? 0), null, "timeout");
     return { outcome: "timeout", exitCode: STACK_WATCH_EXIT.timeout, envelope: null };
 }

package/dist/ui/banner.js

@@ -120,6 +120,9 @@ const WHATS_NEW = {
     "0.3.29": [
         "mg stack watch waits in the background",
     ],
+    "0.3.30": [
+        "stack watch --json prints one JSON document",
+    ],
 };
 function densityFromVariant(variant) {
     if (variant === "mini" || variant === "nano")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm",
-  "version": "0.3.29",
+  "version": "0.3.30",
   "description": "Mergestorm CLI (mg) — local reviews & stacked PRs. MIT; build from source: https://github.com/marginsystems/mergestorm-cli",
   "license": "MIT",
   "type": "module",

package/skill/mergestorm-bounce-watch/SKILL.md

@@ -20,7 +20,7 @@ If your host cannot hold a long turn open (Cursor, Claude Code, Codex, and other
    - `MS-WATCH ATTENTION pr=<n> head=<sha> blocker="<blocker>" repair=<kind>` (exit 3): the watch returned `attention`.
    - `MS-WATCH ATTENTION failed stack=<id> error="<message>"` (exit 3): a read failed and its one retry failed too.
    - `MS-WATCH LANDED stack=<id> reason=<reason>` (exit 0): `watch.done` is `true`. Only `reason=landed` is a landed stack; for `closed`, `archived`, or `not_found`, follow "Not done until landed".
-   With `--max <minutes>` it can also stop with `MS-WATCH TIMEOUT` (exit 5). The stack is not landed then; start the watcher again. `--json` adds the full envelope as one JSON line after the marker line.
+   With `--max <minutes>` it can also stop with `MS-WATCH TIMEOUT` (exit 5). The stack is not landed then; start the watcher again. `--json` writes exactly one JSON document to stdout: the final `mergestorm.stack_watch/v1` envelope, or `{ stackId, outcome }` when there is no envelope (a repeated failed read, timeout, or abort). MS-WATCH marker lines go to stderr; do not merge the streams before parsing stdout.
 3. When it wakes you on `MS-WATCH ATTENTION pr=`, call `stack_status` once for that stack, then fix the blocker as steps 3 to 7 of "Watch and patch" say, push, and start the watcher again with `--head` set to the SHA you pushed. On `MS-WATCH ATTENTION failed`, the watcher already retried once: tell the human the stack is not landed and is no longer being watched.
 4. When the human has taken one blocker over and asked you to keep watching the rest, pass `--ignore <blocker-substring>`. The watcher stays silent on the first attention whose blocker contains that text until the blocker, its PR, or its head changes; any other attention still wakes you.
 5. `--until landed` keeps the watcher running after an attention: it prints each new attention line once and exits only when the watch is done or a read fails twice. Use it only when your host streams output lines to you while the command runs.