mergestorm 0.3.29 → 0.3.31

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.31                                             │
 │ ▀▀▀▀▀▀▀▀▀     ● 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)"
@@ -129,7 +129,7 @@ Use `mergestorm dismiss` when a Vortex finding is wrong and you have checked it
 - Retrying the same dismissal is safe; it reports the earlier record.
 - The seam gate clears only when every finding of that integration review is dismissed and the review is still the current seam verdict. CI, other reviews and Auto land policy still apply.
 - Vortex does not raise a dismissed finding again on the same diff (the same head, or a restack with an unchanged diff).
-- With `--json`, the result carries `gate` and, for a stack PR, `watch.next` (the next `stack_wait` call).
+- With `--json`, the result carries `gate` and, for a stack PR, `watch.next` (the next `stack_wait` call, plus `watch.next.background`, the `mg stack watch` command to run in the background instead).
 
 `mg` is a short alias for `mergestorm` (same binary), e.g. `mg stack create`. Happy path: **create → commit → submit → restack → land**. On review-unit stacks, `stack land` **promotes** the tip into the unit (same gates as the dashboard); otherwise it lands the bottom open PR. `stack adopt` is for importing a chain that already exists on GitHub (legacy / Graphite). Restack/land use the same login key (`/api/v1/stacks`). Unattended landing is `mg queue add`.
 

package/dist/api.d.ts

@@ -29,6 +29,13 @@ export declare function devicePost(base: string, route: string, json: unknown, o
     status: number;
     body: any;
 }>;
+export type SurgeUsage = {
+    includedMinutes: number;
+    usedMinutes: number;
+    walletMinutes: number;
+    windowStart: string;
+    pricePerMinuteUsd: number;
+};
 export type MeResponse = {
     key: {
         prefix: string;
@@ -50,6 +57,7 @@ export type MeResponse = {
         bonus?: {
             remaining: number;
         };
+        surge?: SurgeUsage;
     };
 };
 export type JobListItem = {

package/dist/client/index.d.ts

@@ -8,4 +8,4 @@ export { discoverTrunk } from "../git-stack.js";
 export { BOUNCE_KIND_LABELS, deriveStackAgentsBusy, mergeQueueBounceLabel, type StackAgentsBusy } from "../stack-dto.js";
 export { STACK_WATCH_SCHEMA, STACK_WATCH_DEFAULT_TIMEOUT_MS, STACK_WATCH_BUSY_RECHECK_S, StackWatchError, StackWatchTimeoutError, pollStackWatch, type PollStackWatchOptions, type StackWatchCursor, type StackWatchEnvelope, } from "../stack-watch.js";
 export { stackBlockers, stackBlockersSummary, sameHead, layerAgents, layerAgentsBusy, conflictLiveParent, stackRepair, agentsCannotClear, type StackAgentBusy, type StackBlocker, type StackBusyAgent, type StackHeldBlocker, type StackLandGatePending, type StackLayerAgents, type StackRepairHint, } from "../stack-blockers.js";
-export { STACK_WATCH_NOT_DONE_SENTENCE, stackTerminalReason, stackWatchNextArgs, stackWatchObligation, type StackWatchDoneReason, type StackWatchNext, type StackWatchNextArgs, type StackWatchObligation, type StackWatchObligationInput, type StackWatchReason, } from "../stack-watch-obligation.js";
+export { STACK_WATCH_NOT_DONE_SENTENCE, STACK_WATCH_NOTIFY_PATTERN, stackWatchBackgroundCommand, stackTerminalReason, stackWatchNextArgs, stackWatchObligation, type StackWatchDoneReason, type StackWatchNext, type StackWatchNextArgs, type StackWatchObligation, type StackWatchObligationInput, type StackWatchReason, } from "../stack-watch-obligation.js";

package/dist/client/index.js

@@ -8,4 +8,4 @@ export { discoverTrunk } from "../git-stack.js";
 export { BOUNCE_KIND_LABELS, deriveStackAgentsBusy, mergeQueueBounceLabel } from "../stack-dto.js";
 export { STACK_WATCH_SCHEMA, STACK_WATCH_DEFAULT_TIMEOUT_MS, STACK_WATCH_BUSY_RECHECK_S, StackWatchError, StackWatchTimeoutError, pollStackWatch, } from "../stack-watch.js";
 export { stackBlockers, stackBlockersSummary, sameHead, layerAgents, layerAgentsBusy, conflictLiveParent, stackRepair, agentsCannotClear, } from "../stack-blockers.js";
-export { STACK_WATCH_NOT_DONE_SENTENCE, stackTerminalReason, stackWatchNextArgs, stackWatchObligation, } from "../stack-watch-obligation.js";
+export { STACK_WATCH_NOT_DONE_SENTENCE, STACK_WATCH_NOTIFY_PATTERN, stackWatchBackgroundCommand, stackTerminalReason, stackWatchNextArgs, stackWatchObligation, } from "../stack-watch-obligation.js";

package/dist/commands/browse.js

@@ -221,6 +221,7 @@ export async function openTabsBrowser(initial) {
                 used: me.usage.standard.used,
                 limit: me.usage.standard.limit,
                 bonusRemaining: me.usage.bonus?.remaining,
+                surge: me.usage.surge,
                 resetsAt: me.resets_at,
                 jobs: jobs.slice(0, 5).map(toPanelJob),
                 jobsError: jobsError ?? undefined,

package/dist/commands/credits.js

@@ -37,6 +37,7 @@ export async function cmdCredits(args) {
         used: s.used,
         limit: s.limit,
         bonusRemaining: me.usage.bonus?.remaining,
+        surge: me.usage.surge,
         resetsAt: me.resets_at,
         jobs: recentJobs.map(toPanelJob),
         columns,

package/dist/commands/dismiss.js

@@ -120,7 +120,7 @@ export function formatDismissResult(result, watch) {
                 : `Seam gate: not blocking (seam_state=${seam.state}).`);
     }
     if (watch?.next)
-        lines.push(`Next: ${watch.next.command}`);
+        lines.push(`Next: ${watch.next.background} as a background command, or ${watch.next.command}`);
     return lines.join("\n");
 }
 export async function cmdDismiss(args, deps = {}) {

package/dist/commands/stack.js

@@ -1,5 +1,5 @@
 import { stackBlockers, stackBlockersSummary } from "../stack-blockers.js";
-import { STACK_WATCH_NOT_DONE_SENTENCE, stackTerminalReason, stackWatchObligation, } from "../stack-watch-obligation.js";
+import { STACK_WATCH_NOT_DONE_SENTENCE, STACK_WATCH_NOTIFY_PATTERN, stackTerminalReason, stackWatchObligation, } from "../stack-watch-obligation.js";
 import { adoptStack, ensureUpperPark, findStackPull, getEnrichedStack, landNextStack, listStacks, openStackPull, restackStack, setStackPolicy, } from "../api.js";
 import { loadConfig } from "../config.js";
 import { rateLimitedMessage, REVIEW_EXIT, CommandError } from "../errors.js";
@@ -36,7 +36,10 @@ export function stackWatchTextLines(watch) {
         return [watch.message];
     const next = watch.next;
     return [
-        ...(next ? [`Next: ${next.command} (MCP: stack_wait ${JSON.stringify(next.args)})`] : []),
+        ...(next ? [
+            `Next: ${next.background} as a background command (notify on ${STACK_WATCH_NOTIFY_PATTERN}, then end your turn)`,
+            `Or poll: ${next.command} (MCP: stack_wait ${JSON.stringify(next.args)})`,
+        ] : []),
         STACK_WATCH_NOT_DONE_SENTENCE,
     ];
 }
@@ -56,6 +59,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/stack-watch-obligation.d.ts

@@ -1,5 +1,7 @@
 import type { StackDto } from "./stack-dto.js";
 export declare const STACK_WATCH_NOT_DONE_SENTENCE = "This stack is not landed. Your task is not done. Call stack_wait again with this cursor.";
+export declare const STACK_WATCH_NOTIFY_PATTERN = "MS-WATCH (ATTENTION|LANDED)";
+export declare function stackWatchBackgroundCommand(stackId: string): string;
 export type StackWatchDoneReason = "landed" | "closed" | "archived" | "not_found";
 export type StackWatchReason = StackWatchDoneReason | "open" | "attention" | "unread" | "rate_limited" | "failed";
 export type StackWatchNextArgs = {
@@ -13,6 +15,7 @@ export type StackWatchNext = {
     tool: "stack_wait";
     args: StackWatchNextArgs;
     command: string;
+    background: string;
 };
 export type StackWatchObligation = {
     done: boolean;

package/dist/stack-watch-obligation.js

@@ -1,4 +1,8 @@
 export const STACK_WATCH_NOT_DONE_SENTENCE = "This stack is not landed. Your task is not done. Call stack_wait again with this cursor.";
+export const STACK_WATCH_NOTIFY_PATTERN = "MS-WATCH (ATTENTION|LANDED)";
+export function stackWatchBackgroundCommand(stackId) {
+    return `mg stack watch ${stackId}`;
+}
 const DONE_MESSAGES = {
     landed: "This stack is landed. The watch is done; stop calling stack_wait for it.",
     closed: "Every PR in this stack is merged or closed and nothing is left to land, but not every PR landed. The watch is done; tell the human which PRs were closed without landing.",
@@ -49,8 +53,10 @@ export function stackWatchObligation(input) {
         : input.status === "failed"
             ? "failed"
             : input.attention ? "attention" : input.unread ? "unread" : "open";
+    const background = stackWatchBackgroundCommand(input.stackId);
     const parts = [
         STACK_WATCH_NOT_DONE_SENTENCE,
+        `If you cannot hold a long turn open, run \`${background}\` as a background command instead, notify on output matching ${STACK_WATCH_NOTIFY_PATTERN}, and end your turn: it keeps calling stack_wait for you, stays silent while the stack waits, and wakes you on attention or when the watch is done.`,
         `Watch stack ${input.stackId} as a whole until it lands or the human takes it back. A clean push, a submit, or one merged layer does not finish it: merging a lower layer can break a layer above it.`,
     ];
     if (reason === "rate_limited") {
@@ -60,7 +66,7 @@ export function stackWatchObligation(input) {
         parts.push(`This read failed, which does not end the task. Call stack_wait once more with the same cursor; if that fails too, tell the human that stack ${input.stackId} is not landed and is no longer being watched.`);
     }
     else if (reason === "attention" && input.attention) {
-        parts.push(`First fix #${input.attention.prNumber} (${input.attention.blocker}); repair, when present, names the fix. Calling stack_wait again before fixing it returns the same attention. After your push, call stack_wait with this cursor and enrolled_head_sha set to the SHA you pushed.`);
+        parts.push(`First fix #${input.attention.prNumber} (${input.attention.blocker}); repair, when present, names the fix. Calling stack_wait again before fixing it returns the same attention. After your push, call stack_wait with this cursor and enrolled_head_sha set to the SHA you pushed, or start \`${background} --head <pushed-sha>\` in the background.`);
     }
     else if (reason === "unread") {
         parts.push("This tool did not read the stack's state; stack_wait will.");
@@ -73,7 +79,7 @@ export function stackWatchObligation(input) {
         done: false,
         until: "landed",
         reason,
-        next: { tool: "stack_wait", args, command: `mg stack wait ${input.stackId} --json` },
+        next: { tool: "stack_wait", args, command: `mg stack wait ${input.stackId} --json`, background },
         message: parts.join(" "),
     };
 }

package/dist/ui/banner.js

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

package/dist/ui/usage.d.ts

@@ -24,6 +24,12 @@ export declare function formatResetLabel(iso: string | null | undefined, now?: D
 export declare function formatDaysLeft(iso: string | null | undefined, now?: Date): string;
 /** Bar cells so `  [bar] 100% used` stays inside the terminal. */
 export declare function usageBarWidth(columns: number): number;
+export type SurgeUsageSummary = {
+    includedMinutes: number;
+    usedMinutes: number;
+    walletMinutes: number;
+};
+export declare function formatSurgeSummary(surge: SurgeUsageSummary): string;
 export type UsagePanelJob = {
     job: string;
     verdict: string;
@@ -37,6 +43,7 @@ export type UsagePanelInput = {
     used: number;
     limit: number | null;
     bonusRemaining?: number;
+    surge?: SurgeUsageSummary;
     resetsAt: string | null | undefined;
     jobs: UsagePanelJob[];
     /** When the jobs fetch failed, show this instead of "No review jobs yet." */

package/dist/ui/usage.js

@@ -87,6 +87,16 @@ export function formatDaysLeft(iso, now = new Date()) {
 export function usageBarWidth(columns) {
     return Math.max(8, frameWidth(80, columns) - 13);
 }
+function formatMinutes(value) {
+    return value.toLocaleString("en-US", { maximumFractionDigits: 1 });
+}
+export function formatSurgeSummary(surge) {
+    const wallet = `wallet ${formatMinutes(surge.walletMinutes)} min`;
+    if (surge.includedMinutes <= 0)
+        return `Surge: ${wallet}`;
+    return (`Surge: ${formatMinutes(surge.usedMinutes)} of ${formatMinutes(surge.includedMinutes)} included min this period` +
+        ` · ${wallet}`);
+}
 function clipLine(line, columns) {
     if (visibleWidth(line) <= columns)
         return line;
@@ -111,6 +121,7 @@ export function formatUsagePanel(input) {
         ...(input.bonusRemaining == null
             ? []
             : [`  Bonus credits: ${input.bonusRemaining} remaining`]),
+        ...(input.surge ? [`  ${formatSurgeSummary(input.surge)}`] : []),
         "",
     ];
     if (input.jobs.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm",
-  "version": "0.3.29",
+  "version": "0.3.31",
   "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

@@ -15,12 +15,12 @@ A stack watch is done only when the stack is landed, or when the human takes it
 
 If your host cannot hold a long turn open (Cursor, Claude Code, Codex, and other turn-based agents), do not poll `stack_wait` inside your turn and do not subscribe to GitHub events. Hand the waiting to the CLI watcher:
 
-1. Run `mg stack watch <stack-id>` as a background command (add `--head <sha>` right after you pushed that SHA) with a notification on output matching `MS-WATCH (ATTENTION|LANDED)`, then end your turn. The watcher runs the same stack wait against the Mergestorm API in slices of at most 300s, carries the cursor (`enrolled_head_sha`, `after_finished_at`, `bounce_id`) from one slice to the next, and prints nothing while the stack is `waiting` or `in_progress`, including `busy[]` holds and `actAfter: "agents_idle"`. It spends no model tokens while it waits. Ending your turn while it runs is not ending the task.
+1. Run `mg stack watch <stack-id>` as a background command (add `--head <sha>` right after you pushed that SHA) with a notification on output matching `MS-WATCH (ATTENTION|LANDED)`, then end your turn. The watcher runs the same stack wait against the Mergestorm API in slices of at most 300s, carries the cursor (`enrolled_head_sha`, `after_finished_at`, `bounce_id`) from one slice to the next, and prints nothing while the stack is `waiting` or `in_progress`, including `busy[]` holds and `actAfter: "agents_idle"`. It spends no model tokens while it waits. Ending your turn while it runs is not ending the task. Every `watch.next` carries this command as `watch.next.background`.
 2. It prints one line and exits for one of three reasons:
    - `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.