gh-stack 0.17.2 → 0.19.0

package/src/commands/sync.ts

@@ -7,91 +7,132 @@ import {
   findStackForBranch,
   getOrderedBranches,
   removeBranchFromStack,
-  saveRestackState,
   stackBase,
   writeMetadata,
 } from "../lib/metadata.ts";
 import { ensureMetadata, ensureCleanWorkingTree, ensureValidStack } from "../lib/safety.ts";
+import { resolveFlag } from "../lib/config.ts";
 import { takeSnapshot } from "../lib/snapshot.ts";
-import { confirmAction } from "../lib/ui.ts";
+import { guardRemoteContent } from "../lib/remote-guard.ts";
 import { getPrInfo } from "../lib/github.ts";
-import { planMerges, advanceNewBottom, type BranchReview } from "../lib/advance.ts";
+import { planMerges, advanceNewBottom, type BranchReview, type MergePlan } from "../lib/advance.ts";
 import type { StackMetadata } from "../types.ts";
+import restack, {
+  notePendingRun,
+  refuseRebaseInProgress,
+  resolvePush,
+  routePendingRun,
+  syncChain,
+} from "./restack.ts";
 
 export default async function sync(args: string[]): Promise<void> {
   const dryRun = args.includes("--dry-run");
+  const fresh = args.includes("--fresh");
 
   if (args.includes("--help")) {
     console.log(`
 gh-stack sync — Sync base with main + restack all
 
 USAGE
-  gh-stack sync [--dry-run]
+  gh-stack sync [--dry-run] [--no-push | --push] [--fresh]
 
 Fetches latest main, rebases the base branch onto main,
 then restacks all children. Equivalent to running restack
 with the base branch included.
+
+OPTIONS
+  --dry-run   Show what would happen without executing
+  --no-push   Rebase locally only — never push or retarget PRs
+              (also GH_STACK_NO_PUSH=1, or \`[restack] push = false\` in
+              config; see gh-stack config). Wins over --yes for pushes
+  --push      Push even when a config default or env var says not to
+  --resume    Same as \`gh-stack restack --resume\`
+  --fresh     Discard an interrupted restack/sync instead of resuming it
+  --overwrite-remote
+              Rewrite branches even though origin has commits they lack.
+              Those commits are dropped from origin
+
+If an interrupted restack or sync is pending, sync asks whether to resume it
+(with --yes it resumes) rather than starting over on top of it.
+
+Before rewriting anything, sync stops if a branch's copy on origin has
+commits the local branch never had (e.g. the squash commit \`merge --collapse\`
+adds on GitHub). Pull or cherry-pick them first; see \`gh-stack restack --help\`.
 `);
     return;
   }
 
+  // Only explicit push flags (and --overwrite-remote) carry over to a resume:
+  // it otherwise keeps the push decision of the run it resumes.
+  const pushFlags = args.filter(
+    (a) => a === "--push" || a === "--no-push" || a === "--overwrite-remote",
+  );
+  const resumeRun = () => restack(["--resume", ...pushFlags]);
+  if (args.includes("--resume")) {
+    await resumeRun();
+    return;
+  }
+
   // Reject if a git rebase is already in progress. Letting sync run on top
   // of a half-finished rebase produces deeply confusing state — make the
   // user finish or abort it first.
   if (await git.isRebaseInProgress()) {
-    p.cancel(
-      `Git rebase already in progress.\n\n  Finish or abort it first:\n    ${pc.green("git rebase --continue")}\n    ${pc.red("git rebase --abort")}\n\n  Then re-run ${pc.green("gh-stack sync")}.`,
-    );
-    process.exit(1);
+    await refuseRebaseInProgress("sync");
   }
 
-  await ensureCleanWorkingTree();
-
-  const meta = await ensureMetadata();
-  const currentBranch = await git.currentBranch();
-  const stackName = findStackForBranch(meta, currentBranch);
-
-  if (!stackName) {
-    p.cancel(
-      `Branch ${pc.blue(currentBranch)} is not in any stack.\n\n  Track it first (no push/PR):\n    ${pc.green("gh-stack add")}\n\n  Or open its PR with:\n    ${pc.green("gh-stack submit")}`,
-    );
-    process.exit(1);
+  // An interrupted restack/sync is pending: resume it rather than starting a
+  // new sync on top of it (#29).
+  if (dryRun) {
+    await notePendingRun();
+  } else if (
+    (await routePendingRun("sync", {
+      fresh,
+      preflight: async () => void (await syncPreconditions(args)),
+    })) === "resume"
+  ) {
+    await resumeRun();
+    return;
   }
 
+  const push = await resolvePush(args);
+  const noPush = !push.value;
+  const { meta, stackName } = await syncPreconditions(args);
   let stack = meta.stacks[stackName]!;
-  await ensureValidStack(meta, stackName);
   let ordered = getOrderedBranches(stack);
 
-  if (ordered.length === 0) {
-    p.cancel("No branches in this stack");
-    process.exit(1);
-  }
-
   p.intro(pc.cyan("Git Stack Sync"));
 
   // Find the root branch (whose parent is the stack's base)
   const base = stackBase(stack);
-  const baseIsTrunk = base === "main" || base === "master";
-
-  // sync only makes sense for trunk-rooted stacks — it fetches main and
-  // rebases onto it. A split stack is rooted on a branch in another stack, so
-  // syncing it means restacking onto that base (handled by `restack`), or
-  // re-rooting onto main once the parent stack has merged.
-  if (!baseIsTrunk) {
-    p.cancel(
-      `${pc.yellow(stackName)} is based on ${pc.yellow(base)}, not main — sync doesn't apply.\n\n` +
-        `  • Parent moved? Restack onto it:   ${pc.green("gh-stack restack")}\n` +
-        `  • Parent stack merged to main?     ${pc.green("gh-stack restack --onto main")}`,
-    );
-    process.exit(1);
-  }
 
   // Catch up to reality first: if the bottom PR(s) already landed on the trunk
   // outside gh-stack (e.g. the GitHub web UI), the stack metadata still lists
   // them. A plain rebase onto main would then replay their now-squashed commits
   // and conflict — so advance past them (re-rooting the survivor onto main with
   // `--onto`) before the normal sync runs. (#20)
-  const advance = await advanceMergedBottoms(meta, stackName, base, dryRun);
+  const merged = await findMergedBottoms(meta, stackName);
+
+  // Nothing is rewritten yet: stop here if origin holds commits the local
+  // branches lack, e.g. a collapse's squash commit on the base branch (#28).
+  // Bottoms whose PRs already merged are skipped: the advance drops them
+  // rather than rewriting them, and after `merge --approved` they're exactly
+  // where the collapse's squash commits live.
+  const mergedBranches = new Set(merged.steps.map((step) => step.branch));
+  const verified = await guardRemoteContent(
+    meta,
+    ordered.filter((b) => !mergedBranches.has(b)),
+    { command: "sync", overwrite: args.includes("--overwrite-remote"), dryRun },
+  );
+
+  const advance = await advanceMergedBottoms(
+    meta,
+    stackName,
+    base,
+    dryRun,
+    noPush,
+    merged,
+    verified,
+  );
   if (advance.drained) {
     p.outro(pc.green("Bottom PR(s) already merged — stack fully drained & archived."));
     return;
@@ -149,77 +190,55 @@ with the base branch included.
   // need to find when restacking children. (See resolveRestackBoundary.)
   await takeSnapshot(meta, stackName, "sync");
 
-  // Step 1: Rebase base branch onto main
-  console.log();
-  console.log(pc.cyan("━".repeat(40)));
-  console.log(`${pc.blue("Step 1:")} Rebase ${pc.yellow(baseBranch)} onto main`);
-  console.log(pc.cyan("━".repeat(40)));
-  console.log();
-
-  // Check if already up to date
-  if (await git.isAncestor("origin/main", baseBranch)) {
-    p.log.success(`${baseBranch} is already up to date with main`);
-  } else if (dryRun) {
-    p.log.warn(`[DRY RUN] Would rebase ${baseBranch} onto origin/main`);
-  } else {
-    const confirmed = await confirmAction(`Rebase ${pc.yellow(baseBranch)} onto origin/main?`);
-    if (!confirmed) {
-      p.cancel("Cancelled");
-      process.exit(0);
-    }
+  // Rebase the root onto main, push it, then restack every branch above it —
+  // one run, saved after every step, so `restack --resume` can finish it.
+  await syncChain(meta, stackName, ordered, { trunkRef: "origin/main", push, verified });
+}
 
-    p.log.info(`Checking out ${pc.yellow(baseBranch)}...`);
-    await git.checkout(baseBranch);
-
-    // Save restack state BEFORE rebasing so --resume can find it.
-    // The chain is the full ordered list — base branch at index 0,
-    // so resume knows where we were and can continue with children.
-    await saveRestackState({
-      current_index: 0,
-      stack_name: stackName,
-      chain: ordered,
-    });
-
-    p.log.info("Rebasing onto origin/main...");
-    const success = await git.rebase("origin/main");
-
-    if (!success) {
-      console.log();
-      p.log.error("Rebase conflict — resolve and run:");
-      console.log(`  ${pc.green("git rebase --continue")}`);
-      console.log(`  ${pc.green("gh-stack restack --resume")}`);
-      process.exit(2);
-    }
+/**
+ * What a new sync needs before it changes anything: a clean tree, a valid push
+ * setting, and the current branch in a trunk-rooted stack. Also the preflight
+ * for discarding an interrupted run, so a sync that would refuse leaves that
+ * run intact.
+ */
+async function syncPreconditions(
+  args: string[],
+): Promise<{ meta: StackMetadata; stackName: string }> {
+  await resolveFlag("restack.push", args); // a bad setting stops here
+  await ensureCleanWorkingTree();
 
-    p.log.success("Base branch rebased onto main");
+  const meta = await ensureMetadata();
+  const currentBranch = await git.currentBranch();
+  const stackName = findStackForBranch(meta, currentBranch);
 
-    // Prompt to push base
-    await promptForcePush(baseBranch);
+  if (!stackName) {
+    p.cancel(
+      `Branch ${pc.blue(currentBranch)} is not in any stack.\n\n  Track it first (no push/PR):\n    ${pc.green("gh-stack add")}\n\n  Or open its PR with:\n    ${pc.green("gh-stack submit")}`,
+    );
+    process.exit(1);
   }
 
-  // Step 2: Restack children
-  const children = ordered.slice(1);
-
-  if (children.length === 0) {
-    p.outro(pc.green("Sync complete! (no children to restack)"));
-    return;
+  const stack = meta.stacks[stackName]!;
+  await ensureValidStack(meta, stackName);
+  if (getOrderedBranches(stack).length === 0) {
+    p.cancel("No branches in this stack");
+    process.exit(1);
   }
 
-  console.log();
-  console.log(pc.cyan("━".repeat(40)));
-  console.log(`${pc.blue("Step 2:")} Restack ${children.length} child branch(es)`);
-  console.log(pc.cyan("━".repeat(40)));
-  console.log();
-
-  // Delegate to restack for the remaining branches
-  // We import and run restack in --rebase mode effectively
-  const { default: restack } = await import("./restack.ts");
-
-  // Switch to first child and run restack
-  if (children.length > 0) {
-    await git.checkout(children[0]!);
-    await restack(dryRun ? ["--dry-run"] : []);
+  // sync only makes sense for trunk-rooted stacks — it fetches main and
+  // rebases onto it. A split stack is rooted on a branch in another stack, so
+  // syncing it means restacking onto that base (handled by `restack`), or
+  // re-rooting onto main once the parent stack has merged.
+  const base = stackBase(stack);
+  if (base !== "main" && base !== "master") {
+    p.cancel(
+      `${pc.yellow(stackName)} is based on ${pc.yellow(base)}, not main — sync doesn't apply.\n\n` +
+        `  • Parent moved? Restack onto it:   ${pc.green("gh-stack restack")}\n` +
+        `  • Parent stack merged to main?     ${pc.green("gh-stack restack --onto main")}`,
+    );
+    process.exit(1);
   }
+  return { meta, stackName };
 }
 
 /** Result of the merged-bottom catch-up pass. */
@@ -241,19 +260,15 @@ interface AdvanceOutcome {
  * Returns what happened so the caller can re-derive the root or short-circuit.
  * In dry-run it reports and makes no changes.
  */
-async function advanceMergedBottoms(
-  meta: StackMetadata,
-  stackName: string,
-  trunk: string,
-  dryRun: boolean,
-): Promise<AdvanceOutcome> {
+/**
+ * The contiguous bottom branches whose PRs already merged (outside gh-stack,
+ * or the base of a `merge --approved`), walking bottom-up and stopping at the
+ * first that isn't.
+ */
+async function findMergedBottoms(meta: StackMetadata, stackName: string): Promise<MergePlan> {
   const stack = meta.stacks[stackName]!;
-  const ordered = getOrderedBranches(stack);
-
-  // Walk bottom-up gathering PR state; stop at the first branch that isn't a
-  // merged PR (only contiguous merged bottoms can be advanced past).
   const reviews: BranchReview[] = [];
-  for (const branch of ordered) {
+  for (const branch of getOrderedBranches(stack)) {
     const pr = stack.branches[branch]?.pr ?? null;
     let prState: string | null = null;
     if (pr != null) {
@@ -263,8 +278,21 @@ async function advanceMergedBottoms(
     reviews.push({ branch, pr, prState, reviewDecision: null });
     if (prState !== "MERGED") break;
   }
+  return planMerges(reviews, { approveAndMerge: false });
+}
+
+async function advanceMergedBottoms(
+  meta: StackMetadata,
+  stackName: string,
+  trunk: string,
+  dryRun: boolean,
+  noPush: boolean,
+  plan: MergePlan,
+  verified: Map<string, string>,
+): Promise<AdvanceOutcome> {
+  const stack = meta.stacks[stackName]!;
+  const ordered = getOrderedBranches(stack);
 
-  const plan = planMerges(reviews, { approveAndMerge: false });
   if (plan.steps.length === 0) {
     return { detected: false, advanced: false, drained: false };
   }
@@ -302,6 +330,8 @@ async function advanceMergedBottoms(
         childPr,
         targetRef,
         recordedBase: trunk,
+        push: !noPush,
+        expect: verified.get(child),
       });
       if (!res.ok) {
         console.log();
@@ -344,33 +374,3 @@ async function advanceMergedBottoms(
 
   return { detected: true, advanced: true, drained: false };
 }
-
-async function promptForcePush(branch: string): Promise<void> {
-  if (branch === "main" || branch === "master") return;
-  if (!(await git.remoteBranchExists(branch))) return;
-
-  const localSha = await git.revParse(branch);
-  let remoteSha: string;
-  try {
-    remoteSha = await git.revParse(`origin/${branch}`);
-  } catch {
-    return;
-  }
-
-  if (localSha === remoteSha) return;
-
-  console.log();
-  p.log.info(`${pc.yellow("⚠")} ${branch} is out of sync with remote`);
-
-  const confirmed = await confirmAction("Push with --force-with-lease?");
-  if (confirmed) {
-    const ok = await git.forcePushWithLease(branch);
-    if (ok) {
-      p.log.success("Pushed successfully");
-    } else {
-      p.log.error("Push failed");
-    }
-  } else {
-    p.log.warn("Skipping push");
-  }
-}

package/src/commands/undo.ts

@@ -4,6 +4,7 @@ import * as git from "../lib/git.ts";
 import pc from "picocolors";
 import { ensureMetadata, ensureCleanWorkingTree } from "../lib/safety.ts";
 import { getLastSnapshot, popSnapshot } from "../lib/snapshot.ts";
+import { clearRestackState, loadRestackState } from "../lib/metadata.ts";
 import { confirmAction } from "../lib/ui.ts";
 import { $ } from "bun";
 
@@ -72,5 +73,15 @@ a destructive operation (restack, merge, sync, remove).
   // Pop the snapshot
   await popSnapshot(meta);
 
+  // An unfinished run on this stack was rewriting the branches just restored;
+  // resuming it would push the restored tips as if they were its results.
+  const run = await loadRestackState().catch(() => null); // an unusable state is left for --fresh
+  if (run && !run.finished_at && run.stack_name === snapshot.stack) {
+    await clearRestackState();
+    p.log.info(
+      `Discarded the interrupted ${run.command}'s saved state (its branches were restored).`,
+    );
+  }
+
   p.outro(pc.green("Undo complete!"));
 }

package/src/commands/update-prs.ts

@@ -17,6 +17,7 @@ import {
 } from "../lib/metadata.ts";
 import { ensureMetadata } from "../lib/safety.ts";
 import {
+  findOpenPrForBranch,
   getPrInfo,
   getPrBody,
   updatePrBody,
@@ -102,6 +103,32 @@ function vizHash(viz: string): string {
   return createHash("sha1").update(viz).digest("hex");
 }
 
+/**
+ * Whether a live PR body already carries exactly this viz block. GitHub
+ * stores bodies edited in its web UI with CRLF line endings, so normalize
+ * before comparing — otherwise every such PR would look perpetually stale.
+ */
+export function bodyHasViz(body: string, viz: string): boolean {
+  return body.replace(/\r\n/g, "\n").includes(viz);
+}
+
+/**
+ * Record PR numbers for tracked branches whose PR was opened outside gh-stack
+ * (e.g. `gh pr create`), by looking up the open PR for each PR-less branch.
+ * Only an unambiguous single match is adopted. Returns the branches adopted —
+ * the caller persists metadata when non-empty. (#35)
+ */
+export async function discoverMissingPrs(stack: Stack, ordered: string[]): Promise<string[]> {
+  const missing = ordered.filter((b) => stack.branches[b]!.pr == null);
+  const found = await mapLimit(missing, 8, async (branch) => {
+    const pr = await findOpenPrForBranch(branch);
+    if (pr == null) return null;
+    stack.branches[branch]!.pr = pr;
+    return branch;
+  });
+  return found.filter((b): b is string => b != null);
+}
+
 /** Splice the rendered viz block into a PR body, replacing any existing one. */
 function mergeViz(body: string, viz: string): string {
   let base = body;
@@ -135,6 +162,7 @@ export function numberedTitle(title: string, position: number, total: number): s
 
 export interface TitleResult {
   updated: number; // PR titles we edited on GitHub
+  updatedBranches: string[]; // …and their branches, for per-branch reporting (submit --json)
   dirty: boolean; // metadata mutated (cached prTitle changed) — caller persists
 }
 
@@ -184,23 +212,27 @@ export async function reconcilePrTitles(
 
   const items = ordered.map((name) => {
     const bm = stack.branches[name]!;
-    return { pr: bm.pr, prTitle: bm.prTitle, override: overrides[name], bm };
+    return { name, pr: bm.pr, prTitle: bm.prTitle, override: overrides[name], bm };
   });
 
-  const oks = await mapLimit(planTitleEdits(items), 8, async ({ item, desired }) => {
+  const edits = planTitleEdits(items);
+  const oks = await mapLimit(edits, 8, async ({ item, desired }) => {
     const ok = await updatePrTitle(item.pr!, desired);
     if (ok) item.bm.prTitle = desired;
     return ok;
   });
 
-  const updated = oks.filter(Boolean).length;
-  return { updated, dirty: dirtyBackfill || updated > 0 };
+  const updatedBranches = edits.filter((_, i) => oks[i]).map(({ item }) => item.name);
+  const updated = updatedBranches.length;
+  return { updated, updatedBranches, dirty: dirtyBackfill || updated > 0 };
 }
 
 export interface VizResult {
   updated: number; // PRs whose description we PATCHed
+  updatedBranches: string[]; // …and their branches, for per-branch reporting (submit --json)
   unchanged: number; // PRs skipped because their rendered block was identical
   skipped: number; // branches with no PR
+  skippedBranches: string[]; // …and their names, so callers can say which
   dirty: boolean; // metadata mutated (caller should persist)
 }
 
@@ -213,12 +245,17 @@ export interface VizResult {
  * body: the override is used as the base instead of the current GitHub body,
  * the managed `📚 Stacked on` block is re-merged into it, and the PR is updated
  * even if the viz block itself didn't change.
+ *
+ * `verifyLive` checks each PR whose cached hash matches against its actual
+ * body, so a viz block removed by an external edit (`gh pr edit`, the web UI)
+ * is restored rather than reported "unchanged". It costs one read per PR, so
+ * `update-prs` opts in while `submit` stays on the cheap hash check. (#34)
  */
 export async function refreshStackViz(
   meta: StackMetadata,
   stack: Stack,
   ordered: string[],
-  opts: { force?: boolean; bodyOverrides?: Record<string, string> } = {},
+  opts: { force?: boolean; verifyLive?: boolean; bodyOverrides?: Record<string, string> } = {},
 ): Promise<VizResult> {
   const force = opts.force ?? false;
   const bodyOverrides = opts.bodyOverrides ?? {};
@@ -239,28 +276,45 @@ export async function refreshStackViz(
       const bm = stack.branches[info.branch]!;
       // A body override forces the PATCH even when the viz block is unchanged.
       const overridden = bodyOverrides[info.branch] != null;
-      return { info, viz, hash, bm, needsUpdate: force || overridden || bm.vizHash !== hash };
+      const needsUpdate = force || overridden || bm.vizHash !== hash;
+      return { info, viz, hash, bm, needsUpdate, liveBody: null as string | null };
     });
 
+  if (opts.verifyLive) {
+    await mapLimit(
+      plans.filter((plan) => !plan.needsUpdate),
+      8,
+      async (plan) => {
+        const body = await getPrBody(plan.info.prNumber!);
+        if (body !== null && !bodyHasViz(body, plan.viz)) {
+          plan.needsUpdate = true;
+          plan.liveBody = body;
+        }
+      },
+    );
+  }
+
   const toUpdate = plans.filter((plan) => plan.needsUpdate);
   const unchanged = plans.length - toUpdate.length;
-  const skipped = branchInfos.length - plans.length;
+  const skippedBranches = branchInfos.filter((b) => b.prNumber == null).map((b) => b.branch);
+  const skipped = skippedBranches.length;
 
   const oks = await mapLimit(toUpdate, 8, async (plan) => {
     // `submit -b` replaces the body; otherwise keep the PR's current body and
     // just re-merge the viz block into it.
     const override = bodyOverrides[plan.info.branch];
-    const body = override ?? (await getPrBody(plan.info.prNumber!));
+    const body = override ?? plan.liveBody ?? (await getPrBody(plan.info.prNumber!));
     if (body === null) return false;
     const ok = await updatePrBody(plan.info.prNumber!, mergeViz(body, plan.viz));
     if (ok) plan.bm.vizHash = plan.hash;
     return ok;
   });
 
-  const updated = oks.filter(Boolean).length;
+  const updatedBranches = toUpdate.filter((_, i) => oks[i]).map((plan) => plan.info.branch);
+  const updated = updatedBranches.length;
   if (updated > 0) dirty = true;
 
-  return { updated, unchanged, skipped, dirty };
+  return { updated, updatedBranches, unchanged, skipped, skippedBranches, dirty };
 }
 
 export default async function updatePrs(args: string[]): Promise<void> {
@@ -272,8 +326,13 @@ USAGE
   gh-stack update-prs [--force]
 
 Updates all PRs in the current stack with a standardized stack section
-showing the tree structure, PR links, and per-PR stack index. By default
-PRs whose rendered block is unchanged are skipped; --force rewrites all.
+showing the tree structure, PR links, and per-PR stack index. Each PR's
+live description is checked, so a stack section removed by an outside
+edit (gh pr edit, the GitHub UI) is restored. PRs that already show the
+current section are left alone; --force rewrites all.
+
+Tracked branches with no recorded PR are looked up on GitHub first, so a
+PR opened outside gh-stack (e.g. gh pr create) is adopted automatically.
 `);
     return;
   }
@@ -298,17 +357,30 @@ PRs whose rendered block is unchanged are skipped; --force rewrites all.
 
   const s = p.spinner();
   s.start("Updating PR titles & descriptions...");
+  const adopted = await discoverMissingPrs(stack, ordered);
   const titles = await reconcilePrTitles(stack, ordered);
-  const result = await refreshStackViz(meta, stack, ordered, { force });
+  const result = await refreshStackViz(meta, stack, ordered, { force, verifyLive: true });
   s.stop("Done");
 
-  if (titles.dirty || result.dirty) await writeMetadata(meta);
+  if (adopted.length > 0 || titles.dirty || result.dirty) await writeMetadata(meta);
+
+  for (const b of adopted) {
+    p.log.success(
+      `Adopted PR #${stack.branches[b]!.pr} for ${pc.blue(b)} (opened outside gh-stack)`,
+    );
+  }
+  if (result.skippedBranches.length > 0) {
+    p.log.warn(
+      `Skipped ${result.skippedBranches.length} branch(es) with no open PR: ${result.skippedBranches.map((b) => pc.blue(b)).join(", ")}\n` +
+        `  Open them with ${pc.green("gh-stack submit")}`,
+    );
+  }
 
   console.log();
   p.outro(
     pc.green(
       `Updated ${result.updated} description(s), ${titles.updated} title(s)` +
-        (result.unchanged > 0 ? `, ${result.unchanged} unchanged` : "") +
+        (result.unchanged > 0 ? `, ${result.unchanged} already up to date` : "") +
         (result.skipped > 0 ? `, ${result.skipped} without PRs` : ""),
     ),
   );