merge-steward 0.26.1 → 0.27.0

package/dist/admin-types.d.ts

@@ -1,4 +1,5 @@
 import type { DiscoveredRepoSettings } from "./github-repo-discovery.ts";
+import type { QueueRuntimeStatus } from "./types.ts";
 export type RepoRuntimeState = "initializing" | "ready" | "failed";
 export interface RepoRuntimeStatus {
     repoId: string;
@@ -9,6 +10,7 @@ export interface RepoRuntimeStatus {
     readyAt?: string | undefined;
     failedAt?: string | undefined;
     lastError?: string | undefined;
+    runtime?: QueueRuntimeStatus | undefined;
 }
 export interface ServiceHealthResponse {
     ok: boolean;

package/dist/cli/commands/pr-status.d.ts

@@ -1,4 +1,4 @@
-import type { QueueEntry } from "../../types.ts";
+import type { QueueEntry, QueueEventSummary, QueueRuntimeStatus, QueueWatchSnapshot } from "../../types.ts";
 import type { Output, ParsedArgs } from "../types.ts";
 import { type ResolveCommandRunner } from "../resolve.ts";
 import { type PrGitHubOverview } from "./pr-github.ts";
@@ -14,6 +14,9 @@ export interface PrStatusReport {
     exitCode: number;
     reason?: string;
     queueEntry?: QueueEntry;
+    queueSource?: "service" | "database";
+    queueRuntime?: QueueRuntimeStatus;
+    queueLatestEvent?: QueueEventSummary;
     github?: PrGitHubOverview;
     checkedAt: string;
 }
@@ -22,14 +25,19 @@ export declare function classifyGitHubOverview(overview: PrGitHubOverview): {
     kind: PrStatusReport["kind"];
     reason?: string;
 };
+export declare function latestEventForPr(snapshot: QueueWatchSnapshot, prNumber: number): QueueEventSummary | undefined;
 export interface BuildReportOptions {
     repoId: string;
     repoFullName: string;
     prNumber: number;
     queueEntry?: QueueEntry | undefined;
+    queueSource?: "service" | "database" | undefined;
+    queueRuntime?: QueueRuntimeStatus | undefined;
+    queueLatestEvent?: QueueEventSummary | undefined;
     github?: PrGitHubOverview | undefined;
 }
 export declare function buildPrStatusReport(options: BuildReportOptions): PrStatusReport;
+export declare function formatReportText(report: PrStatusReport): string;
 export interface HandlePrStatusOptions {
     parsed: ParsedArgs;
     stdout: Output;

package/dist/cli/commands/pr-status.js

@@ -4,6 +4,7 @@ import { ServiceApiError, fetchLocalJson, loadRepoConfigById } from "../system.j
 import { defaultResolveRunner, resolvePrNumber, resolveRepo } from "../resolve.js";
 import { parseIntegerFlag } from "../args.js";
 import { fetchPrGitHubOverview } from "./pr-github.js";
+import { formatRuntimeActivity } from "../../runtime-format.js";
 export function classifyQueueEntry(entry) {
     switch (entry.status) {
         case "merged": return "merged";
@@ -79,9 +80,18 @@ function findEntryForPr(snapshot, prNumber) {
 }
 async function loadQueueEntry(config, prNumber) {
     try {
-        const snapshot = await fetchLocalJson(config.repoId, "/queue/watch?eventLimit=1");
+        const snapshot = await fetchLocalJson(config.repoId, "/queue/watch?eventLimit=40");
         const entry = findEntryForPr(snapshot, prNumber);
-        return entry ? { kind: "found", entry, source: "service" } : { kind: "not_found" };
+        if (!entry)
+            return { kind: "not_found" };
+        const latestEvent = latestEventForPr(snapshot, prNumber);
+        return {
+            kind: "found",
+            entry,
+            source: "service",
+            runtime: snapshot.runtime,
+            ...(latestEvent ? { latestEvent } : {}),
+        };
     }
     catch (error) {
         if (error instanceof ServiceApiError) {
@@ -106,6 +116,14 @@ async function loadQueueEntry(config, prNumber) {
         }
     }
 }
+export function latestEventForPr(snapshot, prNumber) {
+    for (let index = snapshot.recentEvents.length - 1; index >= 0; index -= 1) {
+        const event = snapshot.recentEvents[index];
+        if (event?.prNumber === prNumber)
+            return event;
+    }
+    return undefined;
+}
 export function buildPrStatusReport(options) {
     const checkedAt = new Date().toISOString();
     if (options.queueEntry) {
@@ -119,6 +137,9 @@ export function buildPrStatusReport(options) {
             terminal: isTerminalKind(kind),
             exitCode: exitCodeForKind(kind),
             queueEntry: options.queueEntry,
+            ...(options.queueSource ? { queueSource: options.queueSource } : {}),
+            ...(options.queueRuntime ? { queueRuntime: options.queueRuntime } : {}),
+            ...(options.queueLatestEvent ? { queueLatestEvent: options.queueLatestEvent } : {}),
             checkedAt,
         };
     }
@@ -139,7 +160,7 @@ export function buildPrStatusReport(options) {
     }
     throw new Error("buildPrStatusReport requires either queueEntry or github overview");
 }
-function formatReportText(report) {
+export function formatReportText(report) {
     const lines = [
         `Repo: ${report.repoFullName} (${report.repoId})`,
         `PR: #${report.prNumber}`,
@@ -156,6 +177,12 @@ function formatReportText(report) {
         lines.push(`Head SHA: ${entry.headSha}`);
         if (entry.waitDetail)
             lines.push(`Wait detail: ${entry.waitDetail}`);
+        if (report.queueRuntime) {
+            lines.push(...formatRuntimeActivity(report.queueRuntime));
+        }
+        if (report.queueLatestEvent) {
+            lines.push(`Latest event for this PR: ${report.queueLatestEvent.toStatus}${report.queueLatestEvent.detail ? ` (${report.queueLatestEvent.detail})` : ""} at ${report.queueLatestEvent.at}`);
+        }
     }
     if (report.github) {
         const gh = report.github;
@@ -232,6 +259,9 @@ export async function handlePrStatus(options) {
                 repoFullName: resolvedRepo.repoFullName,
                 prNumber: resolvedPr.prNumber,
                 queueEntry: queueResult.entry,
+                queueSource: queueResult.source,
+                ...(queueResult.runtime ? { queueRuntime: queueResult.runtime } : {}),
+                ...(queueResult.latestEvent ? { queueLatestEvent: queueResult.latestEvent } : {}),
             });
         }
         const overview = await fetchGh(resolvedRepo.repoFullName, resolvedPr.prNumber);

package/dist/cli/commands/queue.d.ts

@@ -1,5 +1,6 @@
-import { type QueueWatchSnapshot } from "../../types.ts";
+import { type QueueReconcileResult, type QueueWatchSnapshot } from "../../types.ts";
 import type { ParsedArgs, Output } from "../types.ts";
 import { type ResolveCommandRunner } from "../resolve.ts";
 export declare function formatQueueStatusText(source: "service" | "database", snapshot: QueueWatchSnapshot): string;
 export declare function handleQueue(parsed: ParsedArgs, stdout: Output, resolveCommand?: ResolveCommandRunner): Promise<number>;
+export declare function formatReconcileRequestText(result: QueueReconcileResult): string;

package/dist/cli/commands/queue.js

@@ -6,6 +6,7 @@ import { formatJson, writeOutput } from "../output.js";
 import { ServiceApiError, loadRepoConfigById, fetchLocalJson } from "../system.js";
 import { resolveRepo } from "../resolve.js";
 import { buildQueueSummary } from "../../watch/dashboard-model.js";
+import { formatDurationMs, formatRuntimeActivity } from "../../runtime-format.js";
 async function resolveRepoIdWithCwdFallback(parsed, positionalIndex, resolveCommand) {
     const positional = parsed.positionals[positionalIndex];
     if (positional)
@@ -84,6 +85,7 @@ export function formatQueueStatusText(source, snapshot) {
         `Queued: ${snapshot.summary.queued}  preparing: ${snapshot.summary.preparingHead}  validating: ${snapshot.summary.validating}  merging: ${snapshot.summary.merging}`,
         `Merged: ${snapshot.summary.merged}  evicted: ${snapshot.summary.evicted}  dequeued: ${snapshot.summary.dequeued}`,
         snapshot.summary.headPrNumber ? `Head PR: #${snapshot.summary.headPrNumber}` : "Head PR: none",
+        ...formatRuntimeActivity(snapshot.runtime),
         ...(snapshot.runtime.lastTickOutcome === "failed"
             ? [
                 "Last tick: failed",
@@ -241,7 +243,7 @@ export async function handleQueue(parsed, stdout, resolveCommand) {
             else {
                 writeOutput(stdout, [
                     `Repo: ${repoId}`,
-                    result.started ? "Reconcile started." : "Reconcile request accepted; a tick was already in progress.",
+                    formatReconcileRequestText(result),
                     `Last outcome: ${result.runtime.lastTickOutcome}`,
                 ].join("\n") + "\n");
             }
@@ -253,3 +255,18 @@ export async function handleQueue(parsed, stdout, resolveCommand) {
     }
     throw new UsageError(`Unknown queue command: ${subcommand}`, "queue");
 }
+export function formatReconcileRequestText(result) {
+    if (result.started)
+        return "Reconcile started.";
+    if (result.reason === "already_running") {
+        const age = formatDurationMs(result.runtime.tickAgeMs);
+        const latest = result.runtime.lastReconcileEvent
+            ? `; latest action ${result.runtime.lastReconcileEvent.action} PR #${result.runtime.lastReconcileEvent.prNumber}`
+            : "";
+        const guidance = result.runtime.staleTick
+            ? "inspect logs before restarting"
+            : "wait for the current tick before restarting";
+        return `Reconcile already running for ${age}${latest}; ${guidance}.`;
+    }
+    return "Reconcile request accepted; a tick was already in progress.";
+}

package/dist/cli/commands/service.js

@@ -3,6 +3,7 @@ import { UsageError } from "../types.js";
 import { parseIntegerFlag } from "../args.js";
 import { formatJson, writeOutput } from "../output.js";
 import { fetchServiceHealthStatus, formatCommandFailure, parseSystemctlShowOutput, runSystemctl } from "../system.js";
+import { formatDurationMs } from "../../runtime-format.js";
 const UNIT_NAME = "merge-steward.service";
 export async function handleService(parsed, stdout, runCommand) {
     const subcommand = parsed.positionals[1];
@@ -71,6 +72,7 @@ export async function handleService(parsed, stdout, runCommand) {
             health.reachable
                 ? `Health: ${health.ok ? "ok" : "unhealthy"} (HTTP ${health.status})`
                 : `Health: not reachable (${health.error})`,
+            ...(health.reachable && health.health ? staleRuntimeLines(health.health.repos) : []),
         ]
             .filter(Boolean)
             .join("\n") + "\n");
@@ -94,3 +96,12 @@ export async function handleService(parsed, stdout, runCommand) {
     }
     throw new UsageError(`Unknown service command: ${subcommand}`, "service");
 }
+function staleRuntimeLines(repos) {
+    return repos
+        .filter((repo) => repo.runtime?.staleTick)
+        .map((repo) => {
+        const event = repo.runtime?.lastReconcileEvent;
+        const latest = event ? `; latest action ${event.action} PR #${event.prNumber}` : "";
+        return `Warning: ${repo.repoId} reconcile tick is stale after ${formatDurationMs(repo.runtime?.tickAgeMs)}${latest}`;
+    });
+}

package/dist/config.d.ts

@@ -10,6 +10,7 @@ export declare const stewardConfigSchema: z.ZodObject<{
     flakyRetries: z.ZodDefault<z.ZodNumber>;
     speculativeDepth: z.ZodDefault<z.ZodNumber>;
     pollIntervalMs: z.ZodDefault<z.ZodNumber>;
+    reconcileStaleAfterMs: z.ZodDefault<z.ZodNumber>;
     server: z.ZodDefault<z.ZodObject<{
         bind: z.ZodDefault<z.ZodString>;
         port: z.ZodDefault<z.ZodNumber>;

package/dist/config.js

@@ -16,6 +16,7 @@ export const stewardConfigSchema = z.object({
     /** Max speculative branches to maintain in parallel. 1 = serial mode. */
     speculativeDepth: z.number().int().min(1).default(10),
     pollIntervalMs: z.number().int().min(1000).default(30_000),
+    reconcileStaleAfterMs: z.number().int().min(1000).default(5 * 60_000),
     server: z.object({
         bind: z.string().default("127.0.0.1"),
         port: z.number().int().default(8790),

package/dist/http-multi.js

@@ -48,6 +48,7 @@ export async function buildMultiRepoHttpServer(options) {
             ...(record.readyAt ? { readyAt: record.readyAt } : {}),
             ...(record.failedAt ? { failedAt: record.failedAt } : {}),
             ...(record.lastError ? { lastError: record.lastError } : {}),
+            ...(record.instance ? { runtime: record.instance.service.getRuntimeStatus() } : {}),
         })),
     }));
     app.get("/admin/runtime/auth", async () => githubAdmin.getStatus());

package/dist/reconciler-evict.js

@@ -32,11 +32,20 @@ export async function evictEntry(ctx, entry, failureClass, extra) {
     const retryHistory = [];
     for (const event of events) {
         const eventBaseSha = event.baseSha || "unknown";
+        const detail = event.detail ?? "";
         if (event.fromStatus === "preparing_head" && event.toStatus === "validating") {
             retryHistory.push({ at: event.at, baseSha: eventBaseSha, outcome: "passed_to_validation" });
         }
         else if (event.fromStatus === "validating" && event.toStatus === "preparing_head") {
-            retryHistory.push({ at: event.at, baseSha: eventBaseSha, outcome: "ci_failed_retry" });
+            const outcome = detail.startsWith("invalidated:")
+                ? "invalidated"
+                : detail.toLowerCase().includes("ci failed")
+                    ? "ci_failed_retry"
+                    : "validation_reset";
+            retryHistory.push({ at: event.at, baseSha: eventBaseSha, outcome });
+        }
+        else if (event.fromStatus === "merging" && event.toStatus === "preparing_head") {
+            retryHistory.push({ at: event.at, baseSha: eventBaseSha, outcome: "push_failed_retry" });
         }
         else if (event.fromStatus === "preparing_head" && event.toStatus === "preparing_head") {
             retryHistory.push({ at: event.at, baseSha: eventBaseSha, outcome: "conflict_retry" });

package/dist/reconciler-merge.js

@@ -7,6 +7,136 @@ const DEFAULT_PR_MERGED_POLL_DELAY_MS = 2_000;
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function shortSha(sha) {
+    return sha ? sha.slice(0, 8) : "unknown";
+}
+function sanitizeCommandOutput(value) {
+    return value
+        .replace(/x-access-token:[^@\s]+@/g, "x-access-token:[redacted]@")
+        .replace(/\bgh[psu]_[A-Za-z0-9_]+\b/g, "[redacted-token]")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 1200);
+}
+function describeError(error) {
+    if (!(error instanceof Error)) {
+        return sanitizeCommandOutput(String(error));
+    }
+    const failure = error;
+    const parts = [
+        failure.stderr,
+        failure.stdout,
+        error.message,
+        typeof failure.exitCode === "number" ? `exit code ${failure.exitCode}` : undefined,
+        failure.signal ? `signal ${failure.signal}` : undefined,
+    ].filter((part) => Boolean(part && part.trim()));
+    return sanitizeCommandOutput(parts.join(" "));
+}
+function classifyPushFailure(error, detail) {
+    const failure = error instanceof Error ? error : undefined;
+    const lower = detail.toLowerCase();
+    if (failure?.timedOut || lower.includes("timed out")) {
+        return "timeout";
+    }
+    if (lower.includes("refusing to allow a github app to create or update workflow")) {
+        return "workflow_permission";
+    }
+    if (lower.includes("non-fast-forward")
+        || lower.includes("fetch first")
+        || lower.includes("stale info")
+        || lower.includes("cannot lock ref")) {
+        return "non_fast_forward";
+    }
+    if (lower.includes("protected branch")
+        || lower.includes("gh006")
+        || lower.includes("required status check")
+        || lower.includes("required approving review")
+        || lower.includes("changes must be made through a pull request")) {
+        return "protected_branch";
+    }
+    if (lower.includes("authentication failed")
+        || lower.includes("permission denied")
+        || lower.includes("write access")
+        || lower.includes("403")
+        || lower.includes("not authorized")) {
+        return "auth_or_permission";
+    }
+    return "github_push_rejected";
+}
+function normalizeCheckName(name) {
+    return name.trim().toLowerCase();
+}
+function getMissingRequiredChecks(requiredChecks, checks) {
+    if (requiredChecks.length === 0) {
+        return [];
+    }
+    const available = new Set(checks.map((check) => normalizeCheckName(check.name)).filter(Boolean));
+    return requiredChecks.filter((check) => !available.has(normalizeCheckName(check)));
+}
+function summarizeChecks(checks, missingRequiredChecks) {
+    const visible = checks
+        .filter((check) => check.name.trim())
+        .map((check) => `${check.name}=${check.conclusion}`);
+    const parts = [];
+    if (visible.length > 0) {
+        parts.push(`spec checks ${visible.slice(0, 5).join(", ")}`);
+        if (visible.length > 5) {
+            parts.push(`+${visible.length - 5} more`);
+        }
+    }
+    else {
+        parts.push("no spec checks visible");
+    }
+    if (missingRequiredChecks.length > 0) {
+        parts.push(`missing required ${missingRequiredChecks.join(", ")}`);
+    }
+    return parts.join("; ");
+}
+async function inspectSpecChecks(ctx, specSha) {
+    if (!specSha) {
+        return {
+            detail: "spec checks unavailable: no spec SHA",
+            failingChecks: [],
+            pendingChecks: [],
+            missingRequiredChecks: ctx.policy.getRequiredChecks(),
+        };
+    }
+    try {
+        const checks = await ctx.github.listChecksForRef(specSha);
+        const failingChecks = checks.filter((check) => check.conclusion === "failure");
+        const pendingChecks = checks.filter((check) => check.conclusion === "pending");
+        const missingRequiredChecks = getMissingRequiredChecks(ctx.policy.getRequiredChecks(), checks);
+        return {
+            detail: summarizeChecks(checks, missingRequiredChecks),
+            failingChecks,
+            pendingChecks,
+            missingRequiredChecks,
+        };
+    }
+    catch (error) {
+        return {
+            detail: `spec checks unavailable: ${describeError(error)}`,
+            failingChecks: [],
+            pendingChecks: [],
+            missingRequiredChecks: ctx.policy.getRequiredChecks(),
+        };
+    }
+}
+async function verifySpecStillFastForwards(ctx, specSha) {
+    try {
+        await ctx.git.fetch();
+        const currentBase = await ctx.git.headSha(ref(ctx, ctx.baseBranch));
+        const isFastForward = await ctx.git.isAncestor(currentBase, specSha);
+        return { currentBase, isFastForward };
+    }
+    catch (error) {
+        return {
+            currentBase: null,
+            isFastForward: null,
+            detail: `fast-forward verification unavailable: ${describeError(error)}`,
+        };
+    }
+}
 export async function mergeHead(ctx, entry) {
     emit(ctx, entry, "merge_revalidating");
     const prStatus = await ctx.github.getStatus(entry.prNumber);
@@ -93,7 +223,12 @@ export async function mergeHead(ctx, entry) {
     try {
         await ctx.git.push(entry.specBranch, false, ctx.baseBranch);
     }
-    catch {
+    catch (error) {
+        const pushErrorDetail = describeError(error);
+        const pushFailureKind = classifyPushFailure(error, pushErrorDetail);
+        const fastForward = entry.specSha
+            ? await verifySpecStillFastForwards(ctx, entry.specSha)
+            : { currentBase: null, isFastForward: null, detail: "fast-forward verification unavailable: no spec SHA" };
         try {
             const refresh = await ctx.policy.refreshOnIssue("merge_push_rejected");
             if (refresh.attempted && refresh.changed) {
@@ -109,20 +244,52 @@ export async function mergeHead(ctx, entry) {
         catch {
             // Fall through to the normal push failure handling when policy refresh is unavailable.
         }
-        emit(ctx, entry, "merge_rejected", { detail: "push to main failed" });
-        const allActive = ctx.store.listActive(ctx.repoId);
-        if (isBudgetExhausted(entry)) {
-            emit(ctx, entry, "budget_exhausted");
-            await evictEntry(ctx, entry, "integration_conflict");
+        const checkState = await inspectSpecChecks(ctx, entry.specSha);
+        const detail = [
+            `push to ${ctx.baseBranch} failed (${pushFailureKind})`,
+            `spec ${shortSha(entry.specSha)}`,
+            `main ${shortSha(fastForward.currentBase ?? currentBase)}`,
+            fastForward.isFastForward === null
+                ? fastForward.detail
+                : `spec fast-forward ${fastForward.isFastForward ? "yes" : "no"}`,
+            checkState.detail,
+            pushErrorDetail,
+        ].filter((part) => Boolean(part && part.trim())).join("; ");
+        emit(ctx, entry, "merge_rejected", {
+            detail,
+            baseSha: fastForward.currentBase ?? currentBase ?? undefined,
+            failingChecks: checkState.failingChecks,
+            pendingChecks: checkState.pendingChecks,
+            missingRequiredChecks: checkState.missingRequiredChecks,
+        });
+        const mustRebuild = pushFailureKind === "non_fast_forward" || fastForward.isFastForward === false;
+        if (mustRebuild) {
+            const allActive = ctx.store.listActive(ctx.repoId);
+            if (isBudgetExhausted(entry)) {
+                emit(ctx, entry, "budget_exhausted", {
+                    detail: "push retry budget exhausted after non-fast-forward rejection",
+                });
+                await evictEntry(ctx, entry, "integration_conflict");
+            }
+            else {
+                ctx.store.transition(entry.id, "preparing_head", {
+                    retryAttempts: entry.retryAttempts + 1,
+                    ...CLEAN_CI,
+                    ...CLEAN_SPEC,
+                }, `push failed, retry ${entry.retryAttempts + 1}/${entry.maxRetries}`);
+            }
+            await invalidateDownstream(ctx, allActive, 0);
+            return;
         }
-        else {
-            ctx.store.transition(entry.id, "preparing_head", {
-                retryAttempts: entry.retryAttempts + 1,
-                ...CLEAN_CI,
-                ...CLEAN_SPEC,
-            }, `push failed, retry ${entry.retryAttempts + 1}/${entry.maxRetries}`);
+        if (isBudgetExhausted(entry)) {
+            emit(ctx, entry, "budget_exhausted", {
+                detail: "push retry budget exhausted; keeping validated spec for GitHub recovery",
+            });
         }
-        await invalidateDownstream(ctx, allActive, 0);
+        ctx.store.transition(entry.id, "merging", {
+            retryAttempts: Math.min(entry.retryAttempts + 1, entry.maxRetries),
+            waitDetail: detail,
+        }, `push failed, keeping validated spec: ${detail}`);
         return;
     }
     emit(ctx, entry, "merge_succeeded");

package/dist/runtime-format.d.ts

@@ -0,0 +1,4 @@
+import type { QueueRuntimeStatus, ReconcileEventSummary } from "./types.ts";
+export declare function formatDurationMs(ms: number | null | undefined): string;
+export declare function formatReconcileEvent(event: ReconcileEventSummary | null | undefined): string | null;
+export declare function formatRuntimeActivity(runtime: QueueRuntimeStatus): string[];

package/dist/runtime-format.js

@@ -0,0 +1,35 @@
+export function formatDurationMs(ms) {
+    if (ms === null || ms === undefined || !Number.isFinite(ms))
+        return "unknown duration";
+    const seconds = Math.max(0, Math.round(ms / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainder = seconds % 60;
+    if (minutes < 60)
+        return remainder === 0 ? `${minutes}m` : `${minutes}m${remainder}s`;
+    const hours = Math.floor(minutes / 60);
+    const minuteRemainder = minutes % 60;
+    return minuteRemainder === 0 ? `${hours}h` : `${hours}h${minuteRemainder}m`;
+}
+export function formatReconcileEvent(event) {
+    if (!event)
+        return null;
+    return `${event.action} PR #${event.prNumber}${event.detail ? ` (${event.detail})` : ""} at ${event.at}`;
+}
+export function formatRuntimeActivity(runtime) {
+    if (!runtime.tickInProgress)
+        return [];
+    const age = formatDurationMs(runtime.tickAgeMs);
+    const started = runtime.lastTickStartedAt ? `, started ${runtime.lastTickStartedAt}` : "";
+    const lines = [
+        `Reconcile: ${runtime.staleTick ? "stale" : "running"} for ${age}${started}`,
+    ];
+    const latest = formatReconcileEvent(runtime.lastReconcileEvent);
+    if (latest)
+        lines.push(`Latest action: ${latest}`);
+    if (runtime.staleTick) {
+        lines.push(`Warning: reconcile tick appears stale; threshold ${formatDurationMs(runtime.staleTickThresholdMs)}.`);
+    }
+    return lines;
+}

package/dist/service-runtime.d.ts

@@ -1,7 +1,7 @@
 import type { Logger } from "pino";
 import type { GitOperations, CIRunner, GitHubPRApi, EvictionReporter, SpeculativeBranchBuilder } from "./interfaces.ts";
 import type { QueueStore } from "./store.ts";
-import type { QueueBlockState, QueueRuntimeStatus } from "./types.ts";
+import type { QueueBlockState, QueueReconcileResult, QueueRuntimeStatus } from "./types.ts";
 import type { StewardConfig } from "./config.ts";
 import type { GitHubPolicyCache } from "./github-policy.ts";
 export declare class MergeStewardRuntime {
@@ -16,25 +16,27 @@ export declare class MergeStewardRuntime {
     private readonly logger;
     private readonly beforeTick?;
     private tickTimer;
+    private staleTickTimer;
     private tickInProgress;
     private lastTickStartedAt;
     private lastTickCompletedAt;
     private lastTickOutcome;
     private lastTickError;
+    private lastReconcileEvent;
     private currentQueueBlock;
     private readonly waitingMainInfoAt;
     private static readonly WAITING_MAIN_INFO_INTERVAL_MS;
     constructor(config: StewardConfig, policy: GitHubPolicyCache, store: QueueStore, git: GitOperations, ci: CIRunner, github: GitHubPRApi, eviction: EvictionReporter, specBuilder: SpeculativeBranchBuilder, logger: Logger, beforeTick?: (() => Promise<void>) | undefined);
     start(): Promise<void>;
     stop(): Promise<void>;
-    triggerReconcile(): Promise<{
-        started: boolean;
-        runtime: QueueRuntimeStatus;
-    }>;
+    triggerReconcile(): Promise<QueueReconcileResult>;
     getRuntimeStatus(): QueueRuntimeStatus;
     getCurrentQueueBlock(): QueueBlockState | null;
     getGitHubPolicy(): import("./github-policy.ts").GitHubPolicySnapshot;
     private scheduleNextTick;
+    private getTickAgeMs;
+    private scheduleStaleTickWarning;
+    private clearStaleTickTimer;
     private runTick;
     private describeMainBroken;
     private getMissingRequiredChecks;

package/dist/service-runtime.js

@@ -11,11 +11,13 @@ export class MergeStewardRuntime {
     logger;
     beforeTick;
     tickTimer;
+    staleTickTimer;
     tickInProgress = false;
     lastTickStartedAt = null;
     lastTickCompletedAt = null;
     lastTickOutcome = "idle";
     lastTickError = null;
+    lastReconcileEvent = null;
     currentQueueBlock = null;
     // Per-entry timestamp of the last info-level `merge_waiting_main` log.
     // The event fires every tick while the gate waits, so subsequent ticks
@@ -44,6 +46,7 @@ export class MergeStewardRuntime {
             clearTimeout(this.tickTimer);
             this.tickTimer = undefined;
         }
+        this.clearStaleTickTimer();
         const deadline = Date.now() + 10_000;
         while (this.tickInProgress && Date.now() < deadline) {
             await new Promise((resolve) => setTimeout(resolve, 100));
@@ -54,16 +57,23 @@ export class MergeStewardRuntime {
         const started = await this.runTick();
         return {
             started,
+            ...(!started ? { reason: "already_running" } : {}),
             runtime: this.getRuntimeStatus(),
         };
     }
     getRuntimeStatus() {
+        const tickAgeMs = this.getTickAgeMs();
+        const staleTickThresholdMs = this.config.reconcileStaleAfterMs;
         return {
             tickInProgress: this.tickInProgress,
             lastTickStartedAt: this.lastTickStartedAt,
             lastTickCompletedAt: this.lastTickCompletedAt,
             lastTickOutcome: this.lastTickOutcome,
             lastTickError: this.lastTickError,
+            tickAgeMs,
+            staleTickThresholdMs,
+            staleTick: tickAgeMs !== null && tickAgeMs >= staleTickThresholdMs,
+            lastReconcileEvent: this.lastReconcileEvent,
         };
     }
     getCurrentQueueBlock() {
@@ -79,6 +89,36 @@ export class MergeStewardRuntime {
         this.tickTimer = setTimeout(() => void this.runTick(), this.config.pollIntervalMs);
         this.tickTimer.unref?.();
     }
+    getTickAgeMs() {
+        if (!this.tickInProgress || !this.lastTickStartedAt)
+            return null;
+        const startedMs = Date.parse(this.lastTickStartedAt);
+        if (!Number.isFinite(startedMs))
+            return null;
+        return Math.max(0, Date.now() - startedMs);
+    }
+    scheduleStaleTickWarning(startedAt) {
+        this.clearStaleTickTimer();
+        const timer = setTimeout(() => {
+            if (!this.tickInProgress || this.lastTickStartedAt !== startedAt)
+                return;
+            const runtime = this.getRuntimeStatus();
+            this.logger.warn({
+                startedAt,
+                tickAgeMs: runtime.tickAgeMs,
+                staleTickThresholdMs: runtime.staleTickThresholdMs,
+                lastReconcileEvent: runtime.lastReconcileEvent,
+            }, "Reconcile tick appears stale");
+        }, this.config.reconcileStaleAfterMs);
+        timer.unref?.();
+        this.staleTickTimer = timer;
+    }
+    clearStaleTickTimer() {
+        if (this.staleTickTimer) {
+            clearTimeout(this.staleTickTimer);
+            this.staleTickTimer = undefined;
+        }
+    }
     async runTick() {
         if (this.tickInProgress)
             return false;
@@ -86,6 +126,8 @@ export class MergeStewardRuntime {
         this.lastTickStartedAt = new Date().toISOString();
         this.lastTickOutcome = "running";
         this.lastTickError = null;
+        this.lastReconcileEvent = null;
+        this.scheduleStaleTickWarning(this.lastTickStartedAt);
         try {
             await this.beforeTick?.();
             let tickQueueBlockEvent = null;
@@ -103,6 +145,7 @@ export class MergeStewardRuntime {
                 flakyRetries: this.config.flakyRetries,
                 policy: this.policy,
                 onEvent: (event) => {
+                    this.lastReconcileEvent = summarizeReconcileEvent(event);
                     const isWarn = event.action === "evicted" || event.action === "spec_build_conflict"
                         || event.action === "ci_failed"
                         || event.action === "merge_rejected" || event.action === "budget_exhausted";
@@ -142,6 +185,7 @@ export class MergeStewardRuntime {
             this.logger.error({ err: error instanceof Error ? { message: error.message, stack: error.stack } : error }, "Reconcile tick failed");
         }
         finally {
+            this.clearStaleTickTimer();
             this.tickInProgress = false;
             this.lastTickCompletedAt = new Date().toISOString();
             this.scheduleNextTick();
@@ -191,3 +235,14 @@ export class MergeStewardRuntime {
         return requiredChecks.filter((check) => !available.has(check.trim().toLowerCase()));
     }
 }
+function summarizeReconcileEvent(event) {
+    return {
+        at: event.at,
+        entryId: event.entryId,
+        prNumber: event.prNumber,
+        action: event.action,
+        ...(event.detail ? { detail: event.detail } : {}),
+        ...(event.ciRunId ? { ciRunId: event.ciRunId } : {}),
+        ...(event.specBranch ? { specBranch: event.specBranch } : {}),
+    };
+}

package/dist/service.d.ts

@@ -1,10 +1,9 @@
 import type { Logger } from "pino";
 import type { GitOperations, CIRunner, GitHubPRApi, EvictionReporter, SpeculativeBranchBuilder } from "./interfaces.ts";
-import type { QueueEntry, QueueEntryDetail, IncidentRecord, QueueRuntimeStatus, QueueWatchSnapshot } from "./types.ts";
+import type { QueueEntry, QueueEntryDetail, IncidentRecord, QueueReconcileResult, QueueRuntimeStatus, QueueWatchSnapshot } from "./types.ts";
 import type { StewardConfig } from "./config.ts";
 import type { GitHubPolicyCache, GitHubPolicyRefreshResult, GitHubPolicySnapshot } from "./github-policy.ts";
 import type { QueueStore } from "./store.ts";
-import { MergeStewardRuntime } from "./service-runtime.ts";
 /**
  * Merge steward service. The public shell stays thin and delegates
  * lifecycle, queue mutations, and query shaping to focused helpers.
@@ -51,10 +50,7 @@ export declare class MergeStewardService {
     getEntryDetail(entryId: string, options?: {
         eventLimit?: number;
     }): QueueEntryDetail | undefined;
-    triggerReconcile(): Promise<{
-        started: boolean;
-        runtime: ReturnType<MergeStewardRuntime["getRuntimeStatus"]>;
-    }>;
+    triggerReconcile(): Promise<QueueReconcileResult>;
     getGitHubPolicy(): GitHubPolicySnapshot;
     refreshGitHubPolicyFromWebhook(reason: string): Promise<GitHubPolicyRefreshResult>;
 }

package/dist/types.d.ts

@@ -141,6 +141,24 @@ export interface QueueRuntimeStatus {
     lastTickCompletedAt: string | null;
     lastTickOutcome: "idle" | "running" | "succeeded" | "failed";
     lastTickError: string | null;
+    tickAgeMs?: number | null;
+    staleTickThresholdMs?: number;
+    staleTick?: boolean;
+    lastReconcileEvent?: ReconcileEventSummary | null;
+}
+export interface ReconcileEventSummary {
+    at: string;
+    entryId: string;
+    prNumber: number;
+    action: ReconcileAction;
+    detail?: string | undefined;
+    ciRunId?: string | undefined;
+    specBranch?: string | undefined;
+}
+export interface QueueReconcileResult {
+    started: boolean;
+    reason?: "already_running" | undefined;
+    runtime: QueueRuntimeStatus;
 }
 export interface QueueStatusSummary {
     total: number;

package/dist/watch/App.js

@@ -2,6 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useMemo, useState } from "react";
 import { Box, Text, useApp, useInput, useStdout } from "ink";
 import { fetchGatewayHealth, fetchSnapshot, triggerReconcile } from "./api.js";
+import { formatDurationMs } from "../runtime-format.js";
 import { buildDashboard, matchRepoRef, repoSelector, stepRepo } from "./dashboard-model.js";
 import { HelpBar } from "./HelpBar.js";
 import { OverviewView } from "./OverviewView.js";
@@ -147,7 +148,9 @@ export function App({ gatewayBaseUrl, repos, initialRepoRef, initialPrNumber })
             return;
         try {
             const result = await triggerReconcile(gatewayBaseUrl, repoId);
-            setFlashMessage(result.started ? `reconcile tick completed for ${repoId}` : `reconcile already running for ${repoId}`);
+            setFlashMessage(result.started
+                ? `reconcile tick completed for ${repoId}`
+                : `reconcile already running for ${formatDurationMs(result.runtime.tickAgeMs)} in ${repoId}`);
         }
         catch (error) {
             setFlashMessage(error instanceof Error ? error.message : String(error));

package/dist/watch/api.d.ts

@@ -1,5 +1,5 @@
 import type { ServiceHealthResponse } from "../admin-types.ts";
-import type { QueueEntryDetail, QueueWatchSnapshot } from "../types.ts";
+import type { QueueEntryDetail, QueueReconcileResult, QueueWatchSnapshot } from "../types.ts";
 export declare class ServiceApiError extends Error {
     readonly options?: {
         status?: number;
@@ -15,6 +15,5 @@ export declare function fetchGatewayHealth(gatewayBaseUrl: string): Promise<Serv
 export declare function fetchEntryDetail(gatewayBaseUrl: string, repoId: string, entryId: string): Promise<QueueEntryDetail>;
 export declare function triggerReconcile(gatewayBaseUrl: string, repoId: string): Promise<{
     ok: true;
-    started: boolean;
-}>;
+} & QueueReconcileResult>;
 export declare function dequeueEntry(gatewayBaseUrl: string, repoId: string, entryId: string): Promise<void>;

package/dist/watch/format.js

@@ -164,7 +164,7 @@ export function specChainLabel(entry, allEntries) {
 }
 export function runtimeLabel(runtime) {
     if (runtime.tickInProgress) {
-        return "running";
+        return runtime.staleTick ? "stale" : "running";
     }
     if (runtime.lastTickOutcome === "idle") {
         return "idle";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "merge-steward",
-  "version": "0.26.1",
+  "version": "0.27.0",
   "description": "Serial merge queue for GitHub — rebase, CI-gate, and merge PRs one at a time",
   "type": "module",
   "repository": {