mergestorm 0.3.64 → 0.3.67

package/dist/server-publish.d.ts

@@ -1,27 +1,10 @@
-import { getStackPublication, submitStackPublication, type StackPublication, type StackPublicationChange, type StackPublicationCommit, type StackPublicationIdentity, type StackPublicationStatus } from "./api.js";
+import { getStackPublication, submitStackPublication, type StackPublication, type StackPublicationCommit, type StackPublicationStatus } from "./api.js";
 import { loadConfig, type Config } from "./config.js";
 import { discoverTrunk } from "./git-stack.js";
-export declare const SERVER_PUBLISH_MAX_COMMITS = 20;
-export declare const SERVER_PUBLISH_MAX_CHANGES = 500;
 export declare const SERVER_PUBLISH_MAX_FILE_BYTES: number;
-export declare const SERVER_PUBLISH_MAX_TOTAL_BYTES: number;
-export declare const SERVER_PUBLISH_MAX_COMMIT_BYTES: number;
-export declare const SERVER_PUBLISH_FILE_MODES: readonly ["100644", "100755", "120000"];
-export declare const SERVER_PUBLISH_HISTORY_SCAN = 500;
 export type GitRead = (args: string[], cwd: string) => Buffer | Promise<Buffer>;
 export declare const READ_ONLY_GIT: Set<string>;
 export declare function readGit(args: string[], cwd: string): Buffer;
-export declare function readCommitHeader(read: GitRead, sha: string, cwd: string): Promise<{
-    tree: string;
-    parents: string[];
-    author: StackPublicationIdentity;
-    committer: StackPublicationIdentity;
-    message: string;
-}>;
-export declare function readCommitChanges(read: GitRead, parent: string, sha: string, cwd: string, budget: {
-    changes: number;
-    bytes: number;
-}): Promise<StackPublicationChange[]>;
 export declare function readPublicationCommits(read: GitRead, from: string, to: string, cwd: string): Promise<StackPublicationCommit[]>;
 export type ServerPublishInput = {
     cfg: Config;
@@ -73,12 +56,6 @@ export declare function assertExplicitStacking(input: {
     stackCommand: string;
     trunkCommand: string;
 }): void;
-export declare function workingBranchTarget(input: WorkingBranchInput): {
-    cwd: string;
-    owner: string;
-    repo: string;
-    branch: string;
-};
 export declare function publishWorkingBranch(input: WorkingBranchInput, deps?: WorkingBranchDeps): Promise<ServerPublishResult & {
     stacked: boolean;
 }>;

package/dist/server-publish.js

@@ -5,13 +5,13 @@ import { CommandError, isCommandErrorCode } from "./errors.js";
 import { parseGithubOriginRepo } from "./git.js";
 import { currentBranch, discoverTrunk, tipCommitMessage, tipCommitSubject } from "./git-stack.js";
 import { buildPrBodyFromCommit } from "./pr-body.js";
-export const SERVER_PUBLISH_MAX_COMMITS = 20;
-export const SERVER_PUBLISH_MAX_CHANGES = 500;
+const SERVER_PUBLISH_MAX_COMMITS = 20;
+const SERVER_PUBLISH_MAX_CHANGES = 500;
 export const SERVER_PUBLISH_MAX_FILE_BYTES = 2 * 1024 * 1024;
-export const SERVER_PUBLISH_MAX_TOTAL_BYTES = 8 * 1024 * 1024;
-export const SERVER_PUBLISH_MAX_COMMIT_BYTES = 1024 * 1024;
-export const SERVER_PUBLISH_FILE_MODES = ["100644", "100755", "120000"];
-export const SERVER_PUBLISH_HISTORY_SCAN = 500;
+const SERVER_PUBLISH_MAX_TOTAL_BYTES = 8 * 1024 * 1024;
+const SERVER_PUBLISH_MAX_COMMIT_BYTES = 1024 * 1024;
+const SERVER_PUBLISH_FILE_MODES = ["100644", "100755", "120000"];
+const SERVER_PUBLISH_HISTORY_SCAN = 500;
 export const READ_ONLY_GIT = new Set(["cat-file", "diff-tree", "merge-base", "rev-list", "rev-parse", "symbolic-ref"]);
 export function readGit(args, cwd) {
     if (!READ_ONLY_GIT.has(args[0] ?? "")) {
@@ -56,7 +56,7 @@ function parseIdentity(line, sha) {
     }
     return { name: match[1].trim() ? match[1] : match[2], email: match[2], date };
 }
-export async function readCommitHeader(read, sha, cwd) {
+async function readCommitHeader(read, sha, cwd) {
     const commitBytes = Number(await text(read, ["cat-file", "-s", sha], cwd));
     if (commitBytes > SERVER_PUBLISH_MAX_COMMIT_BYTES) {
         throw new CommandError(`Commit ${sha} is ${commitBytes} bytes; server-side publication reads commits up to ${SERVER_PUBLISH_MAX_COMMIT_BYTES} bytes.`, 1, "payload_too_large");
@@ -91,7 +91,7 @@ export async function readCommitHeader(read, sha, cwd) {
     }
     return { tree, parents, author: parseIdentity(author, sha), committer: parseIdentity(committer, sha), message };
 }
-export async function readCommitChanges(read, parent, sha, cwd, budget) {
+async function readCommitChanges(read, parent, sha, cwd, budget) {
     const listing = await read(["diff-tree", "-r", "-z", "--raw", "--no-renames", "--no-commit-id", "--abbrev=40", parent, sha], cwd);
     let raw;
     try {
@@ -244,7 +244,7 @@ export function assertExplicitStacking(input) {
         `• Stack onto \`${input.parent}\`: ${input.stackCommand}\n` +
         `• New stack from \`${input.trunk}\`: ${input.trunkCommand}`, 1, "implicit_stack");
 }
-export function workingBranchTarget(input) {
+function workingBranchTarget(input) {
     const cwd = input.cwd ?? process.cwd();
     const origin = input.owner && input.repo ? { owner: input.owner, repo: input.repo } : parseGithubOriginRepo(cwd);
     if (!origin) {

package/dist/stack-blockers.d.ts

@@ -6,8 +6,8 @@ export type StackBlocker = {
     blocker: string;
     bounceKind: string | null;
 };
-export type StackBlockerReason = "restack_conflict" | "restack_failed" | "draft_pr" | "merge_conflict" | "ci_failed" | "vortex_failed" | "vortex_out_of_quota" | "vortex_skipped" | "vortex_findings_need_person" | "seam_failed" | "seam_findings" | "seam_not_running" | "seam_review_stuck" | "seam_rereview_not_running" | "seam_verdict_stale" | "unit_abandoned" | "land_gate" | "bounce" | "auto_land_off" | "auto_land_switched_off" | "auto_land_ci_pending" | "auto_land_members_remaining" | "auto_land_vortex_wait" | "auto_land_promote_failed" | "auto_land_ci_unreadable" | "auto_land_waited" | "queue_stalled" | "land_pr_missing";
-export type ClassifiedStackBlocker = StackBlocker & {
+export type StackBlockerReason = "restack_conflict" | "restack_failed" | "draft_pr" | "merge_conflict" | "ci_failed" | "vortex_failed" | "vortex_out_of_quota" | "vortex_skipped" | "vortex_findings_need_person" | "seam_failed" | "seam_findings" | "seam_not_running" | "seam_review_stuck" | "seam_rereview_not_running" | "seam_verdict_stale" | "unit_abandoned" | "land_gate" | "bounce" | "auto_land_off" | "auto_land_switched_off" | "auto_land_ci_pending" | "auto_land_members_remaining" | "auto_land_vortex_wait" | "auto_land_promote_failed" | "auto_land_ci_unreadable" | "auto_land_waited" | "queue_stalled" | "cyclone_stalled" | "land_pr_missing";
+type ClassifiedStackBlocker = StackBlocker & {
     reason: StackBlockerReason;
 };
 export type StackAgentBusy = {
@@ -113,6 +113,14 @@ export type StackRepairHint = {
     since: string;
     reason: string;
     steps: string;
+} | {
+    kind: "cyclone_stalled";
+    prNumber: number;
+    headSha: string | null;
+    branch: string;
+    runSha: string | null;
+    since: string | null;
+    steps: string;
 } | {
     kind: "queue_stalled";
     prNumber: number;
@@ -159,42 +167,14 @@ export type StackLandGatePending = {
 export declare function landGateIsPending(reason: string | null | undefined): boolean;
 export declare function layerAgentsBusy(layer: StackLayerDto): StackAgentsBusy;
 export declare function layerAgents(layer: StackLayerDto): StackLayerAgents;
-export declare function isMgParkBase(branch: string | null | undefined): boolean;
-/** GitHub DIRTY vs an mg-park-* freeze is not a merge conflict, verified or not. */
-export declare function boundDirty(layer: StackLayerDto): boolean;
-export declare function mergeabilityPending(layer: StackLayerDto): boolean;
 export declare function sameHead(a: string | null | undefined, b: string | null | undefined): boolean;
 export declare function currentLayer(stack: StackDto): StackLayerDto | undefined;
-export declare const RESTACK_FAILED = "Restack failed";
-export declare const SEAM_REVIEW_NOT_RUNNING = "Seam review pending, no review running";
-export declare const VORTEX_REVIEW_OUT_OF_QUOTA = "Review skipped, out of review quota";
-export declare const SEAM_REVIEW_STUCK = "Seam review stuck in reviewing, no review running";
-export declare const SEAM_REREVIEW_NOT_RUNNING = "Seam re-review pending, no review running";
-export declare const SEAM_VERDICT_STALE = "Seam verdict is for an older head, no review running";
 export declare const VORTEX_FINDINGS_NEED_PERSON = "Vortex findings need a person";
-export declare const CYCLONE_NOT_RUN_ATTENTION_MS: number;
-export declare const CYCLONE_NOT_RUN_REASON = "not_run";
 export declare function cycloneStatusWords(layer: Pick<StackLayerDto, "cycloneStatus" | "cycloneHandoff" | "headSha">): string | null;
 export declare function autoResolveActive(stack: StackDto, layer: StackLayerDto): boolean;
 export declare function autoFixCiActive(stack: StackDto, layer: StackLayerDto): boolean;
 export declare const CI_DID_NOT_FINISH_BLOCKER = "CI did not finish \u2014 left for a person";
-export declare function pendingCiLeftForPerson(stack: StackDto, layer: StackLayerDto): boolean;
-export declare const VORTEX_AUTO_REVIEW_OFF = "Vortex auto-review is off, so this head was not reviewed";
-export declare const VORTEX_BILLING_SKIPPED = "Vortex skipped this head: it could not confirm billing";
-export declare const VORTEX_REVIEW_INCOMPLETE = "Vortex reviewed only part of this PR";
-export declare const VORTEX_IGNORED_AUTHOR = "Vortex skipped this head: the PR author is on the ignored authors list";
-export declare const VORTEX_REPO_DISABLED = "Vortex skipped this head: reviews are turned off for this repository";
-export declare const VORTEX_RETRY_SCHEDULED = "Vortex hit a temporary error on this head and will retry by itself";
-export declare const VORTEX_REVIEW_FAILED = "Review failed";
-export declare function vortexRetryScheduled(layer: StackLayerDto): boolean;
-export declare const AUTO_LAND_CI_PENDING_ATTENTION_MS: number;
-export declare const AUTO_LAND_VORTEX_WAIT_ATTENTION_MS: number;
-export declare const AUTO_LAND_PROMOTE_FAILED_ATTEMPTS = 3;
-export declare const AUTO_LAND_CI_FAILED_BLOCKER = "CI failed \u2014 Auto land reads a failing check on GitHub at this head";
-export declare const AUTO_LAND_WAIT_ATTENTION_MS: number;
-export declare const AUTO_LAND_CI_UNREADABLE_ATTENTION_MS: number;
-export declare function autoLandWaitLayer(stack: StackDto): StackLayerDto | undefined;
-export declare const MERGE_QUEUE_STALL_ATTENTION_MS: number;
+export declare const CYCLONE_STALLED_PREFIX = "Cyclone stalled: ";
 export type StackQueueWait = {
     prNumber: number;
     headSha: string | null;
@@ -216,15 +196,8 @@ export declare function mergeQueueWait(queue: readonly MergeQueueEntryDto[], now
 export declare function conflictLiveParent(stack: StackDto, layer: StackLayerDto): string | null;
 export declare function conflictRepairSteps(branch: string, liveParent: string | null): string;
 export declare const BREEZE_BRANCH_PREFIX = "breeze/";
-export declare function isBreezeBranch(branch: string | null | undefined): boolean;
-export declare function breezeConflictRepairSteps(branch: string, liveParent: string | null, prNumber: number): string;
-export declare function restackFailedRepairSteps(branch: string, liveParent: string | null, failure: {
-    kind: string;
-    detail?: string | null;
-}, prNumber?: number): string;
 export declare function agentsCannotClear(reason: StackBlockerReason, stack?: StackDto, layer?: StackLayerDto): boolean;
 export declare function stackRepair(stack: StackDto, attention: ClassifiedStackBlocker | null, layer: StackLayerDto | undefined, bounce: MergeQueueEntryDto | undefined, queueWait?: MergeQueueWait | null, nowMs?: number): StackRepairHint | null;
-export declare const LAND_PR_MISSING_PREFIX = "No open land PR for ";
 /** Pair-gate attention plus live hard blocks on every other open layer. */
 export declare function stackBlockers(stack: StackDto, entries?: MergeQueueEntryDto[], cursor?: Pick<StackWatchCursor, "bounceId" | "afterFinishedAt">, nowMs?: number): {
     attention: StackBlocker | null;
@@ -243,3 +216,4 @@ export declare function stackBlockers(stack: StackDto, entries?: MergeQueueEntry
 };
 /** Compact contract text shared by status and wait summaries. */
 export declare function stackBlockersSummary(attention: Pick<StackBlocker, "prNumber" | "blocker"> | null, issues: StackBlocker[], busy?: readonly StackAgentBusy[], landGatePending?: Pick<StackLandGatePending, "prNumber" | "reason"> | null, actAfter?: StackHeldBlocker["actAfter"] | null, queueWait?: Pick<StackQueueWait, "prNumber" | "text"> | null): string;
+export {};

package/dist/stack-blockers.js

@@ -1,4 +1,4 @@
-import { CYCLONE_CI_FIX_HELD_REASON, CYCLONE_FIX_HELD_REASON, deriveStackAgentsBusy, mergeQueueBounceLabel, restackRetryPending, } from "./stack-dto.js";
+import { CYCLONE_CI_FIX_HELD_REASON, CYCLONE_FIX_HELD_REASON, deriveStackAgentsBusy, mergeQueueBounceLabel, restackRetryPending, STACK_AGENT_PATCHING_STALE_MS, stalledCycloneRun, } from "./stack-dto.js";
 export function landGateIsPending(reason) {
     const token = reason?.trim().replace(/^landing blocked:\s*/i, "").match(/^[a-z_]+/i)?.[0] ?? "";
     return /_(?:pending|running)$/i.test(token);
@@ -18,11 +18,11 @@ export function layerAgents(layer) {
         busy: { vortex: busy.vortex, cyclone: busy.cyclone },
     };
 }
-export function isMgParkBase(branch) {
+function isMgParkBase(branch) {
     return (branch ?? "").trim().toLowerCase().startsWith("mg-park-");
 }
 /** GitHub DIRTY vs an mg-park-* freeze is not a merge conflict, verified or not. */
-export function boundDirty(layer) {
+function boundDirty(layer) {
     if (isMgParkBase(layer.parentBranch))
         return false;
     if (layer.mergeable == null)
@@ -30,7 +30,7 @@ export function boundDirty(layer) {
     return (!layer.headSha || layer.mergeableHeadSha === layer.headSha) &&
         (layer.mergeable === false || layer.mergeableState?.toLowerCase() === "dirty");
 }
-export function mergeabilityPending(layer) {
+function mergeabilityPending(layer) {
     if (isMgParkBase(layer.parentBranch))
         return false;
     return layer.mergeable == null && !!layer.headSha && layer.mergeableHeadSha === layer.headSha &&
@@ -51,12 +51,12 @@ export function currentLayer(stack) {
     return promote[0] ?? open.find((layer) => layer.prNumber === stack.unit?.landPrNumber) ??
         (land && land.prNumber > 0 && land.state !== "merged" && land.state !== "closed" ? land : undefined);
 }
-export const RESTACK_FAILED = "Restack failed";
-export const SEAM_REVIEW_NOT_RUNNING = "Seam review pending, no review running";
-export const VORTEX_REVIEW_OUT_OF_QUOTA = "Review skipped, out of review quota";
-export const SEAM_REVIEW_STUCK = "Seam review stuck in reviewing, no review running";
-export const SEAM_REREVIEW_NOT_RUNNING = "Seam re-review pending, no review running";
-export const SEAM_VERDICT_STALE = "Seam verdict is for an older head, no review running";
+const RESTACK_FAILED = "Restack failed";
+const SEAM_REVIEW_NOT_RUNNING = "Seam review pending, no review running";
+const VORTEX_REVIEW_OUT_OF_QUOTA = "Review skipped, out of review quota";
+const SEAM_REVIEW_STUCK = "Seam review stuck in reviewing, no review running";
+const SEAM_REREVIEW_NOT_RUNNING = "Seam re-review pending, no review running";
+const SEAM_VERDICT_STALE = "Seam verdict is for an older head, no review running";
 const STUCK_SEAM_REASONS = ["seam_review_stuck", "seam_rereview_not_running", "seam_verdict_stale"];
 function coreReviewDoneAtHead(layer) {
     const review = layer.vortexReview;
@@ -72,8 +72,8 @@ function vortexFindingsRestAtHead(layer) {
 function vortexChangesRequestedAtHead(layer) {
     return vortexFindingsRestAtHead(layer) && layer.reviewStatus === "changes_requested";
 }
-export const CYCLONE_NOT_RUN_ATTENTION_MS = 30 * 60_000;
-export const CYCLONE_NOT_RUN_REASON = "not_run";
+const CYCLONE_NOT_RUN_ATTENTION_MS = 30 * 60_000;
+const CYCLONE_NOT_RUN_REASON = "not_run";
 function cycloneNotRunAtHead(layer, nowMs) {
     const review = layer.vortexReview;
     if (layer.cycloneFindingsTakenAtHead !== false || layer.vortexStatus !== "findings")
@@ -109,6 +109,7 @@ 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",
+    run_deadline: "Cyclone's patch ran past its time limit and stopped without pushing",
     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",
@@ -175,7 +176,7 @@ export function autoFixCiActive(stack, layer) {
         !sameHead(layer.cycloneCiHandoff?.headSha, layer.headSha);
 }
 export const CI_DID_NOT_FINISH_BLOCKER = "CI did not finish — left for a person";
-export function pendingCiLeftForPerson(stack, layer) {
+function pendingCiLeftForPerson(stack, layer) {
     return layer.ciStatus === "pending" && layer.checks?.cancelledOnly === true &&
         sameHead(layer.checks.namedRunsCompleteHeadSha, layer.headSha) && !isLandPrLayer(stack, layer) &&
         sameHead(layer.cycloneCiHandoff?.headSha, layer.headSha);
@@ -200,6 +201,7 @@ const CYCLONE_HELD_FINDINGS_REASONS = [
     "pr_state_unavailable",
     "vortex_patch_cap",
     "patch_job_lost",
+    "run_deadline",
     "unsupported_language",
     "credits_exhausted",
     "no_billing",
@@ -227,13 +229,13 @@ function quotaSkippedReview(layer) {
     return review?.status === "skipped" && review.skip_reason === "quota_exceeded" &&
         sameHead(review.head_sha, layer.headSha);
 }
-export const VORTEX_AUTO_REVIEW_OFF = "Vortex auto-review is off, so this head was not reviewed";
-export const VORTEX_BILLING_SKIPPED = "Vortex skipped this head: it could not confirm billing";
-export const VORTEX_REVIEW_INCOMPLETE = "Vortex reviewed only part of this PR";
-export const VORTEX_IGNORED_AUTHOR = "Vortex skipped this head: the PR author is on the ignored authors list";
-export const VORTEX_REPO_DISABLED = "Vortex skipped this head: reviews are turned off for this repository";
-export const VORTEX_RETRY_SCHEDULED = "Vortex hit a temporary error on this head and will retry by itself";
-export const VORTEX_REVIEW_FAILED = "Review failed";
+const VORTEX_AUTO_REVIEW_OFF = "Vortex auto-review is off, so this head was not reviewed";
+const VORTEX_BILLING_SKIPPED = "Vortex skipped this head: it could not confirm billing";
+const VORTEX_REVIEW_INCOMPLETE = "Vortex reviewed only part of this PR";
+const VORTEX_IGNORED_AUTHOR = "Vortex skipped this head: the PR author is on the ignored authors list";
+const VORTEX_REPO_DISABLED = "Vortex skipped this head: reviews are turned off for this repository";
+const VORTEX_RETRY_SCHEDULED = "Vortex hit a temporary error on this head and will retry by itself";
+const VORTEX_REVIEW_FAILED = "Review failed";
 const VORTEX_SKIP_BLOCKERS = {
     auto_review_off: VORTEX_AUTO_REVIEW_OFF,
     billing_blocked: VORTEX_BILLING_SKIPPED,
@@ -241,7 +243,7 @@ const VORTEX_SKIP_BLOCKERS = {
     ignored_author: VORTEX_IGNORED_AUTHOR,
     repo_disabled: VORTEX_REPO_DISABLED,
 };
-export function vortexRetryScheduled(layer) {
+function vortexRetryScheduled(layer) {
     const review = layer.vortexReview;
     const reason = review?.skip_reason?.trim();
     return (reason === "retry_scheduled" || reason === "post_delayed") && sameHead(review?.head_sha, layer.headSha);
@@ -388,6 +390,9 @@ function layerAttention(stack, layer, queue, cursor, nowMs) {
             if (landing && !landGateIsPending(landing))
                 return hardBlock(landing, "land_gate");
         }
+        const stalled = stalledCycloneRun(layer, nowMs);
+        if (stalled)
+            return hardBlock(cycloneStalledBlocker(stalled, nowMs), "cyclone_stalled");
         if (vortexFindingsLeftForPerson(stack, layer, nowMs))
             return hardBlock(VORTEX_FINDINGS_NEED_PERSON, "vortex_findings_need_person");
     }
@@ -408,6 +413,11 @@ function layerAttention(stack, layer, queue, cursor, nowMs) {
     return { blocker: label, reason: "bounce", bounceKind: kind, bounce };
 }
 const UNIT_ABANDONED_BLOCKER_PREFIX = "Review unit abandoned: based on ";
+export const CYCLONE_STALLED_PREFIX = "Cyclone stalled: ";
+function cycloneStalledBlocker(run, nowMs) {
+    const minutes = Math.floor((nowMs - Date.parse(run.startedAt ?? "")) / 60_000);
+    return `${CYCLONE_STALLED_PREFIX}patching ${run.sha?.slice(0, 7) ?? "this PR"} for ${minutes}m with no push or result`;
+}
 function unitAbandonedUnder(stack, layer) {
     if (stack.unit?.state !== "abandoned")
         return false;
@@ -447,15 +457,15 @@ function switchedOffByAnotherActor(stack) {
     const reason = stack.autoLandOff?.reason;
     return reason && AUTO_LAND_SWITCHED_OFF_BY[reason] ? reason : undefined;
 }
-export const AUTO_LAND_CI_PENDING_ATTENTION_MS = 45 * 60_000;
-export const AUTO_LAND_VORTEX_WAIT_ATTENTION_MS = 30 * 60_000;
-export const AUTO_LAND_PROMOTE_FAILED_ATTEMPTS = 3;
-export const AUTO_LAND_CI_FAILED_BLOCKER = "CI failed — Auto land reads a failing check on GitHub at this head";
+const AUTO_LAND_CI_PENDING_ATTENTION_MS = 45 * 60_000;
+const AUTO_LAND_VORTEX_WAIT_ATTENTION_MS = 30 * 60_000;
+const AUTO_LAND_PROMOTE_FAILED_ATTEMPTS = 3;
+const AUTO_LAND_CI_FAILED_BLOCKER = "CI failed — Auto land reads a failing check on GitHub at this head";
 const AUTO_LAND_CI_PENDING_PREFIX = "CI pending for ";
 const AUTO_LAND_VORTEX_WAIT_PREFIX = "No green Vortex review for ";
 const AUTO_LAND_PROMOTE_FAILED_PREFIX = "Promote failed ";
-export const AUTO_LAND_WAIT_ATTENTION_MS = 45 * 60_000;
-export const AUTO_LAND_CI_UNREADABLE_ATTENTION_MS = 10 * 60_000;
+const AUTO_LAND_WAIT_ATTENTION_MS = 45 * 60_000;
+const AUTO_LAND_CI_UNREADABLE_ATTENTION_MS = 10 * 60_000;
 const AUTO_LAND_CI_UNREADABLE_PREFIX = "Mergestorm cannot read ";
 const AUTO_LAND_WAITED_PREFIX = "Auto land has waited ";
 const AUTO_LAND_MEMBERS_REMAINING_PREFIX = "The land PR cannot be queued: ";
@@ -477,6 +487,8 @@ const AUTO_LAND_WAIT_WORDS = {
     missing_head: "GitHub returned no head commit for this PR",
     pr_draft: "this PR is a draft",
     trunk_in_land_target_without_land_pr: "the stack's commits are already in the land target, but no merged land PR was found",
+    land_pr_push_unreviewed: "someone other than Stacks pushed to the stack trunk, and the land PR has no clean Vortex review at that push or at its head",
+    land_pr_head_unexplained: "GitHub's activity list for the stack trunk does not show the push that made the land PR head",
     conflict_unchanged: "the merge queue bounced this PR for a conflict, and neither the PR nor its base has changed since",
     land_pr_unavailable: "the land PR cannot be opened or found",
     github_unreadable: "Mergestorm cannot read this PR from GitHub",
@@ -510,7 +522,7 @@ function lastPrLayer(stack) {
         return land;
     return stack.layers.filter((layer) => layer.prNumber > 0).sort((a, b) => b.position - a.position)[0];
 }
-export function autoLandWaitLayer(stack) {
+function autoLandWaitLayer(stack) {
     const wait = armedAutoLandWait(stack);
     if (!wait)
         return undefined;
@@ -578,7 +590,7 @@ function autoLandWaitNamed(stack, layer, nowMs) {
         ? { blocker: `${AUTO_LAND_WAITED_PREFIX}${minutes}m: ${autoLandWaitWords(wait.reason)}`, reason: "auto_land_waited" }
         : null;
 }
-export const MERGE_QUEUE_STALL_ATTENTION_MS = 45 * 60_000;
+const MERGE_QUEUE_STALL_ATTENTION_MS = 45 * 60_000;
 const MERGE_QUEUE_STALLED_PREFIX = "Merge queue stuck: ";
 const LIVE_QUEUE_STATES = ["queued", "running", "waiting"];
 function minutesOf(ms) {
@@ -680,15 +692,15 @@ export function conflictRepairSteps(branch, liveParent) {
     return `Merge ${liveParent} into ${branch}: git fetch origin, check out ${branch} at its live remote head, git merge origin/${liveParent}, resolve the conflicts, run the tests, then an ordinary git push (no force). Do not rebase onto trunk, main, or mg-park-*, and do not retarget the PR base.`;
 }
 export const BREEZE_BRANCH_PREFIX = "breeze/";
-export function isBreezeBranch(branch) {
+function isBreezeBranch(branch) {
     return typeof branch === "string" && branch.startsWith(BREEZE_BRANCH_PREFIX);
 }
-export function breezeConflictRepairSteps(branch, liveParent, prNumber) {
+function breezeConflictRepairSteps(branch, liveParent, prNumber) {
     if (!liveParent)
         return conflictRepairSteps(branch, liveParent);
     return `${branch} is a Breeze branch: Breeze updates it only with open_pull_request, which publishes single-parent commits, so it cannot publish a merge of ${liveParent}. Rebase it in the Breeze chat that opened #${prNumber}: fetch ${liveParent} with fetch_repository, git rebase origin/${liveParent}, resolve the conflicts, run the tests, then call open_pull_request again. Or have Cyclone resolve it: cyclone_start with task resolve_conflicts and pr_number ${prNumber}. Do not retarget the PR base.`;
 }
-export function restackFailedRepairSteps(branch, liveParent, failure, prNumber) {
+function restackFailedRepairSteps(branch, liveParent, failure, prNumber) {
     const why = `Mergestorm could not restack ${branch}${liveParent ? ` onto ${liveParent}` : ""} (${failure.kind}${failure.detail?.trim() ? `: ${failure.detail.trim()}` : ""}) and will not try this head again.`;
     if (!liveParent) {
         return `${why} The live parent of ${branch} is unknown (it is never an mg-park-* freeze). Do not merge or rebase anything; stop and tell the human.`;
@@ -815,6 +827,18 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null, n
             steps: `Auto land is off for this stack (autoLandOff reason ${offReason}: ${AUTO_LAND_SWITCHED_OFF_BY[offReason] ?? offReason}), so nothing will enqueue it and it will not land by itself. No bounce did this and nothing in the layers needs a change: do not patch or push for it. A person or another agent session may have switched it off on purpose, so do not turn Auto land back on yourself. Tell the human that Auto land is off and why, and turn it back on (mg stack set ${stack.id} --auto-land on) only when they say so.`,
         };
     }
+    if (reason === "cyclone_stalled") {
+        const run = stalledCycloneRun(layer, nowMs);
+        return {
+            kind: "cyclone_stalled",
+            prNumber: layer.prNumber,
+            headSha: layer.headSha ?? null,
+            branch: layer.branch,
+            runSha: run?.sha ?? null,
+            since: run?.startedAt ?? null,
+            steps: `Cyclone has been patching #${layer.prNumber}${run?.sha ? ` (a run for ${run.sha.slice(0, 7)})` : ""} since ${run?.startedAt ?? "an unknown time"} without pushing or finishing, past the ${STACK_AGENT_PATCHING_STALE_MS / 60_000}-minute limit, so the watch no longer waits for it. Patch the open Vortex findings at ${layer.headSha ?? "the head"} yourself: verify each one against a checkout of ${layer.branch}, fix the real ones with the smallest patch and an ordinary push, and dismiss the ones you judge wrong with mg dismiss. If ${layer.branch} moves before you push, Cyclone pushed after all: re-read stack_status instead of pushing. Tell the human Cyclone stalled on this PR.`,
+        };
+    }
     if (reason === "vortex_failed") {
         return {
             kind: "vortex_failed",
@@ -933,7 +957,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null, n
     }
     return null;
 }
-export const LAND_PR_MISSING_PREFIX = "No open land PR for ";
+const LAND_PR_MISSING_PREFIX = "No open land PR for ";
 function landPrMissing(stack, candidate) {
     const unit = stack.unit;
     if (!unit || candidate || stack.archivedAt || unit.state === "landed" || unit.state === "abandoned")

package/dist/stack-dto.d.ts

@@ -120,7 +120,9 @@ export type StackAgentsBusy = {
     headSha: string | null;
 };
 export declare const STACK_AGENT_QUEUED_STALE_MS: number;
+export declare const STACK_AGENT_PATCHING_STALE_MS: number;
 export declare const AUTO_RESOLVE_ENQUEUE_GRACE_MS: number;
+export declare function stalledCycloneRun(layer: Pick<StackLayerDto, "agentRuns">, nowMs?: number): StackAgentRun | null;
 export declare function deriveStackAgentsBusy(layer: Pick<StackLayerDto, "headSha" | "vortexStatus" | "cycloneStatus" | "agentRuns" | "vortexReview" | "cycloneConflictPendingSince" | "cycloneCiPendingSince">, opts?: {
     cycloneClaimed?: boolean;
     nowMs?: number;
@@ -238,6 +240,7 @@ export type StackLayerDto = {
     headSha?: string | null;
     /** Head SHA that produced mergeable / mergeableState. */
     mergeableHeadSha?: string | null;
+    staleBaseMergeable?: boolean;
     /** GitHub PR draft flag from enrich; the auto-land watcher never enqueues a draft. */
     draft?: boolean | null;
     /**

package/dist/stack-dto.js

@@ -26,6 +26,7 @@ export const AUTO_LAND_OFF_REASONS = ["user", "archive", "watcher", "cancelled",
 export const CYCLONE_FIX_HELD_REASON = "fix_held";
 export const CYCLONE_CI_FIX_HELD_REASON = "ci_fix_held";
 export const STACK_AGENT_QUEUED_STALE_MS = 15 * 60 * 1000;
+export const STACK_AGENT_PATCHING_STALE_MS = 60 * 60 * 1000;
 export const AUTO_RESOLVE_ENQUEUE_GRACE_MS = 2 * 60_000;
 function agentShaMayBeHead(sha, head) {
     const left = sha?.trim().toLowerCase();
@@ -34,6 +35,17 @@ function agentShaMayBeHead(sha, head) {
         return false;
     return left.startsWith(right) || right.startsWith(left);
 }
+export function stalledCycloneRun(layer, nowMs = Date.now()) {
+    const patching = (layer.agentRuns ?? [])
+        .filter((run) => !run.finishedAt && run.agent === "cyclone" && run.status === "patching")
+        .map((run) => ({ run, startedMs: Date.parse(run.startedAt ?? "") }));
+    if (!patching.length)
+        return null;
+    if (!patching.every(({ startedMs }) => Number.isFinite(startedMs) && nowMs - startedMs > STACK_AGENT_PATCHING_STALE_MS)) {
+        return null;
+    }
+    return patching.reduce((newest, entry) => (entry.startedMs > newest.startedMs ? entry : newest)).run;
+}
 export function deriveStackAgentsBusy(layer, opts = {}) {
     const headSha = layer.headSha?.trim() || null;
     const nowMs = opts.nowMs ?? Date.now();
@@ -54,8 +66,9 @@ export function deriveStackAgentsBusy(layer, opts = {}) {
         const sinceMs = Date.parse(since ?? "");
         return Number.isFinite(sinceMs) && nowMs - sinceMs <= AUTO_RESOLVE_ENQUEUE_GRACE_MS;
     };
-    const cyclone = opts.cycloneClaimed === true || layer.cycloneStatus === "patching" ||
-        runs.some((run) => run.agent === "cyclone" && run.status === "patching") ||
+    const stalled = stalledCycloneRun(layer, nowMs) !== null;
+    const cyclone = (!stalled && (opts.cycloneClaimed === true || layer.cycloneStatus === "patching" ||
+        runs.some((run) => run.agent === "cyclone" && run.status === "patching"))) ||
         runs.some((run) => run.agent === "cyclone" && agentShaMayBeHead(run.sha, headSha) && queuedFresh(run)) ||
         withinGrace(layer.cycloneConflictPendingSince) ||
         withinGrace(layer.cycloneCiPendingSince);

package/dist/stack-meta.d.ts

@@ -3,7 +3,7 @@ export type StackLayerMeta = {
     /** Parent branch name (trunk for the bottom layer). */
     parentBranch: string;
 };
-export type LocalStack = {
+type LocalStack = {
     layers: StackLayerMeta[];
     autoEnqueueWhenReady?: boolean;
     /** Per-open override carried from `stack create` to `stack submit`; absent = account flag. */
@@ -22,7 +22,6 @@ export type StackMeta = {
 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;
-export declare function activeStack(meta: StackMeta): LocalStack;
 export declare function activeLayers(meta: StackMeta): StackLayerMeta[];
 export declare function setActiveAutoEnqueue(meta: StackMeta, enabled: boolean | undefined): StackMeta;
 /** Per-open automation flags remembered on the active local stack until submit. */
@@ -45,3 +44,4 @@ export declare function appendLayer(meta: StackMeta, layer: StackLayerMeta): Sta
 export declare function selectStackForCreate(meta: StackMeta, parentBranch: string): StackMeta;
 /** Drop the active stack after a successful submit. */
 export declare function removeActiveStack(meta: StackMeta): StackMeta;
+export {};

package/dist/stack-meta.js

@@ -102,7 +102,7 @@ export function emptyStackMeta(trunk) {
         active: 0,
     };
 }
-export function activeStack(meta) {
+function activeStack(meta) {
     const stack = meta.stacks[meta.active];
     if (!stack) {
         throw new Error("Stack authoring state has an out-of-range active stack; run `mg stack reset --force` to clear it.");

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

@@ -1,21 +1,14 @@
 import type { Config } from "./config.js";
 import { readLandedQueueEntry } from "./api.js";
 import { pollStackWatch, type StackWatchCursor, type StackWatchEnvelope } from "./stack-watch.js";
-export declare const STACK_WATCH_MARKER = "MS-WATCH";
 export declare const STACK_WATCH_EXIT: {
     readonly landed: 0;
     readonly attention: 3;
     readonly timeout: 5;
 };
 export declare const STACK_WATCH_SLICE_MS = 300000;
-export declare const STACK_WATCH_RECHECK_MS = 30000;
-export declare const STACK_WATCH_FAILED_RETRY_MS = 15000;
-export declare const STACK_WATCH_RATE_LIMIT_WAIT_MS = 30000;
-export declare const STACK_WATCH_TRANSIENT_WINDOW_MS: number;
-export declare const STACK_WATCH_TRANSIENT_MAX_WAIT_MS = 60000;
-export declare function isTransientWatchFailure(err: unknown): boolean;
 export type StackWatchUntil = "attention" | "landed";
-export type StackWatchOutcome = "attention" | "landed" | "failed" | "timeout" | "aborted";
+type StackWatchOutcome = "attention" | "landed" | "failed" | "timeout" | "aborted";
 export type RunStackWatchOptions = {
     until?: StackWatchUntil;
     ignore?: readonly string[];
@@ -35,10 +28,6 @@ export type StackWatchLoopResult = {
     exitCode: number;
     envelope: StackWatchEnvelope | null;
 };
-export declare function blockerWithoutElapsedMinutes(blocker: string | null | undefined): string;
-export declare function stackWatchAttentionKey(envelope: Pick<StackWatchEnvelope, "prNumber" | "headSha" | "blocker">): string;
-export declare function stackWatchAttentionLine(envelope: StackWatchEnvelope): string;
-export declare function stackWatchLandedLine(envelope: StackWatchEnvelope): string;
 export declare function stackWatchFailedLine(stackId: string, message: string): string;
-export declare function stackWatchTimeoutLine(stackId: string, maxMs: number): string;
 export declare function runStackWatch(cfg: Config, stackId: string, opts?: RunStackWatchOptions): Promise<StackWatchLoopResult>;
+export {};

package/dist/stack-watch-loop.js

@@ -3,16 +3,16 @@ import { API_TIMEOUT_PREFIX, DEFAULT_API_TIMEOUT_MS, LandedQueueReadError, readL
 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";
+const STACK_WATCH_MARKER = "MS-WATCH";
 export const STACK_WATCH_EXIT = { landed: 0, attention: 3, timeout: 5 };
 export const STACK_WATCH_SLICE_MS = 300_000;
-export const STACK_WATCH_RECHECK_MS = 30_000;
-export const STACK_WATCH_FAILED_RETRY_MS = 15_000;
-export const STACK_WATCH_RATE_LIMIT_WAIT_MS = 30_000;
-export const STACK_WATCH_TRANSIENT_WINDOW_MS = 15 * 60_000;
-export const STACK_WATCH_TRANSIENT_MAX_WAIT_MS = 60_000;
+const STACK_WATCH_RECHECK_MS = 30_000;
+const STACK_WATCH_FAILED_RETRY_MS = 15_000;
+const STACK_WATCH_RATE_LIMIT_WAIT_MS = 30_000;
+const STACK_WATCH_TRANSIENT_WINDOW_MS = 15 * 60_000;
+const STACK_WATCH_TRANSIENT_MAX_WAIT_MS = 60_000;
 const TRANSIENT_WATCH_FAILURE = /HTTP (?:408|429|5\d\d)|snapshot missing|fetch failed|ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|socket hang up|network|connection/i;
-export function isTransientWatchFailure(err) {
+function isTransientWatchFailure(err) {
     if (!(err instanceof Error))
         return false;
     if (err instanceof LandedQueueReadError)
@@ -24,24 +24,24 @@ export function isTransientWatchFailure(err) {
     return err.message.startsWith(API_TIMEOUT_PREFIX) || TRANSIENT_WATCH_FAILURE.test(err.message);
 }
 const ELAPSED_MINUTES = /\b\d+m\b/g;
-export function blockerWithoutElapsedMinutes(blocker) {
+function blockerWithoutElapsedMinutes(blocker) {
     return (blocker ?? "").replace(ELAPSED_MINUTES, "Nm");
 }
-export function stackWatchAttentionKey(envelope) {
+function stackWatchAttentionKey(envelope) {
     return `${envelope.prNumber ?? ""}|${envelope.headSha ?? ""}|${blockerWithoutElapsedMinutes(envelope.blocker)}`;
 }
-export function stackWatchAttentionLine(envelope) {
+function stackWatchAttentionLine(envelope) {
     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) {
+function stackWatchLandedLine(envelope) {
     return `${STACK_WATCH_MARKER} LANDED stack=${envelope.stackId} reason=${envelope.watch.reason}`;
 }
 export function stackWatchFailedLine(stackId, message) {
     return `${STACK_WATCH_MARKER} ATTENTION failed stack=${stackId} error=${JSON.stringify(message)}`;
 }
-export function stackWatchTimeoutLine(stackId, maxMs) {
+function stackWatchTimeoutLine(stackId, maxMs) {
     return `${STACK_WATCH_MARKER} TIMEOUT stack=${stackId} after=${Math.round(maxMs / 60_000)}m`;
 }
 function isAbort(err, signal) {

package/dist/submit-pr-base.d.ts

@@ -6,7 +6,6 @@
  * `opened` and double-wake Vortex.
  */
 import type { StackDto } from "./api.js";
-export declare const MG_PARK_PREFIX = "mg-park-";
 export declare function isMgParkBranch(branch: string): boolean;
 /** Live freeze already used as a GitHub base on this stack, if any. */
 export declare function parkFreezeBranchFromStack(stack: StackDto): string | null;

package/dist/submit-pr-base.js

@@ -13,7 +13,7 @@ function registeredParentHit(stacks, parentBranch, owner, repo) {
     }
     return null;
 }
-export const MG_PARK_PREFIX = "mg-park-";
+const MG_PARK_PREFIX = "mg-park-";
 export function isMgParkBranch(branch) {
     return branch.trim().toLowerCase().startsWith(MG_PARK_PREFIX);
 }

package/dist/ui/ansi.d.ts

@@ -1,14 +1,4 @@
-/**
- * Brand ink. xterm-256 77 (#5FAF5F) � muted green that Terminal.app
- * actually paints. 24-bit `38;2;61;�` was read as palette 61 (purple).
- */
-export declare const BRAND_GREEN: {
-    readonly hex: "#5FAF5F";
-    readonly index: 77;
-};
 export declare const BRAND_GREEN_SGR: string;
-/** Full-cell fill. Glyphs like ? leave a hairline; a space with this bg does not. */
-export declare const BRAND_FILL_SGR: string;
 export declare const ansi: {
     readonly enabled: boolean;
     green: (t: string) => string;

package/dist/ui/ansi.js

@@ -15,10 +15,10 @@ function wrap(code, text) {
  * Brand ink. xterm-256 77 (#5FAF5F) � muted green that Terminal.app
  * actually paints. 24-bit `38;2;61;�` was read as palette 61 (purple).
  */
-export const BRAND_GREEN = { hex: "#5FAF5F", index: 77 };
+const BRAND_GREEN = { hex: "#5FAF5F", index: 77 };
 export const BRAND_GREEN_SGR = `38;5;${BRAND_GREEN.index}`;
 /** Full-cell fill. Glyphs like ? leave a hairline; a space with this bg does not. */
-export const BRAND_FILL_SGR = `${BRAND_GREEN_SGR};48;5;${BRAND_GREEN.index}`;
+const BRAND_FILL_SGR = `${BRAND_GREEN_SGR};48;5;${BRAND_GREEN.index}`;
 function brandGreen(text, bold = false) {
     if (!computeEnabled())
         return text;