merge-steward 0.30.3 → 0.32.0

package/dist/db/schema.js

@@ -29,6 +29,7 @@ export function ensureSchema(connection) {
       post_merge_sha TEXT,
       post_merge_summary TEXT,
       post_merge_checked_at TEXT,
+      decided_at TEXT,
       enqueued_at TEXT NOT NULL,
       updated_at TEXT NOT NULL
     )
@@ -81,11 +82,20 @@ export function ensureSchema(connection) {
     // Plan §5.3: cached identity for patch-id-aware updateHead.
     ensureColumn(connection, "queue_entries", "head_patch_id", "TEXT");
     ensureColumn(connection, "queue_entries", "spec_tree_id", "TEXT");
+    ensureColumn(connection, "queue_entries", "decided_at", "TEXT");
     connection.exec(`
     UPDATE queue_entries
        SET post_merge_status = 'pending'
      WHERE status = 'merged'
        AND post_merge_status IS NULL
+  `);
+    // Backfill decided_at for already-terminal rows so historic entries show a
+    // sensible duration/age; updated_at is the best estimate we have for them.
+    connection.exec(`
+    UPDATE queue_entries
+       SET decided_at = updated_at
+     WHERE decided_at IS NULL
+       AND status IN ('merged', 'evicted', 'dequeued')
   `);
     // Must match TERMINAL_STATUSES in types.ts: merged, evicted, dequeued
     connection.exec(`

package/dist/db/sqlite-store.d.ts

@@ -11,6 +11,7 @@ export declare class SqliteStore implements QueueStore {
     getEntryByPR(repoId: string, prNumber: number): QueueEntry | undefined;
     listActive(repoId: string): QueueEntry[];
     listAll(repoId: string): QueueEntry[];
+    listPostMergePending(repoId: string): QueueEntry[];
     insert(entry: QueueEntry): void;
     transition(entryId: string, to: QueueEntryStatus, patch?: Partial<Pick<QueueEntry, "headSha" | "baseSha" | "ciRunId" | "ciRetries" | "retryAttempts" | "lastFailedBaseSha" | "specBranch" | "specSha" | "specBasedOn" | "waitDetail" | "postMergeStatus" | "postMergeSha" | "postMergeSummary" | "postMergeCheckedAt" | "headPatchId" | "specTreeId">>, detail?: string): void;
     dequeue(entryId: string): void;

package/dist/db/sqlite-store.js

@@ -33,6 +33,7 @@ function mapEntry(row) {
         baseRefName: row.base_ref_name === null || row.base_ref_name === undefined ? null : String(row.base_ref_name),
         headPatchId: row.head_patch_id === null || row.head_patch_id === undefined ? null : String(row.head_patch_id),
         specTreeId: row.spec_tree_id === null || row.spec_tree_id === undefined ? null : String(row.spec_tree_id),
+        decidedAt: row.decided_at === null || row.decided_at === undefined ? null : String(row.decided_at),
         enqueuedAt: String(row.enqueued_at),
         updatedAt: String(row.updated_at),
     };
@@ -122,6 +123,13 @@ export class SqliteStore {
         const rows = this.conn.prepare("SELECT * FROM queue_entries WHERE repo_id = ? ORDER BY priority DESC, position ASC").all(repoId);
         return rows.map(mapEntry);
     }
+    listPostMergePending(repoId) {
+        const rows = this.conn.prepare(`SELECT * FROM queue_entries
+       WHERE repo_id = ? AND status = 'merged'
+         AND (post_merge_status IS NULL OR post_merge_status NOT IN ('pass', 'fail'))
+       ORDER BY position ASC`).all(repoId);
+        return rows.map(mapEntry);
+    }
     insert(entry) {
         this.conn.transaction(() => {
             this.conn.prepare(`INSERT INTO queue_entries
@@ -129,20 +137,27 @@ export class SqliteStore {
           priority, generation, ci_run_id, ci_retries, retry_attempts,
           max_retries, last_failed_base_sha, issue_key, wait_detail,
           post_merge_status, post_merge_sha, post_merge_summary, post_merge_checked_at,
-          pr_title, base_ref_name,
+          pr_title, base_ref_name, decided_at,
           enqueued_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(entry.id, entry.repoId, entry.prNumber, entry.branch, entry.headSha, entry.baseSha, entry.status, entry.position, entry.priority, entry.generation, entry.ciRunId, entry.ciRetries, entry.retryAttempts, entry.maxRetries, entry.lastFailedBaseSha, entry.issueKey ?? null, entry.waitDetail ?? null, entry.postMergeStatus ?? null, entry.postMergeSha ?? null, entry.postMergeSummary ?? null, entry.postMergeCheckedAt ?? null, entry.prTitle ?? null, entry.baseRefName ?? null, entry.enqueuedAt, entry.updatedAt);
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(entry.id, entry.repoId, entry.prNumber, entry.branch, entry.headSha, entry.baseSha, entry.status, entry.position, entry.priority, entry.generation, entry.ciRunId, entry.ciRetries, entry.retryAttempts, entry.maxRetries, entry.lastFailedBaseSha, entry.issueKey ?? null, entry.waitDetail ?? null, entry.postMergeStatus ?? null, entry.postMergeSha ?? null, entry.postMergeSummary ?? null, entry.postMergeCheckedAt ?? null, entry.prTitle ?? null, entry.baseRefName ?? null, entry.decidedAt ?? null, entry.enqueuedAt, entry.updatedAt);
             this.writeEvent(entry.id, null, entry.status);
         })();
     }
     transition(entryId, to, patch, detail) {
         this.conn.transaction(() => {
-            const current = this.conn.prepare("SELECT status FROM queue_entries WHERE id = ?").get(entryId);
+            const current = this.conn.prepare("SELECT status, decided_at FROM queue_entries WHERE id = ?").get(entryId);
             if (!current)
                 return;
             const from = String(current.status);
+            const now = isoNow();
             const sets = ["status = ?", "updated_at = ?"];
-            const values = [to, isoNow()];
+            const values = [to, now];
+            // Stamp decidedAt the first time the entry becomes terminal; never move it
+            // afterward (post-merge re-verification keeps transitioning to 'merged').
+            if (TERMINAL_STATUSES.includes(to) && (current.decided_at === null || current.decided_at === undefined)) {
+                sets.push("decided_at = ?");
+                values.push(now);
+            }
             if (patch?.headSha !== undefined) {
                 sets.push("head_sha = ?");
                 values.push(patch.headSha);

package/dist/reconciler.js

@@ -11,8 +11,10 @@ import { syncQueueStateLabels } from "./reconciler-queue-labels.js";
 // ─── Main reconcile loop ────────────────────────────────────────
 export async function reconcile(ctx) {
     const allActive = ctx.store.listActive(ctx.repoId);
-    if (allActive.length === 0)
-        return;
+    // Note: do NOT early-return when the active queue is empty. A drained queue
+    // can still hold merged entries whose post-merge verification is unresolved
+    // (e.g. an externally-merged PR), and verifyMergedEntriesPostPush below is
+    // the only thing that advances them. depth=0 simply skips the active loop.
     // Process up to speculativeDepth entries. GitHub truth checks are
     // bounded by this window — we never scan the full queue.
     const depth = Math.min(ctx.speculativeDepth, allActive.length);
@@ -91,10 +93,10 @@ export async function reconcile(ctx) {
     await verifyMergedEntriesPostPush(ctx);
 }
 async function verifyMergedEntriesPostPush(ctx) {
-    const mergedEntries = ctx.store.listAll(ctx.repoId).filter((entry) => entry.status === "merged");
+    // Targeted query (not listAll) so an idle repo with a large merged history
+    // doesn't scan every terminal row each tick — only the unresolved ones.
+    const mergedEntries = ctx.store.listPostMergePending(ctx.repoId);
     for (const entry of mergedEntries) {
-        if (entry.postMergeStatus === "pass" || entry.postMergeStatus === "fail")
-            continue;
         const postMergeSha = entry.postMergeSha ?? entry.specSha ?? entry.headSha;
         if (!postMergeSha) {
             continue;

package/dist/service-queue.js

@@ -67,6 +67,7 @@ export class MergeStewardQueueCommands {
             specTreeId: null,
             prTitle: params.prTitle ?? null,
             baseRefName: params.baseRefName ?? null,
+            decidedAt: null,
             enqueuedAt: new Date().toISOString(),
             updatedAt: new Date().toISOString(),
         };

package/dist/store.d.ts

@@ -10,6 +10,8 @@ export interface QueueStore {
     getEntryByPR(repoId: string, prNumber: number): QueueEntry | undefined;
     listActive(repoId: string): QueueEntry[];
     listAll(repoId: string): QueueEntry[];
+    /** Merged entries whose post-merge verification is unresolved (not pass/fail). */
+    listPostMergePending(repoId: string): QueueEntry[];
     insert(entry: QueueEntry): void;
     transition(entryId: string, to: QueueEntryStatus, patch?: Partial<Pick<QueueEntry, "headSha" | "baseSha" | "ciRunId" | "ciRetries" | "retryAttempts" | "lastFailedBaseSha" | "specBranch" | "specSha" | "specBasedOn" | "waitDetail" | "postMergeStatus" | "postMergeSha" | "postMergeSummary" | "postMergeCheckedAt" | "headPatchId" | "specTreeId">>, detail?: string): void;
     dequeue(entryId: string): void;

package/dist/types.d.ts

@@ -74,6 +74,14 @@ export interface QueueEntry {
     specTreeId: string | null;
     enqueuedAt: string;
     updatedAt: string;
+    /**
+     * Set once, when the entry first reaches a terminal status
+     * (merged/evicted/dequeued), and never bumped afterward — unlike
+     * updatedAt, which post-merge re-verification keeps moving. Lets the
+     * dashboard report an accurate "how long it took" (decidedAt - enqueuedAt)
+     * and "how long ago" (now - decidedAt). Null while still in flight.
+     */
+    decidedAt: string | null;
 }
 export type FailureClass = "main_broken" | "branch_local" | "integration_conflict" | "policy_blocked";
 export type CheckConclusion = "success" | "failure" | "pending";

package/dist/watch/ProjectDetailView.d.ts

@@ -11,6 +11,9 @@ type ContentLine = {
 } | {
     kind: "entry-header";
     entry: DashboardPrEntry;
+} | {
+    kind: "stack-line";
+    text: string;
 } | {
     kind: "summary-line";
     text: string;

package/dist/watch/ProjectDetailView.js

@@ -2,11 +2,17 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text, useStdout } from "ink";
 import { RepoRow } from "./OverviewView.js";
 import { clipSummary } from "./dashboard-model.js";
-import { formatTokenAge } from "./format.js";
+import { relativeTime } from "./format.js";
+import { formatDurationMs } from "../runtime-format.js";
 const PR_ID_WIDTH = 7;
 const PR_PHRASE_WIDTH = 20;
 const SUMMARY_INDENT = 9;
-const AGE_WIDTH = 4;
+const TIMING_WIDTH = 22;
+// "took 7m · 3m ago" for a finished entry; "running 12m" while in flight.
+function timingLabel(entry) {
+    const duration = formatDurationMs(entry.durationMs);
+    return entry.recencyAt != null ? `took ${duration} · ${relativeTime(entry.recencyAt)} ago` : `running ${duration}`;
+}
 function truncate(value, maxWidth) {
     if (value.length <= maxWidth)
         return value;
@@ -20,6 +26,9 @@ export function buildContentLines(repo, width) {
         if (index > 0)
             lines.push({ kind: "blank" });
         lines.push({ kind: "entry-header", entry });
+        if (entry.stackedOnPr != null) {
+            lines.push({ kind: "stack-line", text: `↳ stacked on #${entry.stackedOnPr} (merges after it)` });
+        }
         if (entry.summary) {
             const summaryText = clipSummary(entry.summary, {
                 maxLines: 3,
@@ -35,16 +44,19 @@ export function buildContentLines(repo, width) {
 function EntryHeaderRow({ entry, width }) {
     const idText = `#${entry.prNumber}`.padEnd(PR_ID_WIDTH, " ");
     const paddedPhrase = entry.phrase.padEnd(PR_PHRASE_WIDTH, " ");
-    const age = formatTokenAge(entry.eventAt);
-    const titleSpace = Math.max(0, width - (PR_ID_WIDTH + 3 + PR_PHRASE_WIDTH + 3 + AGE_WIDTH));
+    const timing = timingLabel(entry).padEnd(TIMING_WIDTH, " ");
+    const titleSpace = Math.max(0, width - (PR_ID_WIDTH + 3 + PR_PHRASE_WIDTH + 3 + TIMING_WIDTH));
     const title = entry.title && entry.title !== entry.phrase && titleSpace >= 8
         ? truncate(entry.title, titleSpace)
         : "";
-    return (_jsxs(Box, { children: [_jsx(Text, { color: entry.color, children: idText }), _jsx(Text, { color: entry.color, children: entry.glyph }), _jsx(Text, { children: `  ${paddedPhrase}` }), _jsx(Text, { dimColor: true, children: `  ${age}` }), title ? _jsx(Text, { dimColor: true, children: `  ${title}` }) : null] }));
+    return (_jsxs(Box, { children: [_jsx(Text, { color: entry.color, children: idText }), _jsx(Text, { color: entry.color, children: entry.glyph }), _jsx(Text, { children: `  ${paddedPhrase}` }), _jsx(Text, { dimColor: true, children: `  ${timing}` }), title ? _jsx(Text, { dimColor: true, children: `  ${title}` }) : null] }));
 }
 function renderLine(line, key, width) {
     if (line.kind === "blank")
         return _jsx(Box, { children: _jsx(Text, { children: " " }) }, key);
+    if (line.kind === "stack-line") {
+        return (_jsxs(Box, { children: [_jsx(Text, { children: " ".repeat(SUMMARY_INDENT) }), _jsx(Text, { color: "gray", children: line.text })] }, key));
+    }
     if (line.kind === "summary-line") {
         return (_jsxs(Box, { children: [_jsx(Text, { children: " ".repeat(SUMMARY_INDENT) }), _jsx(Text, { dimColor: true, children: line.text })] }, key));
     }

package/dist/watch/dashboard-model.d.ts

@@ -20,6 +20,16 @@ export interface DashboardToken {
     color: DashboardTokenColor;
     kind: DashboardTokenKind;
     eventAt: number;
+    /** Queue position; active entries are ordered by this so the stack/queue order shows. */
+    position: number;
+    /** Whether the entry is still in flight (not merged/evicted/dequeued). */
+    active: boolean;
+    /** PR number this entry's speculative spec is stacked on, when that parent is still active. */
+    stackedOnPr: number | null;
+    /** How long the queue processing took: enqueue -> decided (terminal) or enqueue -> now (active). */
+    durationMs: number;
+    /** Completion instant (decidedAt) the views age against; null while in flight. */
+    recencyAt: number | null;
 }
 export interface DashboardPrEntry extends DashboardToken {
     phrase: string;

package/dist/watch/dashboard-model.js

@@ -121,12 +121,19 @@ function overrideKind(kind, override) {
         return "error";
     return kind;
 }
-function repoEntriesFromSnapshot(snapshot, cutoff) {
+function repoEntriesFromSnapshot(snapshot, cutoff, now) {
     const latest = pickLatestPerPR(snapshot.entries);
     const head = latest
         .filter((entry) => isActive(entry.status))
         .sort((a, b) => a.position - b.position)[0] ?? null;
     const queueBlocked = queueBlockMatchesEntry(snapshot.queueBlock, head);
+    // Resolve speculative stacking: an entry's spec can be built on top of
+    // another entry's spec (specBasedOn -> that entry's id). Map ids to PR
+    // numbers so the views can show "stacked on #N". Only surface the link
+    // when the parent is still active, since a merged parent collapses the stack.
+    const idToEntry = new Map();
+    for (const entry of latest)
+        idToEntry.set(entry.id, entry);
     const byPr = new Map();
     for (const entry of latest) {
         const active = isActive(entry.status);
@@ -140,13 +147,26 @@ function repoEntriesFromSnapshot(snapshot, cutoff) {
         const glyph = GLYPH[kind];
         const color = COLOR[kind];
         const phrase = entryPhrase(entry, { isHead, queueBlocked });
+        const parent = entry.specBasedOn ? idToEntry.get(entry.specBasedOn) ?? null : null;
+        const stackedOnPr = parent && isActive(parent.status) ? parent.prNumber : null;
+        // decidedAt is the terminal-transition time (never bumped by post-merge
+        // re-checks). Duration = enqueue -> decided (or -> now while in flight);
+        // recencyAt = the completion instant the views age against.
+        const enqueuedAt = timestamp(entry.enqueuedAt);
+        const decidedAt = active ? null : timestamp(entry.decidedAt) || timestamp(entry.updatedAt);
+        const durationMs = Math.max(0, (decidedAt ?? now) - enqueuedAt);
         const item = {
             prNumber: entry.prNumber,
             glyph,
             color,
             kind,
             phrase,
-            eventAt: timestamp(entry.updatedAt),
+            eventAt: decidedAt ?? timestamp(entry.updatedAt),
+            position: entry.position,
+            active,
+            stackedOnPr,
+            durationMs,
+            recencyAt: decidedAt,
         };
         const summary = entrySummary(entry);
         if (summary)
@@ -156,7 +176,16 @@ function repoEntriesFromSnapshot(snapshot, cutoff) {
             item.title = title;
         byPr.set(entry.prNumber, item);
     }
+    // Active entries first, in queue/stack order (by position, head first) so
+    // speculative stacks read top-to-bottom; decided entries follow, newest-first.
     return [...byPr.values()].sort((left, right) => {
+        if (left.active !== right.active)
+            return left.active ? -1 : 1;
+        if (left.active) {
+            if (left.position !== right.position)
+                return left.position - right.position;
+            return left.prNumber - right.prNumber;
+        }
         const leftOrder = tokenSortOrder(left.kind);
         const rightOrder = tokenSortOrder(right.kind);
         if (leftOrder !== rightOrder)
@@ -188,12 +217,12 @@ export function buildDashboard(repos, opts = {}) {
                 offlineMessage: message,
             };
         }
-        const entries = repoEntriesFromSnapshot(snapshot, cutoff);
+        const entries = repoEntriesFromSnapshot(snapshot, cutoff, now);
         const latestActivityAt = entries.reduce((max, entry) => Math.max(max, entry.eventAt), 0);
         return {
             repoId: repo.repoId,
             repoFullName: repo.repoFullName,
-            tokens: entries.map(({ prNumber, glyph, color, kind, eventAt }) => ({ prNumber, glyph, color, kind, eventAt })),
+            tokens: entries.map(({ prNumber, glyph, color, kind, eventAt, position, active, stackedOnPr, durationMs, recencyAt }) => ({ prNumber, glyph, color, kind, eventAt, position, active, stackedOnPr, durationMs, recencyAt })),
             entries,
             latestActivityAt,
             hasActivity: entries.length > 0,

package/dist/watch/format.d.ts

@@ -11,6 +11,9 @@ export declare function formatRepoTokenText(token: {
     prNumber: number;
     glyph: string;
     eventAt: number;
+    stackedOnPr?: number | null;
+    durationMs?: number | null;
+    recencyAt?: number | null;
 }): string;
 export declare function mergeWaitState(entry: {
     status: QueueEntryStatus;

package/dist/watch/format.js

@@ -1,3 +1,4 @@
+import { formatDurationMs } from "../runtime-format.js";
 const QUEUE_SYMBOLS = {
     inProgress: "\u25cf",
     checkPassed: "\u2713",
@@ -49,7 +50,15 @@ export function formatTokenAge(eventAt) {
     return relativeTime(eventAt).padStart(4, " ");
 }
 export function formatRepoTokenText(token) {
-    return `#${token.prNumber} ${token.glyph} ${relativeTime(token.eventAt)}`;
+    // A leading connector marks an entry whose spec is speculatively stacked on
+    // the PR shown just before it, so the queue order reads as a stack.
+    const stackMark = token.stackedOnPr != null ? "↳" : "";
+    // Two times: how long it took (duration) and, for finished entries, how long
+    // ago it finished (recency), joined as "took·ago" e.g. "7m·3m". In-flight
+    // entries show only the running duration.
+    const duration = token.durationMs != null ? formatDurationMs(token.durationMs) : relativeTime(token.eventAt);
+    const timing = token.recencyAt != null ? `${duration}·${relativeTime(token.recencyAt)}` : duration;
+    return `${stackMark}#${token.prNumber} ${token.glyph} ${timing}`;
 }
 export function mergeWaitState(entry) {
     if (!entry || entry.status !== "merging" || !entry.waitDetail) {

package/package.json

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