mergestorm 0.3.61 → 0.3.63

package/dist/stack-blockers.js

@@ -72,10 +72,26 @@ function vortexFindingsRestAtHead(layer) {
 function vortexChangesRequestedAtHead(layer) {
     return vortexFindingsRestAtHead(layer) && layer.reviewStatus === "changes_requested";
 }
-function cycloneHandoffAtHead(stack, layer) {
+export const CYCLONE_NOT_RUN_ATTENTION_MS = 30 * 60_000;
+export const CYCLONE_NOT_RUN_REASON = "not_run";
+function cycloneNotRunAtHead(layer, nowMs) {
+    const review = layer.vortexReview;
+    if (layer.cycloneFindingsTakenAtHead !== false || layer.vortexStatus !== "findings")
+        return false;
+    if (review?.status !== "done" || !sameHead(review.head_sha, layer.headSha))
+        return false;
+    const settledMs = Date.parse(review.settled_at ?? "");
+    return Number.isFinite(settledMs) && nowMs - settledMs >= CYCLONE_NOT_RUN_ATTENTION_MS;
+}
+function cycloneHandoffAtHead(stack, layer, nowMs) {
     if (sameHead(layer.cycloneHandoff?.headSha, layer.headSha))
         return layer.cycloneHandoff.reason;
-    return stack.cyclonePatchOff ?? (stack.autoPatchOverride === false ? "auto_patch_off" : null);
+    if (layer.cycloneStatus === "failed")
+        return "failed";
+    const off = stack.cyclonePatchOff ?? (stack.autoPatchOverride === false ? "auto_patch_off" : null);
+    if (off)
+        return off;
+    return cycloneNotRunAtHead(layer, nowMs) ? CYCLONE_NOT_RUN_REASON : null;
 }
 const CYCLONE_HANDOFF_WORDS = {
     failed: "Cyclone's patch failed, so it pushed nothing",
@@ -93,6 +109,11 @@ const CYCLONE_HANDOFF_WORDS = {
     unsupported_language: "the findings are in a language Cyclone does not patch",
     policy_owner_changed: "the stack's owner changed while the patch was queued",
     patch_job_lost: "Cyclone's patch job was lost before it finished",
+    pr_state_unavailable: "Cyclone could not read the PR's state, so it pushed nothing",
+    left_for_human: "Cyclone did not patch these findings and pushed nothing",
+    hold: "the review told Cyclone to hold, so it did not patch these findings",
+    vortex_patch_cap: "Cyclone already patched this PR as many times as it may",
+    [CYCLONE_NOT_RUN_REASON]: `Cyclone has not run on this head in the ${CYCLONE_NOT_RUN_ATTENTION_MS / 60_000} minutes since Vortex posted these findings, and nothing is patching it`,
     conflict_needs_person: "Cyclone could not resolve the conflict and left it for a person",
     conflict_unresolved: "Cyclone's conflict resolution failed",
     auto_resolve_daily_cap: "Cyclone already resolved conflicts on this PR twice today, its daily cap",
@@ -179,17 +200,27 @@ const CYCLONE_HELD_FINDINGS_REASONS = [
     "pr_state_unavailable",
     "vortex_patch_cap",
     "patch_job_lost",
+    "unsupported_language",
+    "credits_exhausted",
+    "no_billing",
+    "policy_owner_changed",
 ];
 function vortexImportantFindingsHeldAtHead(layer) {
     return vortexFindingsRestAtHead(layer) && layer.reviewStatus === "reviewed" &&
         sameHead(layer.cycloneHandoff?.headSha, layer.headSha) &&
         CYCLONE_HELD_FINDINGS_REASONS.includes(layer.cycloneHandoff.reason);
 }
-function vortexFindingsLeftForPerson(stack, layer) {
+function seamApprovedAtHead(stack, layer) {
+    const member = (stack.unit?.members ?? []).find((entry) => entry.prNumber === layer.prNumber);
+    return member?.seamState?.trim().toLowerCase() === "approved" && sameHead(member.seamReviewedSha, layer.headSha);
+}
+function vortexFindingsLeftForPerson(stack, layer, nowMs) {
     if (layerAgentsBusy(layer).cyclone)
         return false;
+    if (seamApprovedAtHead(stack, layer))
+        return false;
     return vortexImportantFindingsHeldAtHead(layer) ||
-        (vortexChangesRequestedAtHead(layer) && cycloneHandoffAtHead(stack, layer) !== null);
+        (vortexChangesRequestedAtHead(layer) && cycloneHandoffAtHead(stack, layer, nowMs) !== null);
 }
 function quotaSkippedReview(layer) {
     const review = layer.vortexReview;
@@ -304,7 +335,7 @@ function headChecksRerunning(layer) {
     return layer.ciStatus === "pending" && !!checks && checks.failure === 0 && checks.pending > 0 && checks.cancelledOnly !== true;
 }
 /** Shared live-fact precedence; bounce history is only passed for the candidate. */
-function layerAttention(stack, layer, queue, cursor) {
+function layerAttention(stack, layer, queue, cursor, nowMs) {
     const none = { blocker: null, reason: null, bounceKind: null };
     if (stack.archivedAt)
         return none;
@@ -357,7 +388,7 @@ function layerAttention(stack, layer, queue, cursor) {
             if (landing && !landGateIsPending(landing))
                 return hardBlock(landing, "land_gate");
         }
-        if (vortexFindingsLeftForPerson(stack, layer))
+        if (vortexFindingsLeftForPerson(stack, layer, nowMs))
             return hardBlock(VORTEX_FINDINGS_NEED_PERSON, "vortex_findings_need_person");
     }
     if (!bounce || !kind || recoverable || !layer || queue.some((entry) => ["queued", "running", "waiting"].includes(entry.state)))
@@ -494,9 +525,6 @@ export function autoLandWaitLayer(stack) {
 function autoLandWaitOn(stack, layer) {
     return autoLandWaitLayer(stack)?.prNumber === layer.prNumber ? armedAutoLandWait(stack) : null;
 }
-export function autoLandWaitBlocker(stack, layer, nowMs) {
-    return autoLandWaitNamed(stack, layer, nowMs)?.blocker ?? null;
-}
 function autoLandWaitNamed(stack, layer, nowMs) {
     const wait = autoLandWaitOn(stack, layer);
     if (!wait)
@@ -679,7 +707,7 @@ export function agentsCannotClear(reason, stack, layer) {
         return false;
     return AGENTS_CANNOT_CLEAR.includes(reason);
 }
-export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
+export function stackRepair(stack, attention, layer, bounce, queueWait = null, nowMs = Date.now()) {
     if (!attention || !layer || attention.prNumber !== layer.prNumber)
         return null;
     const reason = attention.reason;
@@ -863,7 +891,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
     }
     if (reason === "vortex_findings_need_person") {
         const findings = `gh api repos/${stack.owner}/${stack.repo}/pulls/${layer.prNumber}/reviews`;
-        const handoff = cycloneHandoffAtHead(stack, layer);
+        const handoff = cycloneHandoffAtHead(stack, layer, nowMs);
         return {
             kind: "vortex_findings",
             prNumber: layer.prNumber,
@@ -871,7 +899,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             branch: layer.branch,
             handoff,
             findings,
-            steps: `Vortex ${vortexImportantFindingsHeldAtHead(layer) ? "left Important findings" : "requested changes"} on ${layer.branch} at ${layer.headSha ?? "its live head"} and Cyclone left them for a person${handoff ? ` (${cycloneHandoffWords(handoff, cycloneHandoffDetailAtHead(layer))})` : ""}, so nothing will patch them and Auto land waits. Read the newest Vortex review and its inline comments (${findings}), verify each finding against ${layer.branch} at its live remote head, fix the real ones with the smallest patch, run the tests, confirm the remote head is still ${layer.headSha ?? "the head you started from"}, then an ordinary git push (no force). If a finding is wrong, tell the human; mg dismiss ${stack.owner}/${stack.repo}#${layer.prNumber} --head <sha> --review <id> dismisses that review. Do not retarget the PR base.`,
+            steps: `Vortex ${vortexImportantFindingsHeldAtHead(layer) ? "left Important findings" : "requested changes"} on ${layer.branch} at ${layer.headSha ?? "its live head"} and Cyclone left them undone${handoff ? ` (${cycloneHandoffWords(handoff, cycloneHandoffDetailAtHead(layer))})` : ""}, so nothing will patch them and Auto land waits. You fix them: read the newest Vortex review and its inline comments (${findings}), verify each finding against ${layer.branch} at its live remote head, fix the real ones with the smallest patch, run the tests, confirm the remote head is still ${layer.headSha ?? "the head you started from"}, then an ordinary git push (no force). Dismiss a finding you verified is wrong yourself: mg dismiss ${stack.owner}/${stack.repo}#${layer.prNumber} --head <sha> --review <id> --finding <id> --reason <why> --evidence <link>. Ask the human only for a product or design decision. Do not retarget the PR base.`,
         };
     }
     if (reason === "ci_failed" || attention.bounceKind === "ci_failure") {
@@ -929,6 +957,15 @@ function landPrMissing(stack, candidate) {
         },
     };
 }
+function layerBusy(layer) {
+    if (!layer)
+        return false;
+    const busy = layerAgentsBusy(layer);
+    return busy.cyclone || busy.vortex;
+}
+function sameBlocker(a, b) {
+    return a.prNumber === b.prNumber && a.blocker === b.blocker;
+}
 /** Pair-gate attention plus live hard blocks on every other open layer. */
 export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now()) {
     const candidate = currentLayer(stack);
@@ -946,11 +983,13 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
     let attentionLayer;
     let bounce;
     const issues = [];
+    const found = [];
     const mergeStateUnknownPrs = new Set();
     const queueWait = stack.archivedAt ? null : mergeQueueWait(queue, nowMs);
     for (const layer of open) {
         const selected = layer.prNumber === candidate?.prNumber;
-        let result = layerAttention(stack, layer, selected ? queue : [], cursor);
+        const inScope = selected || !candidate || layer.position > candidate.position;
+        let result = layerAttention(stack, layer, selected ? queue : [], cursor, nowMs);
         let disarmed;
         if (!result.blocker && selected) {
             disarmed = disarmingBounce(stack, queue);
@@ -978,10 +1017,10 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
             result = { blocker: `${MERGE_QUEUE_STALLED_PREFIX}${queueWait.text}`, reason: "queue_stalled", bounceKind: null };
         }
         if (!result.blocker) {
-            if (vortexRetryScheduled(layer) && (selected || !candidate || layer.position > candidate.position)) {
+            if (vortexRetryScheduled(layer) && inScope) {
                 issues.push({ prNumber: layer.prNumber, headSha: layer.headSha ?? null, blocker: VORTEX_RETRY_SCHEDULED, bounceKind: null });
             }
-            if (mergeabilityPending(layer) && (selected || !candidate || layer.position > candidate.position)) {
+            if (mergeabilityPending(layer) && inScope) {
                 mergeStateUnknownPrs.add(layer.prNumber);
                 issues.push({ prNumber: layer.prNumber, headSha: layer.headSha ?? null,
                     blocker: `Merge state unknown${layer.parentBranch ? ` vs ${layer.parentBranch}` : ""}`, bounceKind: null });
@@ -990,6 +1029,9 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
         }
         const issue = { prNumber: layer.prNumber, headSha: layer.headSha ?? null,
             blocker: result.blocker, bounceKind: result.bounceKind };
+        if (inScope || result.reason === "unit_abandoned" || layer === child || waitNamed) {
+            found.push({ issue, reason: result.reason, layer, bounce: result.bounce });
+        }
         if (selected ||
             result.reason === "unit_abandoned" ||
             (!attention && (layer === child || waitNamed))) {
@@ -1001,7 +1043,7 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
                 issues.push({ prNumber: disarmed.bounceDetail?.prNumber ?? layer.prNumber,
                     headSha: disarmed.bounceDetail?.headSha ?? null, blocker: mergeQueueBounceLabel(disarmed), bounceKind: result.bounceKind });
         }
-        else if (!candidate || layer.position > candidate.position)
+        else if (inScope)
             issues.push(issue);
     }
     if (!attention) {
@@ -1011,6 +1053,7 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
             attention = { prNumber: unlisted.prNumber, headSha: unlisted.headSha ?? null, blocker: waiting.blocker, bounceKind: null };
             attentionReason = waiting.reason;
             attentionLayer = unlisted;
+            found.push({ issue: attention, reason: waiting.reason, layer: unlisted, bounce: undefined });
         }
     }
     const queued = queueWait && candidate && !queueWait.stalled
@@ -1025,13 +1068,15 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
         attention = landMissing.attention;
         attentionReason = landMissing.reason;
         attentionLayer = undefined;
+        found.unshift({ issue: landMissing.attention, reason: landMissing.reason, layer: undefined, bounce: undefined,
+            repair: landMissing.repair });
     }
     const classified = attention && attentionReason
         ? { ...attention, reason: attentionReason }
         : null;
     const focus = attentionLayer ?? candidate;
-    const agents = focus ? layerAgents(focus) : null;
-    const busy = [];
+    let agents = focus ? layerAgents(focus) : null;
+    let busy = [];
     if (attention && agents) {
         for (const agent of ["cyclone", "vortex"]) {
             if (agents.busy[agent])
@@ -1045,17 +1090,39 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
     const landGatePending = landLayer && landing && landGateIsPending(landing)
         ? { prNumber: landLayer.prNumber, headSha: landLayer.headSha ?? null, reason: landing }
         : null;
+    let held = null;
+    let shownIssues = issues;
+    let repair;
     if (busy.length && attention && classified && agentsCannotClear(classified.reason, stack, attentionLayer)) {
-        const held = { ...attention, actAfter: "agents_idle", waitingOn: busy.map((entry) => entry.agent) };
-        return { attention: null, held, issues: [attention, ...issues], currentCandidate, bounce: undefined, busy, agents,
-            repair: stackRepair(stack, classified, attentionLayer, undefined, queueWait), landGatePending, queueWait: queued };
+        held = { ...attention, actAfter: "agents_idle", waitingOn: busy.map((entry) => entry.agent) };
+        shownIssues = [attention, ...issues];
+        repair = stackRepair(stack, classified, attentionLayer, undefined, queueWait, nowMs);
+        attention = null;
+        bounce = undefined;
     }
-    if (busy.length) {
-        return { attention: null, held: null, issues, currentCandidate, bounce: undefined, busy, agents, repair: null, landGatePending,
-            queueWait: queued };
+    else if (busy.length) {
+        repair = null;
+        attention = null;
+        bounce = undefined;
+    }
+    else {
+        repair = landMissing?.repair ?? stackRepair(stack, classified, attentionLayer, bounce, queueWait, nowMs);
+    }
+    if (!attention) {
+        const next = found.find((item) => !layerBusy(item.layer));
+        if (next) {
+            attention = next.issue;
+            repair = next.repair !== undefined
+                ? next.repair
+                : stackRepair(stack, { ...next.issue, reason: next.reason }, next.layer, next.bounce, queueWait, nowMs);
+            bounce = next.bounce;
+            if (next.layer)
+                agents = layerAgents(next.layer);
+            busy = [];
+            shownIssues = shownIssues.filter((issue) => !sameBlocker(issue, next.issue));
+        }
     }
-    return { attention, held: null, issues, currentCandidate, bounce, busy, agents,
-        repair: landMissing?.repair ?? stackRepair(stack, classified, attentionLayer, bounce, queueWait), landGatePending,
+    return { attention, held, issues: shownIssues, currentCandidate, bounce, busy, agents, repair, landGatePending,
         queueWait: queued };
 }
 function mergeabilitySettleIssue(stack, open, mergeStateUnknownPrs, attention) {

package/dist/stack-dto.d.ts

@@ -59,6 +59,7 @@ export type StackVortexReviewView = {
     phase: string | null;
     /** Earliest live job start while `reviewing`; null when lease-only. */
     started_at: string | null;
+    settled_at?: string | null;
     /** Stop control visibility: true only while a pass can actually be cancelled. */
     stoppable: boolean;
     /** Which table spoke: the authority row, a live job, a lease, or nothing. */
@@ -225,6 +226,7 @@ export type StackLayerDto = {
     cycloneConflictPendingSince?: string | null;
     cycloneCiHandoff?: StackCycloneHandoff | null;
     cycloneCiPendingSince?: string | null;
+    cycloneFindingsTakenAtHead?: boolean;
     conflictDetail: string | null;
     restackError?: RestackError | null;
     lastRestackedSha: string | null;

package/dist/stack-meta.d.ts

@@ -19,8 +19,6 @@ export type StackMeta = {
     /** Index into `stacks` for create/submit. */
     active: number;
 };
-/** Exported only for legacy migration/tests. New state never uses this path. */
-export declare const STACK_META_REL: string;
 export declare function stackMetaPath(cwd?: string, stacksRoot?: string): string;
 export declare function loadStackMeta(cwd?: string, stacksRoot?: string): Promise<StackMeta | null>;
 export declare function emptyStackMeta(trunk: string): StackMeta;

package/dist/stack-meta.js

@@ -3,11 +3,10 @@
  * Stored outside repositories under ~/.mergestorm/stacks/<repo-id>/.
  */
 import { randomUUID } from "node:crypto";
-import { chmod, copyFile, mkdir, readFile, readdir, rename, rm, rmdir, unlink, writeFile, } from "node:fs/promises";
+import { chmod, mkdir, readFile, readdir, rename, rm, writeFile, } from "node:fs/promises";
 import path from "node:path";
 import { CommandError, isCommandErrorCode } from "./errors.js";
-import { git } from "./git.js";
-import { cliStacksRoot, gitTopLevel, LEGACY_STACK_META_REL, legacyStackMetaPath, repoStateDir, stackMetaPath as resolveStackMetaPath, } from "./repo-identity.js";
+import { cliStacksRoot, stackMetaPath as resolveStackMetaPath, } from "./repo-identity.js";
 const LOCAL_STACK_FLAGS = [
     "autoEnqueueWhenReady",
     "autoReviewOverride",
@@ -15,8 +14,6 @@ const LOCAL_STACK_FLAGS = [
     "autoResolveConflictsOverride",
     "autoFixCiOverride",
 ];
-/** Exported only for legacy migration/tests. New state never uses this path. */
-export const STACK_META_REL = LEGACY_STACK_META_REL;
 export function stackMetaPath(cwd = process.cwd(), stacksRoot = cliStacksRoot()) {
     return resolveStackMetaPath(cwd, stacksRoot);
 }
@@ -64,17 +61,6 @@ function normalizeMeta(raw) {
         }
         return { version: 2, trunk: obj.trunk, stacks, active };
     }
-    if (obj.version === 1) {
-        if (!Array.isArray(obj.layers) || !obj.layers.every(isLayer)) {
-            throw new Error("Stack authoring state has malformed legacy layers; run `mg stack reset --force` to clear it.");
-        }
-        return {
-            version: 2,
-            trunk: obj.trunk,
-            stacks: [{ layers: obj.layers }],
-            active: 0,
-        };
-    }
     throw new Error("Stack authoring state has an unknown version; run `mg stack reset --force` to clear it.");
 }
 function parseStateJson(raw) {
@@ -96,71 +82,17 @@ async function readIfExists(file) {
         throw err;
     }
 }
-async function removeLegacyFile(file, cwd = process.cwd(), force = false) {
-    const top = gitTopLevel(cwd);
-    const rel = path.relative(top, file);
-    try {
-        git(["rm", "-f", "--", rel], top);
-    }
-    catch (err) {
-        // Fall back to a plain unlink only for untracked files; otherwise the
-        // index entry would remain after the worktree copy is gone.
-        if (git(["ls-files", "--", rel], top).trim() !== "") {
-            if (!force) {
-                throw new Error(`git rm failed for tracked ${rel}: ${err instanceof Error ? err.message : String(err)}`);
-            }
-            git(["update-index", "--force-remove", "--", rel], top);
-        }
-        await unlink(file);
-    }
-    try {
-        await rmdir(path.dirname(file));
-    }
-    catch {
-        // Leave a non-empty .mergestorm directory untouched.
-    }
-}
 export async function loadStackMeta(cwd = process.cwd(), stacksRoot = cliStacksRoot()) {
     const file = stackMetaPath(cwd, stacksRoot);
-    const legacyFile = legacyStackMetaPath(cwd);
     const raw = await readIfExists(file);
-    const legacyRaw = await readIfExists(legacyFile);
     if (raw !== null) {
         const meta = normalizeMeta(parseStateJson(raw));
         if (meta === null) {
             throw new CommandError("Stack authoring state is not an object; run `mg stack reset --force` to clear it.");
         }
-        if (legacyRaw !== null) {
-            const stateDir = repoStateDir(cwd, stacksRoot);
-            const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-            const backup = path.join(stateDir, `legacy-conflict-${stamp}.json`);
-            try {
-                await mkdir(stateDir, { recursive: true, mode: 0o700 });
-                await chmod(stateDir, 0o700);
-                await copyFile(legacyFile, backup);
-                await chmod(backup, 0o600);
-                await removeLegacyFile(legacyFile, cwd);
-            }
-            catch (err) {
-                throw new CommandError(`Failed to preserve legacy stack state${err instanceof Error ? `: ${err.message}` : ""}; run \`mg stack reset --force\` to clear it.`);
-            }
-            console.warn(`Warning: global stack state already existed; preserved legacy state at ${backup}.`);
-        }
         return meta;
     }
-    if (legacyRaw === null)
-        return null;
-    const migrated = normalizeMeta(parseStateJson(legacyRaw));
-    if (!migrated)
-        return null;
-    try {
-        await saveStackMeta(migrated, cwd, stacksRoot);
-        await removeLegacyFile(legacyFile, cwd);
-    }
-    catch (err) {
-        throw new CommandError(`Failed to migrate legacy stack state${err instanceof Error ? `: ${err.message}` : ""}; run \`mg stack reset --force\` to clear it.`);
-    }
-    return migrated;
+    return null;
 }
 export function emptyStackMeta(trunk) {
     return {
@@ -225,10 +157,8 @@ export async function saveStackMeta(meta, cwd = process.cwd(), stacksRoot = cliS
 /** Explicit recovery. Does not touch branches, PRs, or registered server stacks. */
 export async function resetStackMeta(cwd = process.cwd(), stacksRoot = cliStacksRoot()) {
     let stateFile;
-    let legacyFile;
     try {
         stateFile = stackMetaPath(cwd, stacksRoot);
-        legacyFile = legacyStackMetaPath(cwd);
     }
     catch (err) {
         // Outside a worktree / deleted main repo: reset is a no-op (nothing to clear).
@@ -238,14 +168,6 @@ export async function resetStackMeta(cwd = process.cwd(), stacksRoot = cliStacks
         throw err;
     }
     await rm(stateFile, { force: true });
-    try {
-        await removeLegacyFile(legacyFile, cwd, true);
-    }
-    catch (err) {
-        const code = err?.code;
-        if (code !== "ENOENT")
-            throw err;
-    }
 }
 export function appendLayer(meta, layer) {
     const current = activeLayers(meta);

package/dist/stack-watch-loop.js

@@ -1,6 +1,7 @@
 import { setTimeout as sleep } from "node:timers/promises";
 import { API_TIMEOUT_PREFIX, DEFAULT_API_TIMEOUT_MS, LandedQueueReadError, readLandedQueueEntry } from "./api.js";
 import { isTransientReviewPollError } from "./commands/review-client.js";
+import { stackWatchBackgroundCommand } from "./stack-watch-obligation.js";
 import { pollStackWatch, StackWatchError, StackWatchTimeoutError, } from "./stack-watch.js";
 export const STACK_WATCH_MARKER = "MS-WATCH";
 export const STACK_WATCH_EXIT = { landed: 0, attention: 3, timeout: 5 };
@@ -30,7 +31,9 @@ export function stackWatchAttentionKey(envelope) {
     return `${envelope.prNumber ?? ""}|${envelope.headSha ?? ""}|${blockerWithoutElapsedMinutes(envelope.blocker)}`;
 }
 export function stackWatchAttentionLine(envelope) {
-    return `${STACK_WATCH_MARKER} ATTENTION pr=${envelope.prNumber ?? "none"} head=${envelope.headSha ?? "none"} blocker=${JSON.stringify(envelope.blocker ?? "")} repair=${envelope.repair?.kind ?? "none"}`;
+    const restart = envelope.cursor.bounceId
+        ? ` restart=${JSON.stringify(stackWatchBackgroundCommand(envelope.stackId, envelope.cursor))}` : "";
+    return `${STACK_WATCH_MARKER} ATTENTION pr=${envelope.prNumber ?? "none"} head=${envelope.headSha ?? "none"} blocker=${JSON.stringify(envelope.blocker ?? "")} repair=${envelope.repair?.kind ?? "none"}${restart}`;
 }
 export function stackWatchLandedLine(envelope) {
     return `${STACK_WATCH_MARKER} LANDED stack=${envelope.stackId} reason=${envelope.watch.reason}`;

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

@@ -1,7 +1,10 @@
 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 declare function stackWatchBackgroundCommand(stackId: string, cursor?: {
+    afterFinishedAt?: string | null;
+    bounceId?: string | null;
+} | null): string;
 export type StackWatchDoneReason = "landed" | "closed" | "archived" | "not_found";
 export type StackWatchReason = StackWatchDoneReason | "open" | "attention" | "unread" | "rate_limited" | "failed" | "landing_unconfirmed";
 export type StackWatchNextArgs = {

package/dist/stack-watch-obligation.js

@@ -1,7 +1,10 @@
 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}`;
+function shellArg(value) {
+    return /^[A-Za-z0-9_./:@%+=,-]+$/.test(value) ? value : `'${value.replace(/'/g, `'\\''`)}'`;
+}
+export function stackWatchBackgroundCommand(stackId, cursor) {
+    return `mg stack watch ${shellArg(stackId)}${cursor?.bounceId ? ` --bounce-id ${shellArg(cursor.bounceId)}` : ""}${cursor?.afterFinishedAt ? ` --after-finished-at ${shellArg(cursor.afterFinishedAt)}` : ""}`;
 }
 const DONE_MESSAGES = {
     landed: "This stack is landed. The watch is done; stop calling stack_wait for it.",
@@ -53,7 +56,7 @@ export function stackWatchObligation(input) {
         : input.status === "failed"
             ? "failed"
             : input.attention ? "attention" : input.unread ? "unread" : "open";
-    const background = stackWatchBackgroundCommand(input.stackId);
+    const background = stackWatchBackgroundCommand(input.stackId, input.cursor);
     const parts = [
         STACK_WATCH_NOT_DONE_SENTENCE,
         `If your host has a confirmed notification that resumes this task, run \`${background}\` as a background command, notify on output matching ${STACK_WATCH_NOTIFY_PATTERN}, and end your turn. The command monitors the stack; it cannot wake an agent by itself, and a process left running is not a notification. Without a confirmed notification, keep using stack_wait with the returned cursor, or report that automatic follow-up is unavailable before ending the turn.`,
@@ -66,7 +69,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, or start \`${background} --head <pushed-sha>\` in the background.`);
+        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.${input.cursor?.bounceId ? ` If you handle it without a push (for example by turning Auto land back on), start \`${background}\` so this bounce is not reported again.` : ""}`);
     }
     else if (reason === "unread") {
         parts.push("This tool did not read the stack's state; stack_wait will.");

package/dist/stack-watch.js

@@ -154,8 +154,9 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
                 ...(bounce.finishedAt !== undefined ? { afterFinishedAt: bounce.finishedAt } : {}) });
         const held = busy[0];
         const shown = attention ?? named;
+        const waitingNamed = attention ? null : named;
         lastEnvelope = { ...lastEnvelope, cursor, issues, currentCandidate, assessment: "available", busy, agents, repair, landGatePending, queueWait,
-            actAfter: named?.actAfter ?? null, waitingOn: named?.waitingOn ?? [],
+            actAfter: waitingNamed?.actAfter ?? null, waitingOn: waitingNamed?.waitingOn ?? [],
             blocker: shown?.blocker ?? null, bounceKind: shown?.bounceKind ?? null,
             prNumber: shown?.prNumber ?? held?.prNumber ?? currentCandidate?.prNumber ?? null,
             headSha: shown ? shown.headSha : held ? held.headSha : currentCandidate?.headSha ?? null,

package/dist/ui/banner.js

@@ -221,6 +221,12 @@ const WHATS_NEW = {
     "0.3.61": [
         "Watch names a job Cyclone's push skips",
     ],
+    "0.3.62": [
+        "Watch wakes for a blocker on any layer",
+    ],
+    "0.3.63": [
+        "Stack create starts a new stack unless --extend",
+    ],
 };
 function densityFromVariant(variant) {
     if (variant === "mini" || variant === "nano")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm",
-  "version": "0.3.61",
+  "version": "0.3.63",
   "description": "Mergestorm CLI (mg) — local reviews & stacked PRs. MIT; build from source: https://github.com/marginsystems/mergestorm-cli",
   "license": "MIT",
   "type": "module",
@@ -20,7 +20,14 @@
   },
   "exports": {
     ".": "./dist/cli.js",
-    "./client": "./dist/client/index.js"
+    "./client": {
+      "mergestorm-source": "./src/client/index.ts",
+      "default": "./dist/client/index.js"
+    },
+    "./skill": {
+      "mergestorm-source": "./src/commands/skill.ts",
+      "default": "./dist/commands/skill.js"
+    }
   },
   "homepage": "https://mergestorm.ai/docs#review-jobs-api",
   "repository": {

package/skill/SKILL.md

@@ -48,7 +48,7 @@ Cursor `~/.cursor/mcp.json`:
 
 ## Preconditions
 
-1. Prefer the `mergestorm` MCP server. Call `whoami`. If MCP is missing, require `mg` on PATH with `mg whoami --json` exit 0. If neither is available, stop and print the install one-liner above.
+1. Prefer the `mergestorm` MCP server. Call `whoami`. If MCP is missing, require `mg` on PATH with `mg whoami --json` exit 0. If neither is available, stop and print the install one-liner above. A hosted connection to the Mergestorm MCP server, the kind a chat agent uses, has no `review_submit`: it cannot read your checkout. With only that connection, tell the human that this review runs where the branch is checked out, with `mg` or a local MCP server, and stop. Do not install `mg` yourself to get around it.
 2. Call `credits` (or `mg credits --json`). If remaining standard credits are 0, say so and stop.
 
 Ignored bot authors live in Settings → Vortex ("Ignore bot PR authors"), not Agents. Local `review_submit` is a manual review and is not an ignore-list skip.