@kaynooo/forgejo-tools 0.5.1 → 0.7.0

package/dist/cli.js

@@ -2,17 +2,17 @@
 // @bun
 
 // src/cli.ts
-import process8 from "process";
+import process15 from "process";
 
 // ../kit/src/args.ts
-import process3 from "process";
+import process4 from "process";
 import { parseArgs } from "util";
 
 // ../kit/src/format.ts
-import process2 from "process";
+import process3 from "process";
 
 // ../kit/src/style.ts
-import process from "process";
+import process2 from "process";
 
 // ../../node_modules/.bun/@kaynooo+utils@2.31.0+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-mtetydvc.js
 function x(s) {
@@ -276,12 +276,30 @@ function le(i = {}) {
 var t = le();
 
 // ../kit/src/style.ts
-function takesControlCodes(stream, env = process.env) {
+var MARKS = {
+  ok: { symbol: "\u2713", word: "ok:", paint: (colors) => colors.green },
+  warn: { symbol: "!", word: "warning:", paint: (colors) => colors.yellow },
+  problem: { symbol: "\u2717", word: "error:", paint: (colors) => colors.red },
+  note: { symbol: "\xB7", word: "note:", paint: (colors) => colors.dim }
+};
+function takesControlCodes(stream, env = process2.env) {
   return stream.isTTY === true && env.NO_COLOR === undefined && env.NODE_DISABLE_COLORS === undefined && env.TERM !== "dumb";
 }
-function paint(stream, env = process.env) {
+function paint(stream, env = process2.env) {
   return le({ stream: { isTTY: takesControlCodes(stream, env) }, env });
 }
+function marked(mark, text, stream, detail, env = process2.env) {
+  const colors = paint(stream, env);
+  const { symbol, word, paint: tint } = MARKS[mark];
+  const head = takesControlCodes(stream, env) ? tint(colors)(symbol) : word;
+  return `${head} ${text}${detail === undefined ? "" : ` ${colors.dim(detail)}`}`;
+}
+function note(text, detail) {
+  console.log(marked("note", text, process2.stdout, detail));
+}
+function warn(text, detail) {
+  console.error(marked("warn", text, process2.stderr, detail));
+}
 var STATUSES = {
   passed: { symbol: "\u2713", words: ["passed", "success", "succeeded", "ok"], paint: (colors) => colors.green },
   failed: { symbol: "\u2717", words: ["failed", "failure", "error", "errored"], paint: (colors) => colors.red },
@@ -290,6 +308,16 @@ var STATUSES = {
   skipped: { symbol: "-", words: ["skipped", "cancelled", "canceled", "manual"], paint: (colors) => colors.dim }
 };
 var STATUS_OF = new Map(Object.entries(STATUSES).flatMap(([status, { words }]) => words.map((word) => [word, status])));
+function statusOf(word) {
+  return STATUS_OF.get(word.toLowerCase());
+}
+function badge(word, stream, env = process2.env) {
+  const status = statusOf(word);
+  if (status === undefined || !takesControlCodes(stream, env))
+    return word;
+  const { symbol, paint: tint } = STATUSES[status];
+  return tint(paint(stream, env))(`${symbol} ${word}`);
+}
 
 // ../kit/src/format.ts
 var UNITS = [["d", 86400], ["h", 3600], ["m", 60], ["s", 1]];
@@ -336,7 +364,7 @@ function table(rows, { cellWidth, header = false, align = [], fit } = {}) {
       widths[index] = Math.max(widths[index] ?? 0, textWidth(cell));
   }
   const shown = fit === undefined ? cells : narrow(cells, widths, fit);
-  const colors = paint(process2.stdout);
+  const colors = paint(process3.stdout);
   const lines = shown.map((row) => row.map((cell, index) => {
     const width = widths[index] ?? 0;
     const gap = " ".repeat(Math.max(0, width - textWidth(cell)));
@@ -367,6 +395,26 @@ function printJson(value) {
   console.log(JSON.stringify(value, undefined, 2));
 }
 
+// ../kit/src/text.ts
+var ANSI = new RegExp(`${String.fromCharCode(27)}\\[[\\d;?]*[a-z]`, "gi");
+function distance(a, b) {
+  let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (const [i, left] of [...a].entries()) {
+    const current = [i + 1];
+    for (const [j, right] of [...b].entries())
+      current.push(Math.min((previous[j + 1] ?? 0) + 1, (current[j] ?? 0) + 1, (previous[j] ?? 0) + (left === right ? 0 : 1)));
+    previous = current;
+  }
+  return previous[b.length] ?? 0;
+}
+function closest(name, names) {
+  const started = names.find((known) => known.startsWith(name));
+  if (started !== undefined)
+    return started;
+  const [best] = names.map((known) => ({ known, far: distance(name, known) })).sort((a, b) => a.far - b.far);
+  return best !== undefined && best.far <= (name.length < 4 ? 1 : 2) ? best.known : undefined;
+}
+
 // ../kit/src/args.ts
 function jsonOption(holds) {
   return { type: "boolean", description: holds === undefined ? "print JSON" : `print JSON: ${holds}` };
@@ -386,8 +434,8 @@ function fail(message, code = 2, hint) {
 }
 
 class UsageError extends Exit {
-  constructor(message) {
-    super(message, 2);
+  constructor(message, hint) {
+    super(message, 2, hint);
   }
 }
 function badUsage(message) {
@@ -409,24 +457,70 @@ class Completing {
 var completion = { active: false };
 var OPTIONAL = /\[[^\]]+\]/g;
 var USAGE_PREFIX = /^usage:\s*/i;
-function usageLine(usage, colors = paint(process3.stdout)) {
+var FULL_STOP = /\.$/;
+var DASHES = /^-+/;
+function usageLine(usage, colors = paint(process4.stdout)) {
   return `${colors.bold("Usage:")} ${usage.replace(USAGE_PREFIX, "").replaceAll(OPTIONAL, (part) => colors.dim(part))}`;
 }
-function helpText(usage, options, colors = paint(process3.stdout)) {
-  return [usageLine(usage, colors), "", colors.bold("Options:"), ...optionRows(options, colors)].join(`
+function helpText(usage, options, colors = paint(process4.stdout), { examples = [], replaces } = {}) {
+  return [usageLine(usage, colors), ...replacesRows(replaces, colors), "", colors.bold("Options:"), ...optionRows(options, colors), ...exampleRows(examples, colors)].join(`
 `);
 }
-function optionRows(options, colors = paint(process3.stdout)) {
+function replacesRows(replaces, colors = paint(process4.stdout)) {
+  return replaces === undefined ? [] : ["", `${colors.bold("Instead of:")} ${replaces}`];
+}
+function wantsHelpJson(env = process4.env) {
+  return env.KIT_HELP === "json";
+}
+function description(usage, { examples = [], replaces } = {}) {
+  const lines = usage.replace(USAGE_PREFIX, "").split(`
+`);
+  const first = lines[0];
+  const colon = first.indexOf(": ");
+  const prose = lines[lines.indexOf("") + 1] ?? "";
+  const fallback = lines.includes("") ? `${prose.charAt(0).toLowerCase()}${prose.slice(1)}`.replace(FULL_STOP, "") : "";
+  return {
+    synopsis: colon === -1 ? first : first.slice(0, colon),
+    summary: colon === -1 ? fallback : first.slice(colon + 2),
+    ...replaces === undefined ? {} : { replaces },
+    examples: examples.map((example) => typeof example === "string" ? { line: example } : { line: example[0], note: example[1] })
+  };
+}
+function exampleRows(examples, colors = paint(process4.stdout)) {
+  if (examples.length === 0)
+    return [];
+  return ["", colors.bold("Examples:"), ...examples.map((example) => typeof example === "string" ? `  ${example}` : `  ${example[0]}  ${colors.dim(`# ${example[1]}`)}`)];
+}
+function optionRows(options, colors = paint(process4.stdout)) {
   const rows = Object.entries(options).map(([name, option]) => {
     const short = option.short === undefined ? "    " : `${colors.cyan(`-${option.short}`)}, `;
     const value = option.type === "string" ? ` ${colors.dim("<value>")}` : "";
-    return { flag: `${short}${colors.cyan(`--${name}`)}${value}`, width: `-x, --${name}`.length + (option.type === "string" ? " <value>".length : 0), description: option.description };
+    return { flag: `${short}${colors.cyan(`--${name}`)}${value}`, width: `-x, --${name}`.length + (option.type === "string" ? " <value>".length : 0), description: option.description ?? "" };
   });
   const width = Math.max(0, ...rows.map((row) => row.width));
-  return rows.map((row) => `  ${row.flag}${" ".repeat(width - row.width)}  ${colors.dim(row.description)}`);
+  return rows.map((row) => row.description === "" ? `  ${row.flag}` : `  ${row.flag}${" ".repeat(width - row.width)}  ${colors.dim(row.description)}`);
+}
+var OUTPUT_OPTIONS = {
+  color: { type: "string", description: "auto (on a terminal alone), always or never" },
+  plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
+};
+function applyOutput(color, plain, env = process4.env) {
+  const when = plain === true ? "never" : color ?? "auto";
+  if (when === "auto")
+    return;
+  if (when !== "always" && when !== "never")
+    badUsage(`--color takes auto, always or never, not ${when}`);
+  if (when === "always") {
+    env.FORCE_COLOR = "1";
+    delete env.NO_COLOR;
+  } else {
+    env.NO_COLOR = "1";
+    delete env.FORCE_COLOR;
+  }
 }
 function parse(args, usage, options, settings = {}) {
-  const all = { ...options, help: { type: "boolean", short: "h", description: "show this help" } };
+  const output = Object.fromEntries(Object.entries(OUTPUT_OPTIONS).filter(([name]) => !(name in options)));
+  const all = { ...options, ...output, help: { type: "boolean", short: "h", description: "show this help" } };
   if (completion.active)
     throw new Completing(all);
   const separator = settings.rest === true ? args.indexOf("--") : -1;
@@ -434,12 +528,15 @@ function parse(args, usage, options, settings = {}) {
   const rest = separator === -1 ? undefined : args.slice(separator + 1);
   let parsed;
   try {
-    parsed = parseArgs({ args: own, options: all, allowPositionals: true, allowNegative: settings.allowNegative === true, strict: true });
+    parsed = parseArgs({ args: joinDashValues(own, all), options: all, allowPositionals: true, allowNegative: settings.allowNegative === true, strict: true });
   } catch (error) {
-    badUsage(parseError(error));
+    const message = parseError(error);
+    throw new UsageError(message, nearestOption(message, all, settings.allowNegative === true));
   }
-  if (parsed.values.help === true) {
-    console.log(helpText(usage, all));
+  const values = parsed.values;
+  applyOutput("color" in output ? values.color : undefined, "plain" in output ? values.plain : undefined);
+  if (values.help === true) {
+    console.log(wantsHelpJson() ? JSON.stringify(description(usage, settings)) : helpText(usage, all, undefined, settings));
     throw new HelpShown;
   }
   if (settings.positionals !== undefined)
@@ -454,16 +551,52 @@ function checkPositionals(given, names) {
   if (!variadic && given.length > names.length)
     badUsage(`unexpected argument ${given[names.length]}`);
 }
+function joinDashValues(args, options) {
+  const longOf = new Map(Object.entries(options).flatMap(([name, option]) => option.short === undefined ? [[`--${name}`, name]] : [[`--${name}`, name], [`-${option.short}`, name]]));
+  const isOption = (arg) => arg === "--" || longOf.has(arg.includes("=") ? arg.slice(0, arg.indexOf("=")) : arg);
+  const joined = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (arg === "--")
+      return [...joined, ...args.slice(i)];
+    const name = longOf.get(arg);
+    const next = args[i + 1];
+    if (name !== undefined && options[name]?.type === "string" && next !== undefined && next.startsWith("-") && next !== "-" && !isOption(next)) {
+      joined.push(`--${name}=${next}`);
+      i++;
+    } else {
+      joined.push(arg);
+    }
+  }
+  return joined;
+}
 function parseError(error) {
   const message = upTo(error instanceof Error ? error.message : String(error), ". ");
   return `${message.charAt(0).toLowerCase()}${message.slice(1)}`;
 }
+var UNKNOWN_OPTION = /^unknown option '(-[^']+)'/;
+function nearestOption(message, options, allowNegative) {
+  const typed = UNKNOWN_OPTION.exec(message)?.[1];
+  if (typed === undefined)
+    return;
+  const word = typed.replace(DASHES, "");
+  if (word.length < 2 && !typed.startsWith("--"))
+    return;
+  const known = Object.entries(options).flatMap(([name, option]) => [
+    ...option.short === undefined ? [] : [`-${option.short}`],
+    `--${name}`,
+    ...allowNegative && option.type === "boolean" ? [`--no-${name}`] : []
+  ]);
+  const meant = closest(word, known.map((flag) => flag.replace(DASHES, "")));
+  return meant === undefined ? undefined : `did you mean ${known.find((flag) => flag.replace(DASHES, "") === meant)}?`;
+}
+var WHOLE = /^\d+$/;
 function wholeNumber(value, name, fallback, min = 1) {
   if (value === undefined)
     return fallback;
   const number = Number(value);
-  if (!Number.isInteger(number) || number < min)
-    badUsage(`--${name} takes a whole number from ${min}, not ${value}`);
+  if (!WHOLE.test(value) || !Number.isSafeInteger(number) || number < min)
+    badUsage(`${name.startsWith("<") ? name : `--${name}`} takes a whole number from ${min}, not ${value}`);
   return number;
 }
 var DURATION = /^(\d+(?:\.\d+)?)(ms|[smh])?$/;
@@ -479,7 +612,7 @@ function duration(value, name, fallback, unit = "s") {
 }
 async function readInput(path, { noStdin = "nothing is piped on stdin" } = {}) {
   if (path === "-") {
-    if (process3.stdin.isTTY)
+    if (process4.stdin.isTTY)
       fail(noStdin);
     return Bun.stdin.text();
   }
@@ -488,75 +621,471 @@ async function readInput(path, { noStdin = "nothing is piped on stdin" } = {}) {
     fail(`no file ${path}`);
   return file.text();
 }
-// ../kit/src/cli.ts
-import process4 from "process";
+// ../kit/src/progress.ts
+import process6 from "process";
 
-// ../kit/src/text.ts
-var ANSI = new RegExp(`${String.fromCharCode(27)}\\[[\\d;?]*[a-z]`, "gi");
-function distance(a, b) {
-  let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
-  for (const [i, left] of [...a].entries()) {
-    const current = [i + 1];
-    for (const [j, right] of [...b].entries())
-      current.push(Math.min((previous[j + 1] ?? 0) + 1, (current[j] ?? 0) + 1, (previous[j] ?? 0) + (left === right ? 0 : 1)));
-    previous = current;
+// ../kit/src/process.ts
+import { constants } from "os";
+import process5 from "process";
+var KILL_GRACE_MS = 2000;
+var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+function exitCodeOf(code, signal) {
+  if (code !== null)
+    return code;
+  if (typeof signal === "number")
+    return 128 + signal;
+  return signal === null ? 129 : 128 + constants.signals[signal];
+}
+function holdSignals(cleanup) {
+  let received;
+  let child;
+  const held = {
+    get signal() {
+      return received;
+    },
+    forward: (to) => {
+      child = to;
+    },
+    release: () => {
+      for (const signal of SIGNALS)
+        process5.off(signal, onSignal);
+    }
+  };
+  function onSignal(signal) {
+    received = signal;
+    if (child !== undefined) {
+      child.kill(signal);
+      return;
+    }
+    if (cleanup === undefined)
+      return;
+    held.release();
+    cleanup(signal);
+    process5.kill(process5.pid, signal);
+  }
+  for (const signal of SIGNALS)
+    process5.on(signal, onSignal);
+  return held;
+}
+async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal, maxBytes = Infinity, onChunk, onStart } = {}) {
+  const chunks = [];
+  const grouped = timeoutMs !== undefined || signal !== undefined || onStart !== undefined || onChunk !== undefined;
+  const proc = Bun.spawn(argv, { ...cwd === undefined ? {} : { cwd }, ...env === undefined ? {} : { env }, stdin, stdout: "pipe", stderr: "pipe", ...grouped ? { detached: true } : {} });
+  const state = { kept: 0, truncated: false, timedOut: false, failure: undefined, done: false };
+  const timers = [];
+  const killGroup = (killing) => {
+    if (state.done)
+      return;
+    try {
+      if (grouped)
+        process5.kill(-proc.pid, killing);
+      else
+        proc.kill(killing);
+    } catch {}
+  };
+  const stop = () => {
+    killGroup("SIGTERM");
+    timers.push(setTimeout(killGroup, KILL_GRACE_MS, "SIGKILL"));
+  };
+  const onAbort = () => stop();
+  if (timeoutMs !== undefined) {
+    timers.push(setTimeout(() => {
+      state.timedOut = true;
+      stop();
+    }, timeoutMs));
+  }
+  if (signal?.aborted === true)
+    onAbort();
+  else
+    signal?.addEventListener("abort", onAbort, { once: true });
+  onStart?.({ kill: (killing) => killGroup(killing) });
+  const drain = async (stream, name) => {
+    for await (const data of stream) {
+      if (state.failure !== undefined)
+        continue;
+      try {
+        onChunk?.({ stream: name, data });
+      } catch (error) {
+        state.failure = error;
+        stop();
+        continue;
+      }
+      if (state.kept + data.length > maxBytes) {
+        state.truncated = true;
+        continue;
+      }
+      state.kept += data.length;
+      chunks.push({ stream: name, data });
+    }
+  };
+  try {
+    await Promise.all([drain(proc.stdout, "stdout"), drain(proc.stderr, "stderr")]);
+    await proc.exited;
+  } finally {
+    state.done = true;
+    for (const timer of timers)
+      clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+  }
+  if (state.failure !== undefined)
+    throw state.failure;
+  const joined = () => Buffer.concat(chunks.map(({ data }) => data));
+  let output;
+  let text;
+  return {
+    code: exitCodeOf(proc.exitCode, proc.signalCode),
+    chunks,
+    timedOut: state.timedOut,
+    truncated: state.truncated,
+    get output() {
+      return output ??= joined();
+    },
+    get text() {
+      return text ??= (output ??= joined()).toString();
+    }
+  };
+}
+
+// ../kit/src/progress.ts
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var FRAME_MS = 80;
+var CLEAR_LINE = "\r\x1B[2K";
+var LINE_UP = "\x1B[1A\x1B[2K";
+var ESC = String.fromCharCode(27);
+var ESCAPE_CODE = new RegExp(`${ESC}(?:\\[[\\x30-\\x3F]*[\\x20-\\x2F]*[\\x40-\\x7E]|\\][^\\u0007${ESC}]*(?:\\u0007|${ESC}\\\\))`, "y");
+var RESET_STYLE = `${ESC}[0m`;
+var CLOSE_LINK = `${ESC}]8;;${ESC}\\`;
+var CONSOLE_METHODS = ["log", "info", "warn", "error", "debug", "dir", "dirxml", "table", "trace", "group", "groupCollapsed", "count", "timeEnd", "timeLog", "assert"];
+function liveRegion(render, stream = process6.stderr, env = process6.env) {
+  if (!takesControlCodes(stream, env))
+    return { redraw: () => {
+      return;
+    }, print: (text) => void stream.write(`${text}
+`), stop: () => {
+      return;
+    } };
+  const write = stream.write.bind(stream);
+  let frame = 0;
+  let drawn = 0;
+  const clear = () => {
+    if (drawn > 0)
+      write(`${CLEAR_LINE}${LINE_UP.repeat(drawn - 1)}`);
+    drawn = 0;
+  };
+  const draw = () => {
+    const width = (stream.columns === undefined || stream.columns === 0 ? 80 : stream.columns) - 1;
+    const height = stream.rows === undefined || stream.rows === 0 ? 24 : stream.rows;
+    const lines = render(FRAMES[frame++ % FRAMES.length]).slice(0, Math.max(1, height - 1)).map((line) => cutToWidth(line, width));
+    if (lines.length === 0) {
+      clear();
+      return;
+    }
+    write(`${drawn > 0 ? `${CLEAR_LINE}${LINE_UP.repeat(drawn - 1)}` : CLEAR_LINE}${lines.join(`
+`)}`);
+    drawn = lines.length;
+  };
+  const timer = setInterval(draw, FRAME_MS);
+  const restore = interceptOutput(clear);
+  const onExit = () => clear();
+  const signals = holdSignals(stop);
+  function stop() {
+    clearInterval(timer);
+    clear();
+    restore();
+    process6.off("exit", onExit);
+    signals.release();
+  }
+  timer.unref();
+  process6.on("exit", onExit);
+  return {
+    redraw: draw,
+    print: (text) => {
+      clear();
+      write(`${text}
+`);
+      draw();
+    },
+    stop
+  };
+}
+function cutToWidth(line, width) {
+  if (Bun.stringWidth(line) <= width)
+    return line;
+  let room = width;
+  let kept = "";
+  let index = 0;
+  let linked = false;
+  while (index < line.length) {
+    ESCAPE_CODE.lastIndex = index;
+    const escape = ESCAPE_CODE.exec(line);
+    if (escape !== null) {
+      kept += escape[0];
+      linked ||= escape[0].startsWith(`${ESC}]`);
+      index = ESCAPE_CODE.lastIndex;
+      continue;
+    }
+    const char = String.fromCodePoint(line.codePointAt(index));
+    const columns = Bun.stringWidth(char);
+    if (columns > room)
+      break;
+    kept += char;
+    room -= columns;
+    index += char.length;
+  }
+  return `${kept}${RESET_STYLE}${linked ? CLOSE_LINK : ""}`;
+}
+function interceptOutput(clear) {
+  const targets = [...CONSOLE_METHODS.map((name) => [console, name]), [process6.stdout, "write"], [process6.stderr, "write"]];
+  const wrapped = targets.map(([target, name]) => {
+    const original = Reflect.get(target, name);
+    const wrapper = (...args) => {
+      clear();
+      return original.apply(target, args);
+    };
+    Reflect.set(target, name, wrapper);
+    return { target, name, original, wrapper };
+  });
+  return () => {
+    for (const { target, name, original, wrapper } of wrapped) {
+      if (Reflect.get(target, name) === wrapper)
+        Reflect.set(target, name, original);
+    }
+  };
+}
+
+// ../kit/src/tool.ts
+import process7 from "process";
+var PERMANENT = /\bHTTP (?:401|403|404)\b|unauthorized|forbidden|not found|couldn't be found|token is required/i;
+function cwdGone() {
+  try {
+    process7.cwd();
+    return false;
+  } catch {
+    return true;
   }
-  return previous[b.length] ?? 0;
 }
 
+class SpawnError extends Error {
+  missing;
+  constructor(message, missing) {
+    super(message);
+    this.missing = missing;
+  }
+}
+function spawnFailure(command, error) {
+  const gone = cwdGone();
+  const missing = !gone && error?.code === "ENOENT";
+  return new SpawnError(`${command}: ${error instanceof Error ? error.message : String(error)}${gone ? " (the working directory was removed)" : ""}`, missing);
+}
+function isPermanentFailure(error) {
+  if (!(error instanceof Error))
+    return false;
+  return error instanceof SpawnError && error.missing || PERMANENT.test(error.message);
+}
+async function runTool(label, argv, { timeoutMs, cwd, onStart } = {}) {
+  let ran;
+  try {
+    ran = await runCommand(argv, { env: process7.env, ...timeoutMs === undefined ? {} : { timeoutMs }, ...cwd === undefined ? {} : { cwd }, ...onStart === undefined ? {} : { onStart } });
+  } catch (error) {
+    throw spawnFailure(label, error);
+  }
+  if (ran.timedOut)
+    throw new Error(`${label}: no answer in ${formatDuration(timeoutMs ?? 0)}`);
+  const decoder = new TextDecoder;
+  const streams = { stdout: "", stderr: "" };
+  for (const { stream, data } of ran.chunks)
+    streams[stream] += decoder.decode(data, { stream: true });
+  return { code: ran.code, ...streams };
+}
+
+// ../kit/src/ci.ts
+var POLL = 15000;
+async function waitForCi(wait) {
+  const { tool, short, giveUpMs, noneMs, stalledMs, pollMs = POLL } = wait;
+  const started = Date.now();
+  let seen = started;
+  let moving = started;
+  let followed = "";
+  let found;
+  const region = wait.lines === undefined ? undefined : liveRegion((spinner) => wait.lines?.(spinner, found, started) ?? []);
+  const suffix = () => found === undefined ? "" : `: ${wait.links(found)}`;
+  async function stallOf(current) {
+    try {
+      return await wait.stall?.(current);
+    } catch (error) {
+      if (error instanceof Exit || isPermanentFailure(error))
+        throw error;
+      console.warn(`${tool}: ${error instanceof Error ? error.message : String(error)}, polling again`);
+      return "unknown";
+    }
+  }
+  try {
+    for (;; ) {
+      if (Date.now() - started > giveUpMs)
+        fail(`CI has not finished on ${short} in ${formatDuration(giveUpMs)}${suffix()}`);
+      try {
+        found = await wait.covering();
+      } catch (error) {
+        if (error instanceof Exit)
+          throw error;
+        if (cwdGone())
+          fail(`the working directory was removed while waiting for CI on ${short}${suffix()}`);
+        if (isPermanentFailure(error))
+          fail(error instanceof Error ? error.message : String(error));
+        console.warn(`${tool}: ${error instanceof Error ? error.message : String(error)}, polling again`);
+        const latest = found === undefined ? undefined : await wait.settle(found);
+        if (latest !== undefined)
+          return latest;
+        await Bun.sleep(pollMs);
+        continue;
+      }
+      if (found !== undefined) {
+        seen = Date.now();
+        const key = wait.key(found);
+        if (key !== followed) {
+          followed = key;
+          moving = Date.now();
+          wait.announce(found);
+        }
+        if (wait.finished(found))
+          return found;
+        const stall = await stallOf(found);
+        if (stall === undefined)
+          moving = Date.now();
+        else if (stall !== "unknown" && (stall.certain === true || Date.now() - moving > stalledMs))
+          fail(stall.message);
+      } else if (Date.now() - seen > noneMs) {
+        fail(wait.noneMessage);
+      }
+      await Bun.sleep(pollMs);
+    }
+  } finally {
+    region?.stop();
+  }
+}
 // ../kit/src/cli.ts
-function closest(name, names) {
-  const started = names.find((known) => known.startsWith(name));
-  if (started !== undefined)
-    return started;
-  const [best] = names.map((known) => ({ known, far: distance(name, known) })).sort((a, b) => a.far - b.far);
-  return best !== undefined && best.far <= (name.length < 4 ? 1 : 2) ? best.known : undefined;
+import process8 from "process";
+var LEVEL_OPTIONS = {
+  ...OUTPUT_OPTIONS,
+  help: { type: "boolean", short: "h", description: "show this help" }
+};
+var TOP_OPTIONS = { ...LEVEL_OPTIONS, version: { type: "boolean", short: "v", description: "print the version" } };
+async function commandRows(commands, colors) {
+  const width = Math.max(...Object.keys(commands).map((name) => name.length));
+  const groups = new Map([["Commands:", []]]);
+  const summaries = await Promise.all(Object.values(commands).map(async ({ summary }) => resolveSummary(summary)));
+  for (const [index, [name, { group }]] of Object.entries(commands).entries()) {
+    const heading = group === undefined ? "Commands:" : `${group}:`;
+    const rows = groups.get(heading) ?? [];
+    rows.push(`  ${colors.cyan(name.padEnd(width))}  ${colors.dim(summaries[index])}`);
+    groups.set(heading, rows);
+  }
+  return [...groups].filter(([, rows]) => rows.length > 0).flatMap(([heading, rows], index) => [...index === 0 ? [] : [""], colors.bold(heading), ...rows]);
+}
+function takeOutputFlags(argv) {
+  let index = 0;
+  for (;index < argv.length; index++) {
+    const word = argv[index];
+    if (word === "--plain")
+      applyOutput(undefined, true);
+    else if (word.startsWith("--color="))
+      applyOutput(word.slice("--color=".length), undefined);
+    else if (word === "--color" && argv[index + 1] !== undefined)
+      applyOutput(argv[++index], undefined);
+    else
+      break;
+  }
+  return argv.slice(index);
+}
+async function resolveSummary(summary) {
+  return typeof summary === "string" ? summary : summary();
+}
+function scopeOf(commands, extra, aliases) {
+  return { commands: typeof commands === "function" ? {} : commands, lazy: [...typeof commands === "function" ? [commands] : [], ...extra === undefined ? [] : [extra]], aliases };
+}
+async function expand(scope, words) {
+  if (scope.lazy.length === 0)
+    return scope;
+  const commands = { ...scope.commands };
+  for (const added of await Promise.all(scope.lazy.map(async (lazy) => lazy(words)))) {
+    for (const [name, command] of Object.entries(added))
+      commands[name] ??= command;
+  }
+  return { ...scope, commands, lazy: [] };
 }
-async function help({ path, header, commands, defaultCommand }, stream) {
+async function help({ path, header, summary: lazySummary, commands, defaultCommand, examples, replaces }, stream) {
   const colors = paint(stream);
-  const width = Math.max(...Object.keys(commands).map((name) => name.length));
   const prefix = path.join(" ");
+  const summary = await resolveSummary(lazySummary);
+  if (wantsHelpJson())
+    return JSON.stringify(description(`${prefix} <command> [options]: ${summary}`, { examples, replaces }));
   const fallback = defaultCommand === undefined ? undefined : commands[defaultCommand];
   const options = fallback !== undefined && "run" in fallback ? await optionsOf(fallback.run) : undefined;
+  const own = Object.entries(options ?? {}).filter(([name]) => !(name in TOP_OPTIONS));
   return [
-    header(colors),
+    header(colors, summary),
     "",
     usageLine(`${prefix} ${defaultCommand === undefined ? colors.cyan("<command>") : `[${colors.cyan("<command>")}]`} [options]`, colors),
+    ...replacesRows(replaces, colors),
+    "",
+    ...await commandRows(commands, colors),
+    ...own.length === 0 ? [] : ["", `${colors.bold(`Options of ${defaultCommand}:`)} ${colors.dim("the command run when none is named")}`, ...optionRows(Object.fromEntries(own), colors)],
     "",
-    colors.bold("Commands:"),
-    ...Object.entries(commands).map(([name, { summary }]) => `  ${colors.cyan(name.padEnd(width))}  ${colors.dim(summary)}`),
-    ...options === undefined || Object.keys(options).length === 0 ? [] : ["", `${colors.bold(`Options of ${defaultCommand}:`)} ${colors.dim("the command run when none is named")}`, ...optionRows(options, colors)],
+    colors.bold("Options:"),
+    ...optionRows(path.length === 1 ? TOP_OPTIONS : LEVEL_OPTIONS, colors),
+    ...exampleRows(examples ?? [], colors),
     "",
     `${colors.dim("Run")} ${prefix} ${colors.cyan("<command>")} --help ${colors.dim("for its options.")}`
   ].join(`
 `);
 }
 function printError(prefix, message, hint, cause) {
-  const colors = paint(process4.stderr);
-  const styled = takesControlCodes(process4.stderr);
+  const colors = paint(process8.stderr);
+  const styled = takesControlCodes(process8.stderr);
   const head = styled ? `${colors.red.bold("error")} ${colors.dim(`${prefix}:`)}` : `error: ${prefix}:`;
   const under = (label, text, tint) => text === undefined ? "" : `
   ${styled ? tint(label) : `${label}:`} ${text}`;
   console.error(`${head} ${message}${under("cause", cause, colors.dim)}${under("hint", hint, colors.yellow)}`);
 }
-function reportThrown(prefix, error, redact = (text) => text) {
+function runHint(command, effect) {
+  return `run \`${command}\`${effect === undefined ? "" : ` to ${effect}`}`;
+}
+function printHint(hint) {
+  const colors = paint(process8.stderr);
+  console.error(`  ${takesControlCodes(process8.stderr) ? colors.yellow("hint") : "hint:"} ${hint}`);
+}
+function printJsonError(message, hint, cause) {
+  console.error(JSON.stringify({ error: message, ...hint === undefined ? {} : { hint }, ...cause === undefined ? {} : { cause } }));
+}
+function wantsJson(argv) {
+  const end = argv.indexOf("--");
+  return (end === -1 ? argv : argv.slice(0, end)).includes("--json");
+}
+function reportThrown(prefix, error, redact = (text) => text, json = false) {
   if (error instanceof HelpShown)
     return 0;
   const help = error instanceof UsageError ? `run ${prefix} --help for its options` : undefined;
   const named = error instanceof Error && !(error instanceof Exit) && error.name !== "Error" ? `${error.name}: ${error.message}` : undefined;
   const cause = error instanceof Error && error.cause instanceof Error ? redact(error.cause.message) : undefined;
-  printError(prefix, redact(named ?? (error instanceof Error ? error.message : String(error))), error instanceof Exit ? error.hint ?? help : undefined, cause);
+  const report = json ? printJsonError : (message, hint, causeText) => printError(prefix, message, hint, causeText);
+  report(redact(named ?? (error instanceof Error ? error.message : String(error))), error instanceof Exit ? error.hint ?? help : undefined, cause);
   return error instanceof Exit ? error.code : 1;
 }
-async function dispatch(level, argv, { version, redact }) {
-  const [name, ...args] = argv;
+async function dispatch(level, typed, { version, redact }) {
   const prefix = level.path.join(" ");
+  let argv;
+  try {
+    argv = takeOutputFlags(typed);
+  } catch (error) {
+    return reportThrown(prefix, error);
+  }
+  const [name, ...args] = argv;
   if (name === undefined && level.path.length > 1) {
-    console.error(await help(level, process4.stderr));
+    console.error(await help(await expand(level, [...level.path.slice(1), ...argv]), process8.stderr));
     return 2;
   }
   if (name === undefined || name === "help" || name === "--help" || name === "-h") {
-    console.log(await help(level, process4.stdout));
+    console.log(await help(await expand(level, [...level.path.slice(1), ...argv]), process8.stdout));
     return 0;
   }
   if (level.path.length === 1 && (name === "--version" || name === "-v")) {
@@ -565,6 +1094,10 @@ async function dispatch(level, argv, { version, redact }) {
   }
   let command = level.commands[level.aliases?.[name] ?? name];
   let rest = args;
+  if (command === undefined && level.lazy.length > 0) {
+    level = await expand(level, [...level.path.slice(1), ...argv]);
+    command = level.commands[level.aliases?.[name] ?? name];
+  }
   if (command === undefined && level.defaultCommand !== undefined) {
     command = level.commands[level.defaultCommand];
     rest = argv;
@@ -576,12 +1109,12 @@ async function dispatch(level, argv, { version, redact }) {
   }
   if ("commands" in command) {
     const { summary } = command;
-    return dispatch({ path: [...level.path, name], header: (colors) => `${colors.bold(`${prefix} ${name}`)}  ${summary}`, commands: command.commands, aliases: command.aliases, defaultCommand: undefined }, rest, { version, redact });
+    return dispatch({ path: [...level.path, name], header: (colors, text) => `${colors.bold(`${prefix} ${name}`)}  ${text}`, summary, ...scopeOf(command.commands, command.extraCommands, command.aliases), defaultCommand: undefined, examples: command.examples, replaces: undefined }, rest, { version, redact });
   }
   try {
     return await command.run(rest);
   } catch (error) {
-    return reportThrown(`${prefix} ${name}`, error, redact);
+    return reportThrown(`${prefix} ${name}`, error, redact, wantsJson(rest));
   }
 }
 var COMPLETE = "__complete";
@@ -601,31 +1134,96 @@ async function optionsOf(run) {
 async function leafCandidates(run, words) {
   if (!(words.at(-1) ?? "").startsWith("-"))
     return [FILES];
-  return Object.entries(await optionsOf(run)).map(([name, option]) => `--${name}	${option.description}`);
+  return Object.entries(await optionsOf(run)).map(([name, option]) => option.description === undefined ? `--${name}` : `--${name}	${option.description}`);
 }
-async function candidates(commands, aliases, defaultCommand, words) {
+async function candidates(scope, defaultCommand, words, before = []) {
   const [word = "", ...rest] = words;
-  const command = commands[aliases?.[word] ?? word];
-  if (rest.length === 0 && !word.startsWith("-"))
-    return Object.entries(commands).map(([name, { summary }]) => `${name}	${summary}`);
+  const listing = rest.length === 0 && !word.startsWith("-");
+  let { commands, aliases } = scope;
+  let command = commands[aliases?.[word] ?? word];
+  if (listing || command === undefined) {
+    ({ commands, aliases } = await expand(scope, [...before, ...words]));
+    command = commands[aliases?.[word] ?? word];
+  }
+  if (listing)
+    return Promise.all(Object.entries(commands).map(async ([name, { summary }]) => `${name}	${await resolveSummary(summary)}`));
   if (command === undefined) {
     const fallback = defaultCommand === undefined ? undefined : commands[defaultCommand];
     return fallback !== undefined && "run" in fallback ? leafCandidates(fallback.run, words) : [];
   }
-  return "commands" in command ? candidates(command.commands, command.aliases, undefined, rest) : leafCandidates(command.run, rest);
+  return "commands" in command ? candidates(scopeOf(command.commands, command.extraCommands, command.aliases), undefined, rest, [...before, word]) : leafCandidates(command.run, rest);
 }
 async function printCandidates(found) {
   for (const line of await found)
     console.log(line);
   return 0;
 }
-async function runCli(cli, argv = process4.argv.slice(2)) {
+async function runCli(cli, argv = process8.argv.slice(2)) {
   if (argv[0] === COMPLETE)
-    return printCandidates(candidates(cli.commands, cli.aliases, cli.defaultCommand, argv.slice(1)));
-  return dispatch({ path: [cli.name], header: (colors) => `${colors.bold(cli.name)} ${colors.dim(cli.version)}  ${cli.about}`, commands: cli.commands, aliases: cli.aliases, defaultCommand: cli.defaultCommand }, argv, { version: cli.version, redact: cli.redact });
+    return printCandidates(candidates(scopeOf(cli.commands, cli.extraCommands, cli.aliases), cli.defaultCommand, argv.slice(1)));
+  return dispatch({ path: [cli.name], header: (colors, about) => `${colors.bold(cli.name)} ${colors.dim(cli.version)}  ${about}`, summary: cli.about, ...scopeOf(cli.commands, cli.extraCommands, cli.aliases), defaultCommand: cli.defaultCommand, examples: cli.examples, replaces: cli.replaces }, argv, { version: cli.version, redact: cli.redact });
+}
+// ../kit/src/git.ts
+import { basename, dirname } from "path";
+import process9 from "process";
+var ORIGIN_PREFIX = /^origin\//;
+var GIT_NETWORK_MS = 60000;
+async function git(args, timeoutMs) {
+  const result = await runTool(`git ${args.join(" ")}`, ["git", ...args], { timeoutMs });
+  if (result.code !== 0)
+    throw new Error(`git ${args.join(" ")}: ${result.stderr.trim() || `exit ${result.code}`}${cwdGone() ? " (the working directory was removed)" : ""}`);
+  return result.stdout.trim();
+}
+async function gitOk(args) {
+  return (await runTool(`git ${args.join(" ")}`, ["git", ...args])).code === 0;
 }
+async function resolveCommit(ref) {
+  const sha = (await runTool("git rev-parse", ["git", "rev-parse", "--verify", "-q", "--end-of-options", `${ref}^{commit}`])).stdout.trim();
+  if (sha === "")
+    fail(`no commit ${ref}`);
+  return sha;
+}
+async function fetchBranch(branch) {
+  if (branch.startsWith("-") || !await gitOk(["check-ref-format", "--branch", branch]))
+    fail(`${branch} is not a branch name`);
+  await git(["fetch", "-q", "origin", `refs/heads/${branch}`], GIT_NETWORK_MS);
+}
+async function defaultBranch() {
+  const head = (await runTool("git symbolic-ref", ["git", "symbolic-ref", "--short", "-q", "refs/remotes/origin/HEAD"])).stdout.trim();
+  return head === "" ? "main" : head.replace(ORIGIN_PREFIX, "");
+}
+async function leaveWorktree() {
+  const common = await git(["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  if (basename(common) === ".git")
+    process9.chdir(dirname(common));
+}
+// ../kit/src/limit.ts
+function limitOptions(fallback) {
+  return {
+    limit: { type: "string", description: `show at most this many rows, the rest counted (${fallback})` },
+    full: { type: "boolean", description: "show every row" }
+  };
+}
+function limitOf(values, fallback) {
+  if (values.full === true && values.limit !== undefined)
+    badUsage("--limit and --full exclude each other");
+  if (values.full === true || values.json === true && values.limit === undefined)
+    return Number.POSITIVE_INFINITY;
+  return wholeNumber(values.limit, "limit", fallback);
+}
+function moreFooter(more) {
+  return `${more} more, rerun with --full`;
+}
+function capped(rows, limit) {
+  const more = rows.length - limit;
+  return more > 0 ? { shown: rows.slice(0, limit), footer: moreFooter(more) } : { shown: [...rows], footer: undefined };
+}
+// ../kit/src/logs.ts
+var DAY_MS = 24 * 60 * 60 * 1000;
+// ../kit/src/secrets.ts
+var SECRET_WORDS = new Set(["key", "pass", "pwd", "auth", "salt", "cookie", "session", "jwt", "ssn", "iban", "card", "cvv", "otp"]);
 // package.json
-var version = "0.5.1";
+var version = "0.7.0";
 
 // src/args.ts
 var repoOption = {
@@ -637,27 +1235,41 @@ function issueNumber(value, usage) {
     fail(`an issue number is needed
 
 ${usage}`);
-  return wholeNumber(value.replace(ISSUE_HASH, ""), "issue", 0);
+  return wholeNumber(value.replace(ISSUE_HASH, ""), "<issue>", 0);
 }
 function issueNumbers(values, usage) {
   return values.length === 0 ? [issueNumber(undefined, usage)] : values.map((value) => issueNumber(value, usage));
 }
 
 // src/checklist.ts
-var BOX = /^(\s*[-*+] \[)([ x])(\]\s)(.*)\r?$/i;
-var FENCE = /^\s*(?:```|~~~)/;
+var BOX = /^(\s*[-*+] \[)([ x])(\]\s)(.*?)\r?$/is;
+var FENCE = /^\s*(`{3,}|~{3,})/;
+var LIST_ITEM = /^\s*(?:[-*+]|\d+[.)])\s/;
+var INDENT_CODE = /^(?: {4}|\t)/;
 function boxes(body) {
   const found = [];
-  let fenced = false;
+  let fence;
+  let inList = false;
   for (const [line, text] of body.split(`
 `).entries()) {
-    if (FENCE.test(text)) {
-      fenced = !fenced;
+    const marker = FENCE.exec(text)?.[1];
+    if (fence !== undefined) {
+      if (marker?.startsWith(fence[0] ?? "") === true && marker.length >= fence.length && text.trim() === marker)
+        fence = undefined;
+      continue;
+    }
+    if (marker !== undefined) {
+      fence = marker;
       continue;
     }
-    const match = fenced ? null : BOX.exec(text);
+    const blank = text.trim() === "";
+    const match = INDENT_CODE.test(text) && !inList ? null : BOX.exec(text);
     if (match !== null)
       found.push({ number: found.length + 1, line, done: match[2] !== " ", text: match[4] ?? "" });
+    if (LIST_ITEM.test(text))
+      inList = true;
+    else if (!blank && !text.startsWith(" ") && !text.startsWith("\t"))
+      inList = false;
   }
   return found;
 }
@@ -690,13 +1302,17 @@ function numberedBody(body) {
   return lines.join(`
 `).trim();
 }
+var NUMBERED_PICK = /^(\d+):(.+)$/s;
+var WHOLE_PICK = /^\d+$/;
 function setBoxes(body, picks, done) {
   const all = boxes(body);
   const chosen = new Map;
   for (const pick of picks) {
-    const number = Number(pick);
-    const needle = pick.toLowerCase();
-    const matches = Number.isInteger(number) && String(number) === pick ? all.filter((box) => box.number === number) : all.filter((box) => box.text.toLowerCase().includes(needle));
+    if (pick.trim() === "")
+      throw new Error("an empty box pick matches every box");
+    const guarded = NUMBERED_PICK.exec(pick);
+    const needle = (guarded?.[2] ?? pick).trim().toLowerCase();
+    const matches = guarded === null && !WHOLE_PICK.test(pick) ? all.filter((box) => box.text.toLowerCase().includes(needle)) : all.filter((box) => box.number === Number(guarded?.[1] ?? pick) && (guarded === null || box.text.toLowerCase().startsWith(needle)));
     if (matches.length === 0)
       throw new Error(`no box matches ${pick}`);
     if (matches.length > 1)
@@ -734,8 +1350,8 @@ function tickReferences(body, wanted) {
 }
 
 // src/claims.ts
-var TAKEN = /^\s*taken by session ([\w.@:-]+?)\.?\s*$/im;
-var RELEASED = /^\s*released by session ([\w.@:-]+?)\.?\s*$/im;
+var TAKEN = /^\s*taken by session ([\w.@:-]+?)\.?\s*$/i;
+var RELEASED = /^\s*released by session ([\w.@:-]+?)\.?\s*$/i;
 var LANE = /^lane-([^-]+)-/;
 function takenComment(name) {
   return `Taken by session ${name}.`;
@@ -743,9 +1359,12 @@ function takenComment(name) {
 function releasedComment(name) {
   return `Released by session ${name}.`;
 }
-function latestClaim(comments) {
+function isClaimant(comment, author) {
+  return author === undefined || comment.user === undefined || comment.user.login === author;
+}
+function latestClaim(comments, author) {
   let claim;
-  for (const comment of [...comments].sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at))) {
+  for (const comment of comments.filter((each) => isClaimant(each, author)).sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at))) {
     const taken = TAKEN.exec(comment.body)?.[1];
     if (taken !== undefined) {
       claim = { holder: taken, at: comment.created_at };
@@ -772,80 +1391,15 @@ function holderSession(holder, sessions) {
 }
 
 // src/tea.ts
-var {$: $2 } = globalThis.Bun;
-
-// src/git.ts
-import { basename, dirname } from "path";
-import process6 from "process";
-var {$ } = globalThis.Bun;
-var ORIGIN_PREFIX = /^origin\//;
-function spawnFailure(command, error) {
-  return new Error(`${command}: ${error instanceof Error ? error.message : String(error)}${cwdGone() ? " (the working directory was removed)" : ""}`);
-}
-async function git(args) {
-  let result;
-  try {
-    result = await $`git ${args}`.quiet().nothrow();
-  } catch (error) {
-    throw spawnFailure(`git ${args.join(" ")}`, error);
-  }
-  if (result.exitCode !== 0)
-    throw new Error(`git ${args.join(" ")}: ${result.stderr.toString().trim() || `exit ${result.exitCode}`}`);
-  return result.stdout.toString().trim();
-}
-async function gitOk(args) {
-  return (await $`git ${args}`.quiet().nothrow()).exitCode === 0;
-}
-async function resolveCommit(ref) {
-  const sha = (await $`git rev-parse --verify -q ${`${ref}^{commit}`}`.quiet().nothrow().text()).trim();
-  if (sha === "")
-    fail(`no commit ${ref}`);
-  return sha;
-}
-async function defaultBranch() {
-  const head = (await $`git symbolic-ref --short -q refs/remotes/origin/HEAD`.quiet().nothrow().text()).trim();
-  return head === "" ? "main" : head.replace(ORIGIN_PREFIX, "");
-}
-async function tagsAt(commit) {
-  return (await git(["tag", "--points-at", commit])).split(`
-`).filter(Boolean);
-}
-async function commitsNaming(issue, ref) {
-  const out = await git(["log", ref, "--reverse", "--extended-regexp", `--grep=#${issue}([^0-9]|$)`, "--format=%H %s"]);
-  return out.split(`
-`).filter(Boolean).map((line) => {
-    const space = line.indexOf(" ");
-    return { sha: line.slice(0, space), subject: line.slice(space + 1) };
-  });
-}
-function cwdGone() {
-  try {
-    process6.cwd();
-    return false;
-  } catch {
-    return true;
-  }
-}
-async function leaveWorktree() {
-  const common = await git(["rev-parse", "--path-format=absolute", "--git-common-dir"]);
-  if (basename(common) === ".git")
-    process6.chdir(dirname(common));
-}
-
-// src/tea.ts
+var TEA_MS = 60000;
 function repoFlag(repo) {
   return repo === undefined ? [] : ["--repo", repo];
 }
 async function request(path, repo) {
-  let result;
-  try {
-    result = await $2`tea api ${repoFlag(repo)} ${path}`.quiet().nothrow();
-  } catch (error) {
-    throw spawnFailure(`tea api ${path}`, error);
-  }
-  if (result.exitCode !== 0)
-    throw new Error(`tea api ${path}: ${result.stderr.toString().trim() || `exit ${result.exitCode}`}`);
-  return result.stdout.toString();
+  const result = await runTool(`tea api ${path}`, ["tea", "api", ...repoFlag(repo), path], { timeoutMs: TEA_MS });
+  if (result.code !== 0)
+    throw new Error(`tea api ${path}: ${result.stderr.trim() || `exit ${result.code}`}`);
+  return result.stdout;
 }
 function parseJson(path, text) {
   let value;
@@ -855,29 +1409,49 @@ function parseJson(path, text) {
     throw new Error(`tea api ${path}: ${upTo(text.trim(), `
 `) || "empty answer"}`);
   }
-  if (value !== null && typeof value === "object" && !Array.isArray(value) && "message" in value && typeof value.message === "string" && "url" in value)
-    throw new Error(`tea api ${path}: ${value.message}`);
+  const failure = apiError(value);
+  if (failure !== undefined)
+    throw new Error(`tea api ${path}: ${failure}`);
   return value;
 }
+function apiError(value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value) && "message" in value && typeof value.message === "string" && "url" in value)
+    return value.message;
+  return;
+}
 async function api(path, repo) {
   return parseJson(path, await request(path, repo));
 }
 async function repoApi(path, repo) {
   return api(`repos/{owner}/{repo}/${path}`, repo);
 }
-async function repoApiText(path, repo) {
-  return request(`repos/{owner}/{repo}/${path}`, repo);
+async function repoWrite(method, path, fields, repo) {
+  const full = `repos/{owner}/{repo}/${path}`;
+  const flags = Object.entries(fields).flatMap(([name, value]) => ["-f", `${name}=${value}`]);
+  const result = await runTool(`tea api ${full}`, ["tea", "api", ...repoFlag(repo), "-X", method, ...flags, full], { timeoutMs: TEA_MS });
+  if (result.code !== 0)
+    throw new Error(`tea api ${full}: ${result.stderr.trim() || `exit ${result.code}`}`);
+  return parseJson(full, result.stdout);
 }
-async function tea(args, repo) {
-  let result;
+async function repoApiText(path, repo) {
+  const full = `repos/{owner}/{repo}/${path}`;
+  const text = await request(full, repo);
+  let value;
   try {
-    result = await $2`tea ${args} ${repoFlag(repo)}`.quiet().nothrow();
-  } catch (error) {
-    throw spawnFailure(`tea ${args[0] ?? ""}`, error);
+    value = JSON.parse(text);
+  } catch {
+    return text;
   }
-  if (result.exitCode !== 0)
-    throw new Error(`tea ${args[0] ?? ""}: ${result.stderr.toString().trim() || result.stdout.toString().trim() || `exit ${result.exitCode}`}`);
-  return result.stdout.toString();
+  const failure = apiError(value);
+  if (failure !== undefined)
+    throw new Error(`tea api ${full}: ${failure}`);
+  return text;
+}
+async function tea(command, args, repo) {
+  const result = await runTool(`tea ${command.join(" ")}`, ["tea", ...command, ...repoFlag(repo), ...args], { timeoutMs: TEA_MS });
+  if (result.code !== 0)
+    throw new Error(`tea ${command.join(" ")}: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`}`);
+  return result.stdout;
 }
 
 // src/issues.ts
@@ -886,16 +1460,21 @@ var CONCURRENCY = 8;
 async function getIssue(number, repo) {
   return repoApi(`issues/${number}`, repo);
 }
-async function openIssues(labels, repo) {
+async function listIssues(state, filter, repo) {
   const issues = [];
-  const filter = labels === undefined ? "" : `&labels=${encodeURIComponent(labels)}`;
   for (let page = 1;; page++) {
-    const batch = await repoApi(`issues?state=open&type=issues&page=${page}&limit=${PAGE}${filter}`, repo);
+    const batch = await repoApi(`issues?state=${state}&type=issues&page=${page}&limit=${PAGE}${filter}`, repo);
     issues.push(...batch);
     if (batch.length < PAGE)
       return issues;
   }
 }
+async function openIssues(labels, repo, milestone) {
+  return listIssues("open", `${labels === undefined ? "" : `&labels=${encodeURIComponent(labels)}`}${milestone === undefined ? "" : `&milestones=${milestone}`}`, repo);
+}
+async function closedIssues(milestone, repo) {
+  return listIssues("closed", `&milestones=${milestone}`, repo);
+}
 async function commentsOf(number, repo) {
   return repoApi(`issues/${number}/comments`, repo);
 }
@@ -910,42 +1489,75 @@ async function commentsOfAll(issues, repo) {
   return result;
 }
 async function editIssue(number, change, repo) {
-  const args = ["issues", "edit", String(number)];
+  const args = [String(number)];
   if (change.title !== undefined)
     args.push("-t", change.title);
   if (change.body !== undefined)
     args.push("-d", change.body);
-  await tea(args, repo);
+  if (change.milestone !== undefined)
+    args.push("-m", change.milestone);
+  await tea(["issues", "edit"], args, repo);
 }
 async function setBody(number, body, repo) {
   await editIssue(number, { body }, repo);
 }
-async function createIssue(title, body, labels, repo) {
-  const args = ["issues", "create", "-t", title, "-d", body];
+async function createIssue(title, body, labels, milestone, repo) {
+  const args = ["-t", title, "-d", body];
+  const same = (found) => found.title === title && sameText(found.body, body);
+  const known = new Set((await openIssues(undefined, repo)).filter(same).map((found) => found.number));
   if (labels !== undefined)
     args.push("-L", labels);
-  await tea(args, repo);
-  const created = (await openIssues(undefined, repo)).filter((found) => found.title === title).sort((a, b) => b.number - a.number)[0];
-  if (created === undefined)
+  if (milestone !== undefined)
+    args.push("-m", milestone);
+  await tea(["issues", "create"], args, repo);
+  const created = (await openIssues(undefined, repo)).filter((found) => same(found) && !known.has(found.number));
+  if (created.length > 1)
+    throw new Error(`created "${title}" but ${created.map((found) => `#${found.number}`).join(" and ")} both match: another session created the same issue at once`);
+  if (created[0] === undefined)
     throw new Error(`created "${title}" but cannot find it among the open issues`);
-  return created;
+  return created[0];
 }
+function sameText(a, b) {
+  return a.replaceAll(`\r
+`, `
+`).trimEnd() === b.replaceAll(`\r
+`, `
+`).trimEnd();
+}
+var EDIT_TRIES = 3;
 async function editBody(number, change, repo) {
-  const { body } = await getIssue(number, repo);
-  const next = change(body);
-  if (next === body)
-    return false;
-  await setBody(number, next, repo);
-  return true;
+  let wrote = false;
+  for (let attempt = 0;attempt < EDIT_TRIES; attempt++) {
+    const { body } = await getIssue(number, repo);
+    const next = change(body);
+    if (next === body)
+      return wrote;
+    await setBody(number, next, repo);
+    wrote = true;
+    if (sameText((await getIssue(number, repo)).body, next))
+      return true;
+  }
+  throw new Error(`#${number}: its description keeps changing under the edit, so it was not written reliably`);
+}
+var login;
+async function sessionAuthor() {
+  if (login !== undefined)
+    return login;
+  try {
+    login = (await api("user")).login;
+  } catch {
+    return;
+  }
+  return login;
 }
 async function comment(number, body, repo) {
-  await tea(["comment", String(number), body], repo);
+  await repoWrite("POST", `issues/${number}/comments`, { body }, repo);
 }
 async function close(number, repo) {
-  await tea(["issues", "close", String(number)], repo);
+  await tea(["issues", "close"], [String(number)], repo);
 }
 async function reopen(number, repo) {
-  await tea(["issues", "reopen", String(number)], repo);
+  await tea(["issues", "reopen"], [String(number)], repo);
 }
 async function repoLabels(repo) {
   const names = [];
@@ -957,26 +1569,74 @@ async function repoLabels(repo) {
   }
 }
 async function editLabels(number, add, remove, repo) {
-  const args = ["issues", "edit", String(number)];
+  const args = [String(number)];
   if (add.length > 0)
     args.push("--add-labels", add.join(","));
   if (remove.length > 0)
     args.push("--remove-labels", remove.join(","));
-  await tea(args, repo);
+  await tea(["issues", "edit"], args, repo);
+}
+
+// src/milestones.ts
+var PAGE2 = 50;
+var DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+var NO_DUE_YEAR = 9999;
+async function listMilestones(state, repo) {
+  const found = [];
+  for (let page = 1;; page++) {
+    const batch = await repoApi(`milestones?state=${state}&page=${page}&limit=${PAGE2}`, repo);
+    found.push(...batch);
+    if (batch.length < PAGE2)
+      return found;
+  }
+}
+async function findMilestone(reference, repo) {
+  const all = await listMilestones("all", repo);
+  const found = all.find((each) => each.title === reference) ?? all.find((each) => String(each.id) === reference);
+  if (found === undefined)
+    fail(`no milestone ${reference}, ${all.length === 0 ? "the repository has none" : `it has: ${all.map((each) => each.title).join(", ")}`}`, 2, runHint(`ft milestone new ${reference}`, "create it"));
+  return found;
+}
+function dueOn(value) {
+  const match = DATE.exec(value);
+  const date = new Date(`${value}T00:00:00Z`);
+  if (match === null || Number.isNaN(date.getTime()) || date.toISOString().slice(0, 10) !== value || date.getUTCFullYear() < 2000)
+    fail(`--due takes a date as YYYY-MM-DD, not ${value}`);
+  return date.toISOString();
+}
+function dueDate(milestone) {
+  if (milestone.due_on === null || new Date(milestone.due_on).getUTCFullYear() >= NO_DUE_YEAR)
+    return "";
+  return milestone.due_on.slice(0, 10);
+}
+function progress(milestone) {
+  const total = milestone.open_issues + milestone.closed_issues;
+  return total === 0 ? "" : `${Math.round(milestone.closed_issues / total * 100)}%`;
+}
+async function createMilestone(title, description, due, repo) {
+  const fields = { title };
+  if (description !== undefined)
+    fields.description = description;
+  if (due !== undefined)
+    fields.due_on = due;
+  return repoWrite("POST", "milestones", fields, repo);
+}
+async function closeMilestone(id, repo) {
+  await repoWrite("PATCH", `milestones/${id}`, { state: "closed" }, repo);
 }
 
 // src/sessions.ts
 import { homedir } from "os";
 import { join } from "path";
-import process7 from "process";
+import process11 from "process";
 var {Glob } = globalThis.Bun;
 var SESSION_FILES = new Glob("*.json");
 var ACCOUNT_DIRS = new Glob("*/sessions");
 async function sessionDirs() {
   const home = homedir();
   const dirs = new Set([join(home, ".claude", "sessions")]);
-  if (process7.env.CLAUDE_CONFIG_DIR !== undefined)
-    dirs.add(join(process7.env.CLAUDE_CONFIG_DIR, "sessions"));
+  if (process11.env.CLAUDE_CONFIG_DIR !== undefined)
+    dirs.add(join(process11.env.CLAUDE_CONFIG_DIR, "sessions"));
   try {
     for await (const dir of ACCOUNT_DIRS.scan({ cwd: join(home, ".claude-accounts"), onlyFiles: false, absolute: true }))
       dirs.add(dir);
@@ -1022,7 +1682,7 @@ async function liveSessions() {
 }
 async function currentSession(sessions) {
   const byPid = new Map(sessions.map((session) => [session.pid, session]));
-  let pid = process7.ppid;
+  let pid = process11.ppid;
   for (let depth = 0;depth < 32 && pid > 1; depth++) {
     const session = byPid.get(pid);
     if (session !== undefined)
@@ -1061,18 +1721,20 @@ function noteLine(comments, now) {
 `).map((line) => line.trim()).find((line) => line !== "");
   return note === undefined || first === undefined ? [] : [`    ${note.user.login} ${formatAge(note.created_at, now)}: ${truncate(first, NOTE_WIDTH)}`];
 }
-function renderBoard(rows, now = Date.now()) {
+function within(rows, limit, cells, decorate = (line) => [line]) {
+  const { shown, footer } = capped(rows, limit);
+  return { lines: [...table(shown.map(cells)).split(`
+`).flatMap(decorate), ...footer === undefined ? [] : [footer]] };
+}
+function renderBoard(rows, now = Date.now(), limit = Number.POSITIVE_INFINITY) {
   const available = rows.filter((row) => row.standing.state === "available");
   const claimed = (state) => rows.flatMap(({ issue, standing: row, comments }) => row.state === state ? [{ issue, row, comments }] : []);
   const taken = claimed("taken");
   const away = claimed("away");
   const sections = [
-    { heading: "available", count: available.length, lines: table(available.map(({ issue }) => [`#${issue.number}`, truncate(issue.title, TITLE_WIDTH), issue.labels.map((label) => label.name).join(", ")])).split(`
-`) },
-    { heading: "taken", count: taken.length, lines: table(taken.map(({ issue, row }) => claimRow(issue, row, now))).split(`
-`) },
-    { heading: "claimed, no live session here", count: away.length, lines: table(away.map(({ issue, row }) => claimRow(issue, row, now))).split(`
-`).flatMap((line, index) => [line, ...noteLine(away[index]?.comments ?? [], now)]) }
+    { heading: "available", count: available.length, ...within(available, limit, ({ issue }) => [`#${issue.number}`, truncate(issue.title, TITLE_WIDTH), issue.labels.map((label) => label.name).join(", ")]) },
+    { heading: "taken", count: taken.length, ...within(taken, limit, ({ issue, row }) => claimRow(issue, row, now)) },
+    { heading: "claimed, no live session here", count: away.length, ...within(away, limit, ({ issue, row }) => claimRow(issue, row, now), (line, index) => [line, ...noteLine(away[index]?.comments ?? [], now)]) }
   ].filter((section) => section.count > 0);
   return sections.length === 0 ? "no open issue" : sections.map(({ heading, count, lines }) => `${heading} (${count})
 ${lines.join(`
@@ -1080,15 +1742,46 @@ ${lines.join(`
 
 `);
 }
+async function boardRows(issues, sessions, repo) {
+  const comments = await commentsOfAll(issues, repo);
+  const author = await sessionAuthor();
+  return issues.map((issue) => {
+    const own = comments.get(issue.number) ?? [];
+    return { issue, standing: standing(latestClaim(own, author), sessions), comments: own };
+  });
+}
+function boardJson(rows) {
+  return rows.map(({ issue, standing: { state, ...rest }, comments: own }) => {
+    const list = boxes(issue.body);
+    const note = latestNote(own);
+    return {
+      number: issue.number,
+      title: issue.title,
+      labels: issue.labels.map((label) => label.name),
+      state,
+      holder: "claim" in rest ? rest.claim.holder : undefined,
+      since: "claim" in rest ? rest.claim.at : undefined,
+      session: "session" in rest ? rest.session.name : undefined,
+      boxesTotal: list.length,
+      boxesLeft: list.filter((box) => !box.done).length,
+      note: note === undefined ? undefined : { author: note.user.login, at: note.created_at, body: note.body }
+    };
+  });
+}
 var boardUsage = `ft board
 
-Lists open issues as available, taken by a session running here, or claimed by a session no session here answers to, from their latest "Taken by session <name>." comment.
+Lists open issues, at most 30 of each kind (--full for all), as available, taken by a session running here, or claimed by a session no session here answers to, from their latest "Taken by session <name>." comment.
 A claim shows its boxes left, and one no live session holds also the latest comment that is not a claim.
-A lane's claim (lane-<n>-<issue>) is held while the session whose name ends in -<n> runs.`;
+A lane's claim (lane-<n>-<issue>) is held while the session whose name ends in -<n> runs.
+
+Exits 0 when it listed them, 1 when the issues cannot be read, 2 on a usage error.`;
+var BOARD_LIMIT = 30;
 var boardOptions = {
   labels: { type: "string", short: "L", description: "only issues with these labels, comma separated" },
+  milestone: { type: "string", short: "m", description: "only issues of this milestone, a title or an id" },
   query: { type: "string", short: "q", description: "only issues whose title matches this, a case-insensitive regex such as dom|eager" },
   state: { type: "string", description: "only issues in this state: available, taken or away (claimed, no live session here)" },
+  ...limitOptions(BOARD_LIMIT),
   json: jsonOption("number, title, labels, state, holder, since, session, boxesTotal, boxesLeft and note (author, at, body of the latest comment that is not a claim)"),
   ...repoOption
 };
@@ -1096,6 +1789,7 @@ async function board(args) {
   const parsed = parse(args, boardUsage, boardOptions);
   const { values } = parsed;
   const state = values.state;
+  const limit = limitOf(values, BOARD_LIMIT);
   if (state !== undefined && !STATES.has(state))
     fail(`--state takes available, taken or away, not ${state}`);
   let query;
@@ -1104,33 +1798,15 @@ async function board(args) {
   } catch (error) {
     fail(`--query: ${error instanceof Error ? error.message : String(error)}`);
   }
-  const [open, sessions] = await Promise.all([openIssues(values.labels, values.repo), liveSessions()]);
-  const issues = query === undefined ? open : open.filter((issue) => query.test(issue.title));
-  const comments = await commentsOfAll(issues, values.repo);
-  const rows = issues.map((issue) => {
-    const own = comments.get(issue.number) ?? [];
-    return { issue, standing: standing(latestClaim(own), sessions), comments: own };
-  }).filter((row) => state === undefined || row.standing.state === state);
+  const milestone = values.milestone === undefined ? undefined : (await findMilestone(values.milestone, values.repo)).id;
+  const [open, sessions] = await Promise.all([openIssues(values.labels, values.repo, milestone), liveSessions()]);
+  const issues = query === undefined ? open : open.filter((issue) => query.test(issue.title));
+  const rows = (await boardRows(issues, sessions, values.repo)).filter((row) => state === undefined || row.standing.state === state);
   if (values.json === true) {
-    printJson(rows.map(({ issue, standing: { state, ...rest }, comments: own }) => {
-      const list = boxes(issue.body);
-      const note = latestNote(own);
-      return {
-        number: issue.number,
-        title: issue.title,
-        labels: issue.labels.map((label) => label.name),
-        state,
-        holder: "claim" in rest ? rest.claim.holder : undefined,
-        since: "claim" in rest ? rest.claim.at : undefined,
-        session: "session" in rest ? rest.session.name : undefined,
-        boxesTotal: list.length,
-        boxesLeft: list.filter((box) => !box.done).length,
-        note: note === undefined ? undefined : { author: note.user.login, at: note.created_at, body: note.body }
-      };
-    }));
+    printJson(boardJson(rows));
     return 0;
   }
-  console.log(rows.length === 0 && (query !== undefined || state !== undefined) ? "no open issue matches" : renderBoard(rows));
+  console.log(rows.length === 0 && (query !== undefined || state !== undefined) ? "no open issue matches" : renderBoard(rows, Date.now(), limit));
   return 0;
 }
 async function me(as, sessions) {
@@ -1144,7 +1820,9 @@ async function me(as, sessions) {
 var takeUsage = `ft take <n>...
 
 Claims each issue for this Claude Code session with a "Taken by session <name>." comment.
-An issue another live session holds is refused, one this session or its lanes hold passes to the new name, and one claimed by a session no session here answers to needs --take-stale; a refusal leaves the other issues taken and exits 1.`;
+An issue another live session holds is refused, one this session or its lanes hold passes to the new name, and one claimed by a session no session here answers to needs --take-stale; a refusal leaves the other issues taken.
+
+Exits 0 when every issue is taken, 1 when one is refused, 2 on a usage error.`;
 var laneOption = {
   lane: { type: "boolean", description: "claim each as lane-<s>-<n>, <s> ending this session's name, so the claim stays live while it runs" }
 };
@@ -1172,6 +1850,8 @@ async function eachIssue(command, numbers, step) {
       if (!(error instanceof Exit) || numbers.length === 1)
         throw error;
       console.error(`ft ${command}: ${error.message}`);
+      if (error.hint !== undefined)
+        printHint(error.hint);
       code = Math.max(code, error.code);
     }
   }
@@ -1183,12 +1863,13 @@ async function take(args) {
   const numbers = issueNumbers(positionals, takeUsage);
   const sessions = await liveSessions();
   const nameFor = await claimant(values, sessions);
+  const author = await sessionAuthor();
   return eachIssue("take", numbers, async (number) => {
     const name = nameFor(number);
     const [found, comments] = await Promise.all([getIssue(number, values.repo), commentsOf(number, values.repo)]);
     if (found.state === "closed")
-      fail(`#${number} is closed`, 1);
-    const claim = latestClaim(comments);
+      fail(`#${number} is closed`, 1, runHint(`ft reopen ${number}`, "reopen it"));
+    const claim = latestClaim(comments, author);
     const current = standing(claim, sessions);
     if (claim?.holder === name) {
       console.log(`#${number} is already taken by ${name}`);
@@ -1197,14 +1878,19 @@ async function take(args) {
     if (current.state === "taken" && holderSession(name, sessions)?.pid !== current.session.pid)
       fail(`#${number} is taken by ${current.claim.holder}${current.session.name === current.claim.holder ? "" : ` in ${current.session.name}`}, which still runs (${current.session.status})`, 1);
     if (current.state === "away" && values["take-stale"] !== true)
-      fail(`#${number} was taken by ${current.claim.holder} ${formatAge(current.claim.at)}, which no session here answers to: it may run on another machine, so pass --take-stale to take it over`, 1);
+      fail(`#${number} was taken by ${current.claim.holder} ${formatAge(current.claim.at)}, which no session here answers to: it may run on another machine`, 1, runHint(`ft take ${number} --take-stale`, "take it over"));
     await comment(number, takenComment(name), values.repo);
+    const standingNow = latestClaim(await commentsOf(number, values.repo), author);
+    if (standingNow?.holder !== name)
+      fail(`#${number} was taken by ${standingNow?.holder ?? "another session"} at the same moment`, 1);
     console.log(`took #${number} as ${name}: ${found.title}`);
   });
 }
 var dropUsage = `ft drop <n>...
 
-Gives each issue back with a "Released by session <name>." comment, when this session holds it.`;
+Gives each issue back with a "Released by session <name>." comment, when this session holds it.
+
+Exits 0 when every issue is given back, 1 when one is not held by this session, 2 on a usage error.`;
 var dropOptions = {
   as: { type: "string", description: "the name it was taken as, instead of this session's" },
   ...laneOption,
@@ -1215,9 +1901,10 @@ async function drop(args) {
   const { values, positionals } = parsed;
   const numbers = issueNumbers(positionals, dropUsage);
   const nameFor = await claimant(values, await liveSessions());
+  const author = await sessionAuthor();
   return eachIssue("drop", numbers, async (number) => {
     const name = nameFor(number);
-    const claim = latestClaim(await commentsOf(number, values.repo));
+    const claim = latestClaim(await commentsOf(number, values.repo), author);
     if (claim?.holder !== name)
       fail(`#${number} is ${claim === undefined ? "not taken" : `taken by ${claim.holder}, not ${name}`}`, 1);
     await comment(number, releasedComment(name), values.repo);
@@ -1225,6 +1912,23 @@ async function drop(args) {
   });
 }
 
+// src/commands/ci.ts
+import process12 from "process";
+
+// src/git.ts
+async function tagsAt(commit) {
+  return (await git(["tag", "--points-at", commit])).split(`
+`).filter(Boolean);
+}
+async function commitsNaming(issue, ref) {
+  const out = await git(["log", ref, "--reverse", "--extended-regexp", `--grep=#${issue}([^0-9]|$)`, "--format=%H %s"]);
+  return out.split(`
+`).filter(Boolean).map((line) => {
+    const space = line.indexOf(" ");
+    return { sha: line.slice(0, space), subject: line.slice(space + 1) };
+  });
+}
+
 // src/log.ts
 var BOUNDARY = /^(?:\((?:pass|fail|skip|todo)\) |::(?:end)?group::|\S+\.test\.[jt]sx?:$)/;
 var DURATION2 = / \[[\d.]+m?s\]$/;
@@ -1280,12 +1984,32 @@ function runSeconds(run) {
 function startedAge(run, now = Date.now()) {
   return Date.parse(run.started) < EPOCH ? "-" : formatAge(run.started, now);
 }
-async function recentRuns(limit, repo, workflow) {
+var RUNS_PAGE = 50;
+async function runsListing(limit, repo, workflow) {
   const filter = workflow === undefined ? "" : `&workflow_id=${encodeURIComponent(workflow)}`;
-  return (await repoApi(`actions/runs?page=1&limit=${limit}${filter}`, repo)).workflow_runs ?? [];
+  const runs = [];
+  let total = 0;
+  for (let page = 1;runs.length < limit; page++) {
+    const found = await repoApi(`actions/runs?page=${page}&limit=${RUNS_PAGE}${filter}`, repo);
+    const list = found.workflow_runs ?? [];
+    runs.push(...list);
+    total = found.total_count ?? 0;
+    if (list.length < RUNS_PAGE)
+      break;
+  }
+  return { runs: runs.slice(0, limit), total: Math.max(total, runs.length) };
+}
+async function recentRuns(limit, repo, workflow) {
+  return (await runsListing(limit, repo, workflow)).runs;
 }
 async function runsOn(sha, repo) {
-  return (await repoApi(`actions/runs?head_sha=${sha}`, repo)).workflow_runs ?? [];
+  const runs = [];
+  for (let page = 1;; page++) {
+    const list = (await repoApi(`actions/runs?head_sha=${sha}&page=${page}&limit=${RUNS_PAGE}`, repo)).workflow_runs ?? [];
+    runs.push(...list);
+    if (list.length < RUNS_PAGE)
+      return runs;
+  }
 }
 async function runById(id, repo) {
   return repoApi(`actions/runs/${id}`, repo);
@@ -1371,9 +2095,9 @@ var options = {
   job: { type: "string", short: "j", description: "a job whose skipping means the run left its work to a newer push" },
   timeout: { type: "string", short: "t", description: "how long before giving up (30m), a bare number in minutes" }
 };
-var POLL = 15000;
 var NO_RUN = 3 * 60000;
 var STALLED = 3 * 60000;
+var MAX_LOOKUPS = 20;
 function judge(runs, jobSkipped, tagged) {
   if (runs.length === 0)
     return { kind: "none" };
@@ -1385,7 +2109,13 @@ function judge(runs, jobSkipped, tagged) {
     return { kind: "runs", runs };
   return tagged ? { kind: "runs", runs: runs.map((run) => ({ ...run, status: "skipped" })) } : { kind: "passed-over" };
 }
-async function ci(args) {
+function commitsToAsk(commits, passedOver, max = MAX_LOOKUPS) {
+  return commits.filter((commit) => !passedOver.has(commit)).slice(0, max);
+}
+function settled(latest) {
+  return latest !== undefined && latest.every((run) => FINISHED.has(run.status)) && judge(latest, false, false).kind === "runs" ? latest : undefined;
+}
+async function ci2(args) {
   const parsed = parse(args, usage, options);
   const { values, positionals } = parsed;
   const branch = values.branch ?? await defaultBranch();
@@ -1409,62 +2139,44 @@ async function ci(args) {
     return coverage;
   }
   async function covering() {
-    await git(["fetch", "-q", "origin", branch]);
+    await fetchBranch(branch);
     if (!await gitOk(["merge-base", "--is-ancestor", sha, `origin/${branch}`]))
-      fail(`${short} is not on origin/${branch}: push it first`);
+      fail(`${short} is not on origin/${branch}`, 2, runHint(`git push origin ${branch}`));
     const later = (await git(["rev-list", "--reverse", "--first-parent", `${sha}..origin/${branch}`])).split(`
 `).filter(Boolean);
-    for (const commit of [sha, ...later]) {
+    for (const commit of commitsToAsk([sha, ...later], passedOver)) {
       const coverage = await coverageOf(commit);
       if (coverage.kind === "runs")
         return coverage.runs;
     }
     return;
   }
-  const started = Date.now();
-  let seen = started;
-  let moving = started;
-  let followed = "";
-  let runs;
-  for (;; ) {
-    if (Date.now() - started > giveUp)
-      fail(`CI has not finished on ${short} in ${formatDuration(giveUp)}${runs === undefined ? "" : `: ${runs.map((run) => run.html_url).join(" ")}`}`);
-    try {
-      runs = await covering();
-    } catch (error) {
-      if (error instanceof Exit)
-        throw error;
-      if (cwdGone())
-        fail(`the working directory was removed while waiting for CI on ${short}${runs === undefined ? "" : `: ${runs.map((run) => run.html_url).join(" ")}`}`);
-      console.warn(`ft ci: ${error instanceof Error ? error.message : String(error)}, polling again`);
-      const latest = runs === undefined ? undefined : await refreshed(runs);
-      if (latest?.every((run) => FINISHED.has(run.status)) === true) {
-        runs = latest;
-        break;
-      }
-      await Bun.sleep(POLL);
-      continue;
-    }
-    if (runs !== undefined) {
-      seen = Date.now();
-      const ids = runs.map((run) => run.id).join(",");
-      if (ids !== followed) {
-        followed = ids;
-        for (const run of runs)
-          console.log(`following ${run.workflow_id} run ${run.id} on ${run.commit_sha.slice(0, 7)}${run.commit_sha === sha ? "" : `, which covers ${short}`}: ${run.html_url}`);
-      }
-      if (runs.every((run) => FINISHED.has(run.status)))
-        break;
-      const stall = await stallReason(runs);
-      if (stall === undefined)
-        moving = Date.now();
-      else if (stall.certain || Date.now() - moving > STALLED)
-        fail(`runs queued on ${short} are not moving: ${stall.reason}`);
-    } else if (Date.now() - seen > NO_RUN) {
-      fail(`no run covers ${short} yet: its own was cancelled by a later push or never started, so the next push's will`);
-    }
-    await Bun.sleep(POLL);
-  }
+  const { dim } = paint(process12.stderr);
+  const runs = await waitForCi({
+    tool: "ft ci",
+    short,
+    giveUpMs: giveUp,
+    noneMs: NO_RUN,
+    stalledMs: STALLED,
+    noneMessage: `no run covers ${short} yet: its own was cancelled by a later push or never started, so the next push's will`,
+    covering,
+    finished: (found) => found.every((run) => FINISHED.has(run.status)),
+    key: (found) => found.map((run) => run.id).join(","),
+    announce: (found) => {
+      for (const run of found)
+        console.log(`following ${run.workflow_id} run ${run.id} on ${run.commit_sha.slice(0, 7)}${run.commit_sha === sha ? "" : `, which covers ${short}`}: ${run.html_url}`);
+    },
+    links: (found) => found.map((run) => run.html_url).join(" "),
+    settle: async (found) => settled(await refreshed(found)),
+    stall: async (found) => {
+      const stall = await stallReason(found);
+      return stall === undefined ? undefined : { message: `runs queued on ${short} are not moving: ${stall.reason}`, certain: stall.certain };
+    },
+    lines: (spinner, found, started) => [
+      `${spinner} CI on ${short} ${dim(formatDuration(Date.now() - started))}`,
+      ...(found ?? []).map((run) => `  ${badge(run.status, process12.stderr)} ${run.workflow_id} ${dim(`run ${run.id}`)}`)
+    ]
+  });
   const status = overall(runs);
   if (status !== "failure") {
     console.log(`CI ${status === "success" ? "passed" : "skipped its tests, a release tag's workflow testing them"} on ${short}`);
@@ -1480,6 +2192,129 @@ run ${run.id} failed${run.commit_sha === sha ? "" : `, testing every commit from
   return 1;
 }
 
+// src/commands/digest.ts
+import process13 from "process";
+var RUNS_SCANNED = 50;
+var TITLE_WIDTH2 = 70;
+var SHOWN = 8;
+var LINE_START2 = /^/gm;
+function claimed(issue, claim) {
+  const list = boxes(issue.body);
+  return { number: issue.number, title: issue.title, holder: claim.holder, since: claim.at, boxesLeft: list.filter((box) => !box.done).length, boxesTotal: list.length };
+}
+function claims(rows, sessions, me) {
+  const held = [];
+  const away = [];
+  for (const { issue, claim } of rows) {
+    const row = standing(claim, sessions);
+    if (row.state === "taken" && me !== undefined && row.session.pid === me.pid)
+      held.push(claimed(issue, row.claim));
+    else if (row.state === "away")
+      away.push(claimed(issue, row.claim));
+  }
+  return { held, away };
+}
+function unsettled(runs, branch) {
+  return newestPerWorkflow(runs.filter((run) => run.prettyref === branch)).filter((run) => run.status === "failure" || !FINISHED.has(run.status)).map((run) => ({ id: run.id, status: run.status, workflow: run.workflow_id, started: run.started, title: run.title }));
+}
+function dirtyFiles(porcelain) {
+  return porcelain.split(`
+`).flatMap((line) => {
+    const trimmed = line.trim();
+    const space = trimmed.indexOf(" ");
+    return space === -1 ? [] : [{ status: trimmed.slice(0, space), path: trimmed.slice(space + 1).trim() }];
+  });
+}
+async function unpushedCommits() {
+  const base = await gitOk(["rev-parse", "--verify", "-q", "@{upstream}"]) ? "@{upstream}" : `origin/${await defaultBranch()}`;
+  if (!await gitOk(["rev-parse", "--verify", "-q", base]))
+    return [];
+  return (await git(["log", `${base}..HEAD`, "--format=%h %s"])).split(`
+`).filter(Boolean);
+}
+async function dirtyTree() {
+  return dirtyFiles(await git(["status", "--porcelain"]));
+}
+async function quietly(read) {
+  try {
+    return await read();
+  } catch {
+    return [];
+  }
+}
+async function staleTodos() {
+  const bin = Bun.which("todo-scan", { PATH: process13.env.PATH ?? "" });
+  if (bin === null)
+    return [];
+  let found;
+  try {
+    const ran = await runCommand([bin, "--stale", "--json"]);
+    found = JSON.parse(Buffer.concat(ran.chunks.filter((chunk) => chunk.stream === "stdout").map((chunk) => chunk.data)).toString());
+  } catch {
+    return [];
+  }
+  const byIssue = new Map;
+  for (const mark of found) {
+    for (const ref of mark.refs.filter((each) => each.state === "closed")) {
+      const key = `${ref.repo}#${ref.number}`;
+      const entry = byIssue.get(key) ?? { issue: key, comments: [] };
+      entry.comments.push({ path: mark.path, line: mark.line });
+      byIssue.set(key, entry);
+    }
+  }
+  return [...byIssue.values()];
+}
+function claimLine(row, now) {
+  return [`#${row.number}`, row.holder, formatAge(row.since, now), row.boxesTotal === 0 ? "" : `${row.boxesLeft}/${row.boxesTotal} left`, truncate(row.title, TITLE_WIDTH2)];
+}
+function capped2(lines) {
+  return lines.length > SHOWN ? [...lines.slice(0, SHOWN), `... ${lines.length - SHOWN} more`] : lines;
+}
+function renderDigest(digest, now = Date.now()) {
+  const sections = [
+    { heading: "held by this session", count: digest.held.length, lines: table(digest.held.map((row) => claimLine(row, now))).split(`
+`) },
+    { heading: "claimed, no live session here", count: digest.away.length, lines: table(digest.away.map((row) => claimLine(row, now))).split(`
+`) },
+    { heading: "CI on the default branch", count: digest.ci.length, lines: digest.ci.map((run) => `${run.workflow} ${run.status} (run ${run.id}) ${truncate(upTo(run.title, `
+`), TITLE_WIDTH2)}`) },
+    { heading: "unpushed commits", count: digest.unpushed.length, lines: capped2(digest.unpushed) },
+    { heading: "dirty files", count: digest.dirty.length, lines: capped2(digest.dirty.map((file) => `${file.status} ${file.path}`)) },
+    { heading: "stale TODO comments", count: digest.stale.length, lines: capped2(digest.stale.map((todo) => `${todo.issue} closed: ${todo.comments.map((each) => `${each.path}:${each.line}`).join(", ")}`)) }
+  ].filter((section) => section.count > 0);
+  return sections.length === 0 ? "nothing to pick up" : sections.map(({ heading, count, lines }) => `${heading} (${count})
+${lines.join(`
+`).replace(LINE_START2, "  ")}`).join(`
+
+`);
+}
+var usage2 = `ft digest
+
+Summarises the repository for a session starting cold: the issues this session holds with their boxes left, the claims no live session here answers to, red or running CI on the default branch, unpushed commits, dirty files and TODO comments naming a closed issue.
+A section with nothing in it is left out, and the stale TODO comments need todo-scan on the PATH.
+
+Exits 0 when it summarised the repository, 1 when Forgejo cannot be read, 2 on a usage error.`;
+var options2 = {
+  json: jsonOption("held and away (number, title, holder, since, boxesLeft, boxesTotal), ci (id, status, workflow, started, title), unpushed, dirty (status, path) and stale (issue, comments: path, line)"),
+  ...repoOption
+};
+async function digest(args) {
+  const parsed = parse(args, usage2, options2);
+  const { values } = parsed;
+  const [issues, sessions, branch, runs] = await Promise.all([openIssues(undefined, values.repo), liveSessions(), defaultBranch(), recentRuns(RUNS_SCANNED, values.repo)]);
+  const comments = await commentsOfAll(issues, values.repo);
+  const me = await currentSession(sessions);
+  const author = await sessionAuthor();
+  const rows = issues.map((issue) => ({ issue, claim: latestClaim(comments.get(issue.number) ?? [], author) }));
+  const [unpushed, dirty, stale] = await Promise.all([quietly(unpushedCommits), quietly(dirtyTree), staleTodos()]);
+  const summary = { ...claims(rows, sessions, me), ci: unsettled(runs, branch), unpushed, dirty, stale };
+  if (values.json === true)
+    printJson(summary);
+  else
+    console.log(renderDigest(summary));
+  return 0;
+}
+
 // src/commands/triage.ts
 async function checkLabels(names, repo) {
   if (names.length === 0)
@@ -1513,13 +2348,17 @@ async function setState(args, usage, wanted) {
 }
 var closeUsage = `ft close <n>... [-m <reason>]
 
-Closes issues without a fix, a duplicate or one dropped, posting the -m reason first. \`ft fixed\` closes one a commit fixed.`;
+Closes issues without a fix, a duplicate or one dropped, posting the -m reason first. \`ft fixed\` closes one a commit fixed.
+
+Exits 0 when every issue is closed, 1 when Forgejo refuses, 2 on a usage error.`;
 async function closeIssues(args) {
   return setState(args, closeUsage, "closed");
 }
 var reopenUsage = `ft reopen <n>... [-m <reason>]
 
-Reopens closed issues, posting the -m reason first.`;
+Reopens closed issues, posting the -m reason first.
+
+Exits 0 when every issue is open, 1 when Forgejo refuses, 2 on a usage error.`;
 async function reopenIssues(args) {
   return setState(args, reopenUsage, "open");
 }
@@ -1544,7 +2383,9 @@ function labelChanges(args) {
 }
 var labelUsage = `ft label <n> [+]<label>... -<label>...
 
-Adds the labels named bare or with +, removes those named with -, then prints the issue's labels. A label the repository lacks is refused.`;
+Adds the labels named bare or with +, removes those named with -, then prints the issue's labels. A label the repository lacks is refused.
+
+Exits 0 when it changed the labels, 1 when Forgejo refuses, 2 on a usage error or a label the repository lacks.`;
 async function label(args) {
   const changes = labelChanges(args);
   const parsed = parse(changes.rest, labelUsage, repoOption);
@@ -1570,7 +2411,9 @@ ${labelUsage}`);
 var issueUsage = `ft issue <n>...
 
 Prints each issue: its title, state, boxes left and claim, then its description with each checklist box numbered as \`ft tick\` takes it.
-With --body, prints only the raw description, to edit and give back to \`ft edit -F\`.`;
+With --body, prints only the raw description, to edit and give back to \`ft edit -F\`.
+
+Exits 0 when it printed them, 1 when an issue cannot be read, 2 on a usage error.`;
 var issueOptions = {
   todo: { type: "boolean", short: "t", description: "only the header and the boxes left to tick" },
   comments: { type: "boolean", short: "c", description: "add the comments, each with its author and age" },
@@ -1579,7 +2422,7 @@ var issueOptions = {
   ...repoOption
 };
 function renderIssue(found, comments, view, now = Date.now()) {
-  const claim = latestClaim(comments);
+  const claim = latestClaim(comments, view.author);
   const list = boxes(found.body);
   const left = list.filter((box) => !box.done);
   const facts = [found.state];
@@ -1607,14 +2450,14 @@ ${each.body.replaceAll(`\r
 
 `);
 }
-function issueJson(found, comments) {
+function issueJson(found, comments, author) {
   return {
     number: found.number,
     title: found.title,
     state: found.state,
     url: found.html_url,
     labels: found.labels.map((label) => label.name),
-    claim: latestClaim(comments) ?? null,
+    claim: latestClaim(comments, author) ?? null,
     boxes: boxes(found.body).map(({ number, done, text }) => ({ number, done, text })),
     body: found.body,
     comments: comments.map((each) => ({ author: each.user.login, at: each.created_at, body: each.body }))
@@ -1634,12 +2477,13 @@ async function issue(args) {
     return 0;
   }
   const read = await Promise.all(numbers.map(async (number) => Promise.all([getIssue(number, values.repo), commentsOf(number, values.repo)])));
+  const author = await sessionAuthor();
   if (values.json === true) {
-    const json = read.map(([found, comments]) => issueJson(found, comments));
+    const json = read.map(([found, comments]) => issueJson(found, comments, author));
     printJson(json.length === 1 ? json[0] : json);
     return 0;
   }
-  const view = { todo: values.todo === true, comments: values.comments === true };
+  const view = { todo: values.todo === true, comments: values.comments === true, author };
   console.log(read.map(([found, comments]) => renderIssue(found, comments, view)).join(view.todo ? `
 
 ` : `
@@ -1658,11 +2502,14 @@ async function noteText(values) {
   const text = values.file === undefined ? values.message : await readInput(values.file);
   return text?.trim() === "" ? undefined : text?.trim();
 }
+var NOT_FOUND = /not exist|not found|couldn't be found/i;
 async function isClosed(number, repo) {
   try {
     return (await getIssue(number, repo)).state === "closed";
-  } catch {
-    return false;
+  } catch (error) {
+    if (error instanceof Error && NOT_FOUND.test(error.message))
+      return false;
+    throw error;
   }
 }
 async function closedReferences(body, repo) {
@@ -1670,15 +2517,23 @@ async function closedReferences(body, repo) {
   const states = await Promise.all(listed.map(async (issue) => isClosed(issue, repo)));
   return new Set(listed.filter((_, at) => states[at] === true));
 }
-var newUsage = `ft new -t <title> [-F <file>]
+var newUsage = `ft new -t <title> [-F <file>] [-L a,b] [-m <milestone>]
 
-Creates an issue and prints its number and url. The description is read from -F <file>, or from stdin with -F -, and is empty without it. A label the repository lacks is refused before anything is created.`;
+Creates an issue and prints its number and url. The description is read from -F <file>, or from stdin with -F -, and is empty without it. A label or milestone the repository lacks is refused before anything is created.
+
+Exits 0 when it created the issue, 1 when Forgejo refuses, 2 on a usage error or a label or milestone the repository lacks.`;
 var newOptions = {
   title: { type: "string", short: "t", description: "the issue title" },
   file: { type: "string", short: "F", description: "the description: a file, - for stdin" },
   labels: { type: "string", short: "L", description: "comma-separated labels" },
+  milestone: { type: "string", short: "m", description: "the milestone, a title or an id; the repository must have it" },
   ...repoOption
 };
+async function milestoneTitle(reference, repo) {
+  if (reference === undefined)
+    return;
+  return reference.trim() === "" ? "" : (await findMilestone(reference.trim(), repo)).title;
+}
 async function newIssue(args) {
   const parsed = parse(args, newUsage, newOptions);
   const { values } = parsed;
@@ -1688,20 +2543,25 @@ async function newIssue(args) {
 ${newUsage}`);
   const body = await noteText({ file: values.file });
   await checkLabels((values.labels ?? "").split(",").map((name) => name.trim()).filter((name) => name !== ""), values.repo);
-  const created = await createIssue(values.title.trim(), body ?? "", values.labels, values.repo);
+  const milestone = await milestoneTitle(values.milestone, values.repo);
+  const created = await createIssue(values.title.trim(), body ?? "", values.labels, milestone === "" ? undefined : milestone, values.repo);
   console.log(`#${created.number} ${created.html_url}`);
   return 0;
 }
-var editUsage = `ft edit <n> [-t <title>] [-F <file> [--append]] [--add-box <text>]...
+var editUsage = `ft edit <n> [-t <title>] [-F <file> [--append]] [--add-box <text>]... [-m <milestone>]
 
 Replaces the title and/or the description of issue <n>, the description from -F <file> or from stdin with -F -.
+-m moves it to a milestone given by title or id, and \`-m ''\` takes it out of its milestone.
 --append adds the -F text after the description instead, and each --add-box an unticked box after the last one, the rest of the description untouched.
-\`ft issue <n> --body\` prints the description to edit.`;
+\`ft issue <n> --body\` prints the description to edit.
+
+Exits 0 when it edited the issue, 1 when Forgejo refuses, 2 on a usage error.`;
 var editOptions = {
   title: { type: "string", short: "t", description: "the new title" },
   file: { type: "string", short: "F", description: "the new description: a file, - for stdin" },
   append: { type: "boolean", short: "a", description: "add the -F text after the description instead of replacing it" },
   "add-box": { type: "string", multiple: true, description: "add an unticked box after the last one, repeatable" },
+  milestone: { type: "string", short: "m", description: "move the issue to this milestone, a title or an id; an empty value takes it out of its milestone" },
   ...repoOption
 };
 async function edit(args) {
@@ -1714,35 +2574,51 @@ async function edit(args) {
     fail("the description file is empty");
   if (values.append === true && text === undefined)
     fail("--append adds the -F text, give -F");
-  if (values.title === undefined && text === undefined && added.length === 0)
-    fail(`nothing to change: give -t, -F or --add-box
+  if (values.title === undefined && text === undefined && added.length === 0 && values.milestone === undefined)
+    fail(`nothing to change: give -t, -F, --add-box or -m
 
 ${editUsage}`);
   const change = values.title === undefined ? {} : { title: values.title.trim() };
-  if (text !== undefined && values.append !== true)
+  const milestone = await milestoneTitle(values.milestone, values.repo);
+  if (milestone !== undefined)
+    change.milestone = milestone;
+  const grows = text !== undefined && values.append === true || added.length > 0;
+  if (text !== undefined && !grows)
     change.body = text;
-  else if (text !== undefined || added.length > 0)
-    change.body = (await getIssue(number, values.repo)).body;
-  if (text !== undefined && values.append === true)
-    change.body = `${(change.body ?? "").trimEnd()}
-
-${text}`;
-  if (added.length > 0)
-    change.body = appendBoxes(change.body ?? "", added);
-  await editIssue(number, change, values.repo);
+  if (Object.keys(change).length > 0)
+    await editIssue(number, change, values.repo);
+  if (grows) {
+    await editBody(number, (body) => {
+      const appended = text !== undefined && values.append === true && !body.trimEnd().endsWith(text) ? `${body.trimEnd()}
+
+${text}` : body;
+      const present = new Set(boxes(appended).map((box) => box.text));
+      const missing = added.filter((box) => !present.has(box));
+      return missing.length > 0 ? appendBoxes(appended, missing) : appended;
+    }, values.repo);
+  }
   console.log(`edited #${number}`);
   return 0;
 }
 var tickUsage = `ft tick <n> <box>...
 
 Ticks checklist boxes of issue <n>, each given by its number from \`ft issue\` or by text matching exactly one box, then posts the -m or -F comment.
-With --closed, ticks instead every box opening with \`#<issue>\` whose issue is closed, as a release plan lists them.`;
+With --closed, ticks instead every box opening with \`#<issue>\` whose issue is closed, as a release plan lists them.
+
+Exits 0 when it ticked the boxes, 1 when Forgejo refuses, 2 on a usage error or a box matching none or several.`;
 var tickOptions = {
   undo: { type: "boolean", short: "u", description: "untick them instead" },
   closed: { type: "boolean", description: "tick the boxes listing a closed issue, no box to name" },
   ...noteOptions,
   ...repoOption
 };
+function tickedOrFail(number, run) {
+  try {
+    return run();
+  } catch (error) {
+    fail(`#${number}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
 async function tick(args) {
   const parsed = parse(args, tickUsage, tickOptions);
   const { values, positionals } = parsed;
@@ -1760,17 +2636,13 @@ ${tickUsage}`);
   const found = await getIssue(number, values.repo);
   const done = values.undo !== true;
   const closed = values.closed === true ? await closedReferences(found.body, values.repo) : undefined;
-  let result;
-  try {
-    result = closed === undefined ? setBoxes(found.body, picks, done) : tickReferences(found.body, (issue) => closed.has(issue));
-  } catch (error) {
-    fail(`#${number}: ${error instanceof Error ? error.message : String(error)}`);
-  }
+  const apply = (body) => closed === undefined ? setBoxes(body, picks, done) : tickReferences(body, (issue) => closed.has(issue));
+  let result = tickedOrFail(number, () => apply(found.body));
   if (result.changed.length > 0) {
-    if (closed === undefined)
-      await setBody(number, result.body, values.repo);
-    else
-      await editBody(number, (body) => tickReferences(body, (issue) => closed.has(issue)).body, values.repo);
+    await editBody(number, (body) => {
+      result = tickedOrFail(number, () => apply(body));
+      return result.body;
+    }, values.repo);
   }
   for (const box of result.changed)
     console.log(`${done ? "ticked" : "unticked"} ${box.number}: ${box.text}`);
@@ -1784,7 +2656,9 @@ ${tickUsage}`);
 }
 var commentUsage = `ft comment <n> [text]
 
-Posts a comment on issue <n>: the text given, -F <file>, or stdin when neither is, so a heredoc needs no escaping.`;
+Posts a comment on issue <n>: the text given, -F <file>, or stdin when neither is, so a heredoc needs no escaping.
+
+Exits 0 when it posted the comment, 1 when Forgejo refuses, 2 on a usage error.`;
 var commentOptions = {
   file: noteOptions.file,
   ...repoOption
@@ -1807,7 +2681,9 @@ var fixedUsage = `ft fixed <n> [commit]...
 
 Comments "Fixed in <sha>: <message>" on issue <n> and closes it, naming each commit given as "Fixed in <a>, <b> and <c>".
 Without a commit it takes those on origin's default branch whose message names #<n>, and says which, or HEAD when none does.
-The message defaults to the subject of the first commit. Every open issue listing \`- [ ] #<n>\` in its checklist gets that line ticked. An issue with boxes left is refused, as a partly done issue stays open, unless --tick ticks them first.`;
+The message defaults to the subject of the first commit. Every open issue listing \`- [ ] #<n>\` in its checklist gets that line ticked. An issue with boxes left is refused, as a partly done issue stays open, unless --tick ticks them first.
+
+Exits 0 when it closed the issue, 1 when the issue is already closed, has boxes left or Forgejo refuses, 2 on a usage error.`;
 var fixedOptions = {
   message: { type: "string", short: "m", description: 'the line after "Fixed in <sha>:"' },
   tick: { type: "boolean", description: "tick the boxes left before closing" },
@@ -1854,18 +2730,20 @@ async function fixed(args) {
   const commits = await fixingCommits(number, positionals.slice(1));
   const found = await getIssue(number, values.repo);
   if (found.state === "closed")
-    fail(`#${number} is already closed`);
+    fail(`#${number} is already closed`, 1, runHint(`ft reopen ${number}`, "reopen it"));
   const left = boxes(found.body).filter((box) => !box.done);
   if (left.length > 0 && values.tick === true) {
-    await setBody(number, setBoxes(found.body, left.map((box) => String(box.number)), true).body, values.repo);
+    await editBody(number, (body) => setBoxes(body, boxes(body).filter((box) => !box.done).map((box) => String(box.number)), true).body, values.repo);
     console.log(`ticked ${left.length} box${left.length === 1 ? "" : "es"} of #${number}`);
   } else if (left.length > 0 && values.force !== true) {
-    fail(`#${number} has ${left.length} boxes left, tick them, pass --tick or pass --force:
+    fail(`#${number} has ${left.length} boxes left:
 ${left.map((box) => `${String(box.number).padStart(3)} [ ] ${box.text}`).join(`
-`)}`);
+`)}`, 1, `${runHint(`ft fixed ${number} --tick`, "tick them and close")}, or ${runHint(`ft fixed ${number} --force`, "close with them left")}`);
   }
   const shas = joinShas(commits.map((each) => each.sha.slice(0, 7)));
-  await comment(number, `Fixed in ${shas}: ${values.message ?? commits[0]?.subject ?? ""}`, values.repo);
+  const line = `Fixed in ${shas}: ${values.message ?? commits[0]?.subject ?? ""}`;
+  if ((await commentsOf(number, values.repo)).at(-1)?.body.trim() !== line.trim())
+    await comment(number, line, values.repo);
   await close(number, values.repo);
   console.log(`closed #${number}: fixed in ${shas}`);
   await tickListings(number, values.repo);
@@ -1873,44 +2751,182 @@ ${left.map((box) => `${String(box.number).padStart(3)} [ ] ${box.text}`).join(`
 }
 
 // src/commands/logs.ts
-var usage2 = `ft logs <run id>
+var usage3 = `ft logs <run id>
 
 Prints what the failed jobs of a run say went wrong: each failed bun test's output and the end of each failed step.
-With no failed job it prints every job's last lines; --full prints whole logs.`;
-var options2 = {
-  job: { type: "string", short: "j", description: "only this job, by name" },
+With no failed job it prints every job's last lines; --full prints whole logs.
+
+Exits 0 when it printed the logs, 1 when Forgejo cannot be read, 2 on a usage error or a job the run lacks.`;
+var options3 = {
+  job: { type: "string", short: "j", description: "only this job, by name or id" },
   full: { type: "boolean", short: "f", description: "the whole log, timestamps stripped" },
   ...repoOption
 };
-function pickJobs(jobs, name) {
-  if (name !== undefined)
-    return jobs.filter((job) => job.name === name);
+function pickJobs(jobs, wanted) {
+  if (wanted !== undefined)
+    return jobs.filter((job) => job.name === wanted || String(job.id) === wanted);
   const failed = jobs.filter((job) => job.status === "failure");
   return failed.length > 0 ? failed : jobs;
 }
-async function logs(args) {
-  const parsed = parse(args, usage2, options2);
+async function logs2(args) {
+  const parsed = parse(args, usage3, options3);
   const { values, positionals } = parsed;
   if (positionals[0] === undefined)
-    fail(`a run id is needed, as \`ft runs\` lists them
-
-${usage2}`);
-  const run = await runById(wholeNumber(positionals[0], "run id", 0), values.repo);
+    fail("a run id is needed", 2, runHint("ft runs", "list them"));
+  const run = await runById(wholeNumber(positionals[0], "<run id>", 0), values.repo);
   const jobs = await jobsOf(run.id, values.repo);
   const picked = pickJobs(jobs, values.job);
   if (picked.length === 0)
-    fail(`run ${run.id} has no job ${values.job ?? ""}: ${jobs.map((job) => job.name).join(", ")}`);
-  console.log(`${run.workflow_id} run ${run.id} on ${run.prettyref} (${run.commit_sha.slice(0, 7)}): ${run.status}, ${run.html_url}`);
+    fail(`run ${run.id} has no job ${values.job ?? ""}: ${jobs.map((job) => job.name).join(", ")}`, 2, runHint(`ft logs ${run.id}`, "read every failed job"));
+  console.log(`${run.workflow_id} run ${run.id} on ${run.prettyref} (${run.commit_sha.slice(0, 7)}): ${badge(run.status, process.stdout)}, ${run.html_url}`);
   for (const job of picked) {
     const log = await jobLog(job.id, values.repo);
     console.log(`
-job ${job.name}: ${job.status}
+job ${job.name}: ${badge(job.status, process.stdout)}
 ${values.full === true ? logLines(log).join(`
 `) : excerpt(log)}`);
   }
   return 0;
 }
 
+// src/commands/milestone.ts
+var TITLE_WIDTH3 = 60;
+var LIST_LIMIT = 30;
+function counts(milestone) {
+  return `${milestone.open_issues} open, ${milestone.closed_issues} closed`;
+}
+var listUsage = `ft milestones
+
+Lists the repository's milestones, the open ones unless --state says otherwise, with the issues open and closed in each, the progress and the due date.
+
+Exits 0 when it listed them, 1 when Forgejo refuses, 2 on a usage error.`;
+var listOptions = {
+  state: { type: "string", description: "open (the default), closed or all" },
+  ...limitOptions(LIST_LIMIT),
+  json: jsonOption("id, title, state, description, open, closed, due (YYYY-MM-DD or null)"),
+  ...repoOption
+};
+async function milestones(args) {
+  const parsed = parse(args, listUsage, listOptions);
+  const { values } = parsed;
+  const state = values.state ?? "open";
+  if (state !== "open" && state !== "closed" && state !== "all")
+    fail(`--state takes open, closed or all, not ${state}`);
+  const limit = limitOf(values, LIST_LIMIT);
+  const found = await listMilestones(state, values.repo);
+  if (values.json === true) {
+    printJson(found.map((each) => ({ id: each.id, title: each.title, state: each.state, description: each.description, open: each.open_issues, closed: each.closed_issues, due: dueDate(each) || null })));
+    return 0;
+  }
+  if (found.length === 0) {
+    console.log(`no ${state === "all" ? "" : `${state} `}milestone`);
+    return 0;
+  }
+  const { shown, footer } = capped(found, limit);
+  const showState = state === "all";
+  const rows = shown.map((each) => [String(each.id), truncate(each.title, TITLE_WIDTH3), `${each.open_issues} open`, `${each.closed_issues} closed`, progress(each), dueDate(each) === "" ? "" : `due ${dueDate(each)}`, ...showState ? [each.state] : []]);
+  console.log(table(rows));
+  if (footer !== undefined)
+    console.log(footer);
+  return 0;
+}
+var newUsage2 = `ft milestone new <title> [-d <text>] [--due <YYYY-MM-DD>]
+
+Creates a milestone through the API and prints its id. Without --due it has no due date.
+
+Exits 0 when it created the milestone, 1 when Forgejo refuses, 2 on a usage error.`;
+var newOptions2 = {
+  description: { type: "string", short: "d", description: "the milestone description" },
+  due: { type: "string", description: "the due date, YYYY-MM-DD" },
+  ...repoOption
+};
+async function create(args) {
+  const parsed = parse(args, newUsage2, newOptions2);
+  const { values, positionals } = parsed;
+  const title = positionals.join(" ").trim();
+  if (title === "")
+    fail(`give the milestone a title
+
+${newUsage2}`);
+  const due = values.due === undefined ? undefined : dueOn(values.due);
+  const created = await createMilestone(title, values.description, due, values.repo);
+  console.log(`milestone ${created.id} ${created.title}${dueDate(created) === "" ? "" : `, due ${dueDate(created)}`}`);
+  return 0;
+}
+var closeUsage2 = `ft milestone close <title|id> [--force]
+
+Closes a milestone, refused while issues are open in it, which it names. --force closes it with them left.
+
+Exits 0 when it closed the milestone, 1 when issues are open in it or Forgejo refuses, 2 on a usage error.`;
+var closeOptions = {
+  force: { type: "boolean", description: "close it with issues left open" },
+  ...repoOption
+};
+async function closeOne(args) {
+  const parsed = parse(args, closeUsage2, closeOptions);
+  const { values, positionals } = parsed;
+  const reference = positionals.join(" ").trim();
+  if (reference === "")
+    fail(`name the milestone to close
+
+${closeUsage2}`);
+  const found = await findMilestone(reference, values.repo);
+  if (found.state === "closed") {
+    console.log(`milestone ${found.title} is already closed`);
+    return 0;
+  }
+  const open = await openIssues(undefined, values.repo, found.id);
+  if (open.length > 0 && values.force !== true)
+    fail(`milestone ${found.title} has ${open.length} open issue${open.length === 1 ? "" : "s"}:
+${open.map((issue) => `  #${issue.number} ${truncate(issue.title, TITLE_WIDTH3)}`).join(`
+`)}`, 1, `${runHint(`ft milestone close ${found.title} --force`, "close it with them open")}, or move them with \`ft edit <n> -m <milestone>\``);
+  await closeMilestone(found.id, values.repo);
+  console.log(`closed milestone ${found.title}`);
+  return 0;
+}
+var showUsage = `ft milestone <title|id>
+ft milestone new <title> [-d <text>] [--due <YYYY-MM-DD>]
+ft milestone close <title|id> [--force]
+
+Shows a milestone with its open issues as \`ft board\` does: available, taken by a session running here, or claimed by one gone, each with its boxes left, at most 30 of each kind (--full for all).
+\`ft milestone new\` and \`ft milestone close\` have their own --help; a milestone titled new or close is named by its id.
+
+Exits 0 when it showed the milestone, 1 when it cannot be read, 2 on a usage error or an unknown milestone.`;
+var showOptions = {
+  ...limitOptions(LIST_LIMIT),
+  json: jsonOption("the milestone (id, title, state, description, open, closed, due) and its open issues as `ft board --json` lists them"),
+  ...repoOption
+};
+async function show(args) {
+  const parsed = parse(args, showUsage, showOptions);
+  const { values, positionals } = parsed;
+  const reference = positionals.join(" ").trim();
+  if (reference === "")
+    fail(`name the milestone, or see them all with \`ft milestones\`
+
+${showUsage}`);
+  const found = await findMilestone(reference, values.repo);
+  const [issues, sessions] = await Promise.all([openIssues(undefined, values.repo, found.id), liveSessions()]);
+  const rows = await boardRows(issues, sessions, values.repo);
+  if (values.json === true) {
+    printJson({ id: found.id, title: found.title, state: found.state, description: found.description, open: found.open_issues, closed: found.closed_issues, due: dueDate(found) || null, issues: boardJson(rows) });
+    return 0;
+  }
+  const facts = [found.state, counts(found), progress(found), dueDate(found) === "" ? "" : `due ${dueDate(found)}`].filter((fact) => fact !== "");
+  console.log(`milestone ${found.title} (${facts.join(", ")})`);
+  if (found.description.trim() !== "")
+    console.log(found.description.trim());
+  console.log(`
+${renderBoard(rows, Date.now(), limitOf(values, LIST_LIMIT))}`);
+  return 0;
+}
+async function milestone(args) {
+  const [first, ...rest] = args;
+  if (first === "new")
+    return create(rest);
+  return first === "close" ? closeOne(rest) : show(args);
+}
+
 // src/plan.ts
 var MARKUP = /^[#*_\s]+|[*_\s]+$/g;
 function heading(line) {
@@ -1969,13 +2985,17 @@ var addUsage = `ft plan add <plan> <n>... [--section "Bugs:"]
 
 Lists each issue <n> as \`- [ ] #<n> <title>\` in the checklist of issue <plan>, skipping those already listed.
 Lines go under --section, created at the end of the body when missing, or else after the checklist's last box.
-The body is read again just before it is written, so an edit made meanwhile is kept.`;
+The body is read again just before it is written, so an edit made meanwhile is kept.
+
+Exits 0 when it listed the issues, 1 when Forgejo refuses, 2 on a usage error.`;
 var carryUsage = `ft plan carry <from> <to> [--section "Carried from 1.71.0:"]
 
 Copies the unticked \`#<n>\` lines of issue <from> into issue <to>, skipping those <to> already lists.
 Lines go under --section, created at the end of the body when missing, or else after the checklist's last box.
-The body is read again just before it is written, so an edit made meanwhile is kept.`;
-var options3 = {
+The body is read again just before it is written, so an edit made meanwhile is kept.
+
+Exits 0 when it copied the lines, 1 when Forgejo refuses, 2 on a usage error.`;
+var options4 = {
   section: { type: "string", short: "s", description: 'the heading the lines go under, e.g. "Bugs:"' },
   ...repoOption
 };
@@ -1987,7 +3007,7 @@ var plan = {
   }
 };
 async function add(args) {
-  const parsed = parse(args, addUsage, options3);
+  const parsed = parse(args, addUsage, options4);
   const { section, repo } = parsed.values;
   const [target, ...listed] = parsed.positionals;
   const planNumber = issueNumber(target, addUsage);
@@ -2008,7 +3028,7 @@ ${addUsage}`);
   return 0;
 }
 async function carry(args) {
-  const parsed = parse(args, carryUsage, options3);
+  const parsed = parse(args, carryUsage, options4);
   const { section, repo } = parsed.values;
   const from = issueNumber(parsed.positionals[0], carryUsage);
   const to = issueNumber(parsed.positionals[1], carryUsage);
@@ -2029,15 +3049,16 @@ function report(plan, added, skipped) {
 }
 
 // src/commands/release.ts
-import { basename as basename2, join as join2, resolve } from "path";
-var {$: $3 } = globalThis.Bun;
+import { basename as basename2, join as join2, relative, resolve } from "path";
+import process14 from "process";
+var {$ } = globalThis.Bun;
 
 // src/commands/watch.ts
-var usage3 = `ft watch [--after <id>]
+var usage4 = `ft watch [--after <id>]
 
 Waits for runs to finish: those newer than run <id>, or else the ones in progress now.
 Exits 0 when every one passed or was skipped, 1 when one failed or was cancelled, 2 on a timeout or a stalled queue.`;
-var options4 = {
+var options5 = {
   after: { type: "string", short: "a", description: "watch the runs newer than this run id, as `ft runs --json` gives it" },
   timeout: { type: "string", short: "t", description: "how long before giving up (15m), a bare number in minutes" },
   ...repoOption
@@ -2048,21 +3069,18 @@ var STALLED2 = 3 * 60000;
 async function watchRuns(pick, timeout, repo, idle) {
   const started = Date.now();
   const reported = new Map;
+  const followed = new Set;
+  const failed = new Set;
   let moving = started;
-  for (;; ) {
-    await Bun.sleep(timing.poll);
-    if (Date.now() - started > timeout)
-      fail(`the runs did not finish in ${formatDuration(timeout)}`);
-    let runs;
-    try {
-      runs = pick(await recentRuns(LIMIT, repo));
-    } catch (error) {
-      console.warn(`ft watch: ${error instanceof Error ? error.message : String(error)}, polling again`);
-      continue;
-    }
+  async function poll() {
+    const newest = await recentRuns(LIMIT, repo);
+    const gone = await Promise.all([...followed].filter((id) => !newest.some((run) => run.id === id)).map(async (id) => runById(id, repo)));
+    const runs = [...pick(newest), ...gone];
+    for (const run of runs)
+      followed.add(run.id);
     for (const run of runs) {
       if (reported.get(run.id) !== run.status)
-        console.log(`${run.workflow_id} run ${run.id} on ${run.prettyref}: ${run.status}`);
+        console.log(`${run.workflow_id} run ${run.id} on ${run.prettyref}: ${badge(run.status, process.stdout)}`);
       reported.set(run.id, run.status);
     }
     if (runs.length === 0) {
@@ -2070,30 +3088,48 @@ async function watchRuns(pick, timeout, repo, idle) {
         console.log("no run started, so nothing was waited for");
         return 0;
       }
-      continue;
+      return;
     }
-    const status = overall(runs);
-    if (status === "failure" || status === "cancelled") {
-      for (const run of runs) {
-        if (run.status === "failure")
-          console.error(`
+    for (const run of runs) {
+      if (run.status === "failure" && !failed.has(run.id)) {
+        console.error(`
 ${await failureReport(run, repo)}
 
 ${run.html_url}`);
+        failed.add(run.id);
       }
-      return 1;
     }
-    if (runs.every((run) => FINISHED.has(run.status)))
-      return 0;
+    if (runs.every((run) => FINISHED.has(run.status))) {
+      const status = overall(runs);
+      return status === "failure" || status === "cancelled" ? 1 : 0;
+    }
     const stall = await stallReason(runs, repo);
     if (stall === undefined)
       moving = Date.now();
     else if (stall.certain || Date.now() - moving > STALLED2)
       fail(`queued runs are not moving: ${stall.reason}`);
+    return;
+  }
+  for (;; ) {
+    await Bun.sleep(timing.poll);
+    if (Date.now() - started > timeout)
+      fail(`the runs did not finish in ${formatDuration(timeout)}`);
+    try {
+      const code = await poll();
+      if (code !== undefined)
+        return code;
+    } catch (error) {
+      if (error instanceof Exit)
+        throw error;
+      const message = error instanceof Error ? error.message : String(error);
+      if (isPermanentFailure(error))
+        fail(message);
+      console.warn(`ft watch: ${message}, polling again`);
+    }
   }
 }
 async function watch(args) {
-  const parsed = parse(args, usage3, options4);
+  const parsed = parse(args, usage4, options5);
   const { values } = parsed;
   const timeout = duration(values.timeout, "timeout", 15 * 60000, "m");
   if (values.after !== undefined) {
@@ -2109,28 +3145,62 @@ async function watch(args) {
 }
 
 // src/commands/release.ts
-var usage4 = `ft release <patch|minor|major|x.y.z>
+var usage5 = `ft release <patch|minor|major|x.y.z>
 ft release --tagged
 
 Cuts a release from the default branch: first the commit it sits on is pushed and its runs waited for, so failing tests stop it before anything is bumped or tagged. Then \`bun pm version\` commits and tags the bump, one atomic push sends the branch and its tag, and it waits for the runs the push started and for the registry to serve the version.
 --tagged releases a version commit already tagged at HEAD instead, for repos bumping with their own script; the runs waited for first are then those of the commit below it.
 --package releases one workspace package of a monorepo on its own, tagged \`<folder>-v<version>\` (\`ft release patch -p ft\` tags packages/ft as ft-v0.3.0).
-A refused push drops the bump commit and its tag, so a retry starts clean.`;
-var options5 = {
+A refused or interrupted push drops the bump commit and its tag, so a retry starts clean; with --tagged the commit and tag are yours and stay.
+Once released, an open milestone titled like the version (\`1.2.0\`, \`v1.2.0\` or the tag) has its closed issues listed and is closed; a failure there only warns.
+--dry-run checks the same and prints the plan: the version bump, the tag, the pushes and the runs and registry it would wait for, changing nothing.
+Exits 0 once released or planned, 1 when a run fails, origin refuses a push or the registry never serves the version, 2 on a timeout, a stalled queue, a refusal before anything ran (another branch, uncommitted changes, origin ahead) or a usage error.`;
+var options6 = {
   tagged: { type: "boolean", description: "push the version commit and tag already at HEAD instead of bumping" },
   package: { type: "string", short: "p", description: "workspace folder to release, a path or a name under packages/" },
   "no-registry": { type: "boolean", description: "do not wait for the registry to serve the new version" },
+  "dry-run": { type: "boolean", description: "print what the release would do, changing nothing" },
   timeout: { type: "string", short: "t", description: "how long to wait for the runs (15m), a bare number in minutes" }
 };
 var LEVELS = new Set(["patch", "minor", "major", "prepatch", "preminor", "premajor", "prerelease"]);
 var VERSION = /^\d+\.\d+\.\d+(?:-[\w.]+)?$/;
+var PARTS = /^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/;
+var LAST_NUMBER = /\d+$/;
 var REGISTRY_TRIES = 12;
 var REGISTRY_POLL = 5000;
+var limits = { pushMs: 5 * 60000 };
+var REGISTRY_INFO_MS = 30000;
 var NO_RUN2 = 3 * 60000;
 function taggedVersion(tag, prefix) {
   const version = tag.slice(prefix.length);
   return tag.startsWith(prefix) && VERSION.test(version) ? version : undefined;
 }
+function nextVersion(current, level) {
+  if (VERSION.test(level))
+    return level;
+  const [, major = "0", minor = "0", patch = "0", pre] = PARTS.exec(current) ?? [];
+  const [x, y, z] = [Number(major), Number(minor), Number(patch)];
+  switch (level) {
+    case "major":
+      return pre !== undefined && y === 0 && z === 0 ? `${x}.0.0` : `${x + 1}.0.0`;
+    case "minor":
+      return pre !== undefined && z === 0 ? `${x}.${y}.0` : `${x}.${y + 1}.0`;
+    case "patch":
+      return pre === undefined ? `${x}.${y}.${z + 1}` : `${x}.${y}.${z}`;
+    case "premajor":
+      return `${x + 1}.0.0-0`;
+    case "preminor":
+      return `${x}.${y + 1}.0-0`;
+    case "prepatch":
+      return `${x}.${y}.${z + 1}-0`;
+    default: {
+      if (pre === undefined)
+        return `${x}.${y}.${z + 1}-0`;
+      const numbered = LAST_NUMBER.exec(pre);
+      return `${x}.${y}.${z}-${numbered === null ? `${pre}.0` : `${pre.slice(0, numbered.index)}${Number(numbered[0]) + 1}`}`;
+    }
+  }
+}
 async function packageDir(value) {
   for (const dir of [resolve(value), join2(await git(["rev-parse", "--show-toplevel"]), "packages", value)]) {
     if (await Bun.file(join2(dir, "package.json")).exists())
@@ -2142,7 +3212,7 @@ async function commitPackageBump(dir, prefix) {
   const { version } = await Bun.file(join2(dir, "package.json")).json();
   const root = await git(["rev-parse", "--show-toplevel"]);
   const tag = `${prefix}${version}`;
-  const lock = await $3`bun install --lockfile-only`.cwd(root).quiet().nothrow();
+  const lock = await $`bun install --lockfile-only`.cwd(root).quiet().nothrow();
   if (lock.exitCode !== 0)
     fail(`bun install --lockfile-only after the bump: ${lock.stderr.toString().trim()}`);
   await git(["add", join2(dir, "package.json"), join2(root, "bun.lock")]);
@@ -2151,8 +3221,14 @@ async function commitPackageBump(dir, prefix) {
 }
 async function waitForRegistry(name, version) {
   for (let attempt = 0;attempt < REGISTRY_TRIES; attempt++) {
-    const served = (await $3`bun info ${name} version --no-cache`.quiet().nothrow().text()).trim().split(`
+    let served;
+    try {
+      served = (await runTool("bun info", ["bun", "info", name, "version", "--no-cache"], { timeoutMs: REGISTRY_INFO_MS })).stdout.trim().split(`
 `).at(-1);
+    } catch (error) {
+      if (isPermanentFailure(error))
+        throw error;
+    }
     if (served === version)
       return true;
     await Bun.sleep(REGISTRY_POLL);
@@ -2161,23 +3237,77 @@ async function waitForRegistry(name, version) {
 }
 async function testsPass(sha, branch, timeout) {
   if (!await gitOk(["merge-base", "--is-ancestor", sha, `origin/${branch}`])) {
-    const push = await $3`git push origin ${`${sha}:refs/heads/${branch}`}`.quiet().nothrow();
-    if (push.exitCode !== 0)
+    const held = holdSignals();
+    let push;
+    try {
+      push = await runTool("git push", ["git", "push", "origin", `${sha}:refs/heads/${branch}`], { timeoutMs: limits.pushMs, onStart: (child) => held.forward(child) });
+    } finally {
+      held.release();
+    }
+    if (held.signal !== undefined)
+      fail(`interrupted by ${held.signal} while pushing ${sha.slice(0, 7)}, so nothing was bumped`, exitCodeOf(null, held.signal));
+    if (push.code !== 0)
       fail(`origin refused the push of ${sha.slice(0, 7)}, so nothing was bumped:
-${push.stderr.toString().trim()}`, 1);
+${push.stderr.trim()}`, 1);
     console.log(`pushed ${branch} at ${sha.slice(0, 7)}, waiting for its runs before the bump`);
   }
   return await watchRuns((runs) => newestPerWorkflow(runs.filter((run) => run.commit_sha === sha)), timeout, undefined, NO_RUN2) === 0;
 }
+async function printPlan({ level, dir, prefix, branch, base, timeout, registry }) {
+  const file = Bun.file(join2(dir ?? ".", "package.json"));
+  const pkg = await file.exists() ? await file.json() : undefined;
+  const name = pkg?.name ?? basename2(dir ?? process14.cwd());
+  const where = dir === undefined ? "" : ` in ${relative(process14.cwd(), dir) || "."}`;
+  const sha = base.slice(0, 7);
+  let version;
+  let bump;
+  if (level === undefined) {
+    const tag = (await tagsAt("HEAD")).find((each) => taggedVersion(each, prefix) !== undefined);
+    if (tag === undefined)
+      fail(`HEAD carries no ${prefix}* tag`);
+    version = tag.slice(prefix.length);
+    bump = `take the version commit at HEAD, tagged ${tag}`;
+    console.log(`would release ${name} ${version}, tagged ${tag}`);
+  } else {
+    if (pkg?.version === undefined)
+      fail(`no version in ${join2(dir ?? ".", "package.json")}`);
+    version = nextVersion(pkg.version, level);
+    bump = dir === undefined ? `bun pm version ${level}, which commits and tags ${prefix}${version}` : `bun pm version ${level} --no-git-tag-version${where}, then commit it with bun.lock refreshed and tag ${prefix}${version}`;
+    console.log(`would release ${name} ${pkg.version} -> ${version}, tagged ${prefix}${version}`);
+  }
+  const pushed = await gitOk(["merge-base", "--is-ancestor", base, `origin/${branch}`]);
+  const registryStep = registry && pkg?.name !== undefined && pkg.private !== true ? `wait for the registry to serve ${pkg.name}@${version}` : `skip the registry: ${registry ? "the package is private or unnamed" : "--no-registry"}`;
+  const steps = [
+    pushed ? `wait for the runs on ${sha}, already on origin/${branch}` : `push ${branch} at ${sha}, which origin lacks, then wait for its runs`,
+    bump,
+    `push ${branch} and ${prefix}${version} in one atomic push, then wait for the runs it starts (${formatDuration(timeout)} at most)`,
+    registryStep
+  ];
+  console.log(steps.map((step, i) => `  ${i + 1}. ${step}`).join(`
+`));
+  console.log("dry run: nothing was pushed, committed or tagged");
+  return 0;
+}
+async function rollBack(preBump, tagsBefore) {
+  try {
+    for (const name of await tagsAt("HEAD")) {
+      if (!tagsBefore.has(name))
+        await git(["tag", "-d", name]);
+    }
+    await git(["reset", "--keep", preBump]);
+  } catch (error) {
+    warn(`could not undo the bump, back to ${preBump.slice(0, 7)} by hand`, error instanceof Error ? error.message : String(error));
+  }
+}
 async function release(args) {
-  const parsed = parse(args, usage4, options5);
+  const parsed = parse(args, usage5, options6);
   const { values, positionals } = parsed;
   const level = positionals[0];
   const tagged = values.tagged === true;
   if (tagged === (level !== undefined))
     fail(`give a level or --tagged
 
-${usage4}`);
+${usage5}`);
   if (level !== undefined && !LEVELS.has(level) && !VERSION.test(level))
     fail(`${level} is no level nor x.y.z version`);
   const timeout = duration(values.timeout, "timeout", 15 * 60000, "m");
@@ -2186,35 +3316,64 @@ ${usage4}`);
   const branch = await defaultBranch();
   const current = await git(["branch", "--show-current"]);
   if (current !== branch)
-    fail(`a release is cut from ${branch}, not ${current || "a detached HEAD"}`);
+    fail(`a release is cut from ${branch}, not ${current || "a detached HEAD"}`, 2, runHint(`git switch ${branch}`));
   if (await git(["status", "--porcelain"]) !== "")
-    fail("the tree has uncommitted changes: commit or stash them first");
-  await git(["fetch", "-q", "origin", branch]);
-  if ((await $3`git merge-base --is-ancestor ${`origin/${branch}`} HEAD`.quiet().nothrow()).exitCode !== 0)
-    fail(`origin/${branch} has commits HEAD lacks: pull first`);
+    fail("the tree has uncommitted changes", 2, runHint("gst", "see them, then commit them with gc"));
+  await fetchBranch(branch);
+  if ((await $`git merge-base --is-ancestor ${`origin/${branch}`} HEAD`.quiet().nothrow()).exitCode !== 0)
+    fail(`origin/${branch} has commits HEAD lacks`, 2, runHint(`git pull --rebase origin ${branch}`));
   const base = await git(["rev-parse", tagged ? "HEAD~1" : "HEAD"]);
+  if (values["dry-run"] === true)
+    return printPlan({ level, dir, prefix, branch, base, timeout, registry: values["no-registry"] !== true });
   if (!await testsPass(base, branch, timeout))
-    fail(`the runs on ${base.slice(0, 7)} failed, so nothing was bumped or tagged: fix them and release again`, 1);
-  if (level !== undefined) {
-    const bump = dir === undefined ? await $3`bun pm version ${level}`.quiet().nothrow() : await $3`bun pm version ${level} --no-git-tag-version`.cwd(dir).quiet().nothrow();
-    if (bump.exitCode !== 0)
-      fail(`bun pm version ${level}: ${bump.stderr.toString().trim() || bump.stdout.toString().trim()}`);
-    if (dir !== undefined)
-      await commitPackageBump(dir, prefix);
-  }
-  const tag = (await tagsAt("HEAD")).find((name) => taggedVersion(name, prefix) !== undefined);
-  if (tag === undefined)
-    fail(tagged ? `HEAD carries no ${prefix}* tag` : `the bump made no ${prefix}* tag`);
+    fail(`the runs on ${base.slice(0, 7)} failed, so nothing was bumped or tagged`, 1, runHint(`ft runs --sha ${base.slice(0, 7)}`, "list the runs, then ft logs <id> reads the failure"));
+  const preBump = await git(["rev-parse", "HEAD"]);
+  const tagsBefore = new Set(await tagsAt("HEAD"));
   const before = (await recentRuns(1))[0]?.id ?? 0;
-  const push = await $3`git push --atomic origin ${`HEAD:refs/heads/${branch}`} ${tag}`.quiet().nothrow();
-  if (push.exitCode !== 0) {
-    await git(["tag", "-d", tag]);
-    await git(["reset", "--keep", "HEAD~1"]);
-    fail(`origin refused the push, so ${tag} and its commit were dropped for a clean retry:
-${push.stderr.toString().trim()}`, 1);
+  const held = holdSignals();
+  const signalOf = () => held.signal;
+  let tag = "";
+  let head = "";
+  let pushed = false;
+  let isPushUnknown = false;
+  try {
+    if (level !== undefined) {
+      const bump = dir === undefined ? await $`bun pm version ${level}`.quiet().nothrow() : await $`bun pm version ${level} --no-git-tag-version`.cwd(dir).quiet().nothrow();
+      if (bump.exitCode !== 0)
+        fail(`bun pm version ${level}: ${bump.stderr.toString().trim() || bump.stdout.toString().trim()}`);
+      if (dir !== undefined)
+        await commitPackageBump(dir, prefix);
+    }
+    const found = (await tagsAt("HEAD")).find((name) => taggedVersion(name, prefix) !== undefined);
+    if (found === undefined)
+      fail(tagged ? `HEAD carries no ${prefix}* tag` : `the bump made no ${prefix}* tag`);
+    tag = found;
+    head = await git(["rev-parse", "HEAD"]);
+    if (held.signal !== undefined)
+      fail(`interrupted by ${held.signal} before the push`, exitCodeOf(null, held.signal));
+    let push;
+    try {
+      push = await runTool("git push", ["git", "push", "--atomic", "origin", `HEAD:refs/heads/${branch}`, tag], { timeoutMs: limits.pushMs, onStart: (child) => held.forward(child) });
+    } catch (error) {
+      isPushUnknown = true;
+      fail(`${error instanceof Error ? error.message : String(error)}, so ${tag} and its commit are kept: the push may have landed`, 2, `git ls-remote origin refs/tags/${tag} tells; if it is there, ft release --tagged waits for its runs`);
+    }
+    if (push.code !== 0) {
+      const signal = signalOf();
+      fail(`origin refused the push${signal === undefined ? "" : `, or ${signal} interrupted it`}, so ${level === undefined ? `${tag} and its commit are kept for a retry` : `${tag} and its commit were dropped for a clean retry`}:
+${push.stderr.trim()}`, signal === undefined ? 1 : exitCodeOf(null, signal));
+    }
+    pushed = true;
+  } finally {
+    held.release();
+    if (!pushed && !isPushUnknown && level !== undefined)
+      await rollBack(preBump, tagsBefore);
   }
+  const late = signalOf();
+  if (late !== undefined)
+    fail(`interrupted by ${late} after ${tag} was pushed: its runs are not waited for`, exitCodeOf(null, late));
   console.log(`pushed ${branch} and ${tag}, waiting for their runs`);
-  const code = await watchRuns((runs) => runs.filter((run) => run.id > before), timeout);
+  const code = await watchRuns((runs) => runs.filter((run) => run.id > before && run.commit_sha === head), timeout, undefined, NO_RUN2);
   if (code !== 0)
     return code;
   const file = Bun.file(join2(dir ?? ".", "package.json"));
@@ -2222,29 +3381,93 @@ ${push.stderr.toString().trim()}`, 1);
   const version = tag.slice(prefix.length);
   if (values["no-registry"] === true || pkg?.name === undefined || pkg.private === true) {
     console.log(`released ${tag}`);
+    await settleMilestone(version, tag);
     return 0;
   }
   if (!await waitForRegistry(pkg.name, version))
     fail(`the runs passed but the registry does not serve ${pkg.name}@${version}: read the publish job with \`ft logs\``, 1);
   console.log(`released ${pkg.name}@${version}`);
+  await settleMilestone(version, tag);
   return 0;
 }
+async function settleMilestone(version, tag) {
+  try {
+    const names = new Set([version, `v${version}`, tag]);
+    const found = (await listMilestones("open")).find((each) => names.has(each.title));
+    if (found === undefined)
+      return;
+    const [done, left] = await Promise.all([closedIssues(found.id), openIssues(undefined, undefined, found.id)]);
+    console.log(`milestone ${found.title}: ${done.length} closed issue${done.length === 1 ? "" : "s"}${done.length === 0 ? "" : `
+${done.map((issue) => `  #${issue.number} ${issue.title}`).join(`
+`)}`}`);
+    if (left.length > 0)
+      warn(`${left.length} issue${left.length === 1 ? " is" : "s are"} still open in it`, left.map((issue) => `#${issue.number}`).join(" "));
+    await closeMilestone(found.id);
+    console.log(`closed milestone ${found.title}`);
+  } catch (error) {
+    warn(`released, but the milestone ${version} could not be settled`, error instanceof Error ? error.message : String(error));
+  }
+}
 
 // src/commands/remote.ts
 import { lookup } from "dns/promises";
-var {$: $4 } = globalThis.Bun;
+import { homedir as homedir3 } from "os";
+var {$: $2 } = globalThis.Bun;
+
+// src/config.ts
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+function settingsPath(home = homedir2()) {
+  return join3(home, ".config", "ft", "config.json");
+}
+async function loadSettings(home = homedir2()) {
+  const path = settingsPath(home);
+  const file = Bun.file(path);
+  if (!await file.exists())
+    return {};
+  let raw;
+  try {
+    raw = await file.json();
+  } catch (error) {
+    warn(`${path} is not valid JSON, so its settings are ignored`, error instanceof Error ? error.message : String(error));
+    return {};
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    warn(`${path} is not a JSON object, so its settings are ignored`);
+    return {};
+  }
+  const host = "remoteHost" in raw ? raw.remoteHost : undefined;
+  if (host !== undefined && (typeof host !== "string" || host === ""))
+    warn(`remoteHost in ${path} must be a non-empty string, so it is ignored`);
+  return typeof host === "string" && host !== "" ? { remoteHost: host } : {};
+}
 
 // src/remote.ts
 var SCP_LIKE = /^(?:([^@/]+)@)?([^:/]+):(?!\/)(.+?)(?:\.git)?\/?$/;
-var SSH_URL = /^ssh:\/\/(?:([^@/]+)@)?([^:/]+)(?::\d+)?\/(.+?)(?:\.git)?\/?$/;
+var SSH_URL = /^ssh:\/\/(?:([^@/]+)@)?([^:/]+)(?::(\d+))?\/(.+?)(?:\.git)?\/?$/;
+var USERINFO = /^([a-z][a-z\d+.-]*:\/\/)[^@/]*@/i;
+var DEFAULT_PORT = "22";
 function parseSshRemote(url) {
-  const match = SSH_URL.exec(url) ?? (url.includes("://") ? null : SCP_LIKE.exec(url));
-  return match === null ? undefined : { user: match[1] ?? "git", host: match[2] ?? "", path: match[3] ?? "" };
+  const ssh = SSH_URL.exec(url);
+  const scp = ssh === null && !url.includes("://") ? SCP_LIKE.exec(url) : null;
+  const match = ssh ?? scp;
+  if (match === null || match[2]?.startsWith("-") === true)
+    return;
+  const login = match[1] ?? "git";
+  const user = login.includes(":") ? login.slice(0, login.indexOf(":")) : login;
+  if (ssh === null)
+    return { user, host: match[2] ?? "", path: match[3] ?? "" };
+  return { user, host: match[2] ?? "", path: match[4] ?? "", ...ssh[3] === undefined ? {} : { port: ssh[3] } };
+}
+function redactUrl(url) {
+  return url.replace(USERINFO, "$1");
 }
 function canonicalRemote(url, host, reaches) {
   const remote = parseSshRemote(url);
   if (remote === undefined || remote.host === host || !reaches(remote.host))
     return;
+  if (remote.port !== undefined && remote.port !== DEFAULT_PORT)
+    return `ssh://${remote.user}@${host}:${remote.port}/${remote.path}.git`;
   return `${remote.user}@${host}:${remote.path}.git`;
 }
 async function reachesHost(hostname, host, hostAddresses, addressesOf) {
@@ -2254,17 +3477,20 @@ async function reachesHost(hostname, host, hostAddresses, addressesOf) {
 }
 
 // src/commands/remote.ts
-var usage5 = `ft remote [--fix]
+var usage6 = `ft remote [--fix]
 
 Checks that origin's URLs name the Forgejo host itself: tea only finds the repository when origin's host is the login's ssh_host, never through an ssh alias such as \`forgejo\` or \`gitea\`.
---fix switches every alias URL to \`git@<host>:<owner>/<repo>.git\` and proves it with \`git ls-remote\`.`;
-var options6 = {
-  host: { type: "string", description: "the Forgejo ssh host (git.kevyn.fr)" },
+--fix switches every alias URL to \`git@<host>:<owner>/<repo>.git\` and proves it with \`git ls-remote\`.
+The host comes from --host, else \`remoteHost\` in ~/.config/ft/config.json; with neither, it checks nothing.
+
+Exits 0 when origin names the Forgejo host (or was switched) or no host is set, 1 when it does not or a switch is still to run, 2 on a usage error.`;
+var options7 = {
+  host: { type: "string", description: "the Forgejo ssh host, instead of remoteHost in ~/.config/ft/config.json" },
   fix: { type: "boolean", description: "rewrite the alias URLs" }
 };
 var HOSTNAME = /^hostname (.+)$/m;
 async function sshHostname(alias) {
-  return HOSTNAME.exec(await $4`ssh -G ${alias}`.quiet().nothrow().text())?.[1];
+  return HOSTNAME.exec(await $2`ssh -G -- ${alias}`.quiet().nothrow().text())?.[1];
 }
 async function addresses(name) {
   try {
@@ -2273,15 +3499,26 @@ async function addresses(name) {
     return [];
   }
 }
+async function restoreOrigin(fetchUrl, pushUrls, changes) {
+  if (changes.some(([from]) => from === fetchUrl))
+    await git(["remote", "set-url", "origin", fetchUrl]);
+  for (const [from, to] of changes) {
+    if (pushUrls.includes(from))
+      await git(["remote", "set-url", "--push", "origin", from, to]);
+  }
+}
 function originHost(url) {
   return parseSshRemote(url)?.host ?? (URL.canParse(url) ? new URL(url).hostname : undefined);
 }
-async function remote(args) {
-  const parsed = parse(args, usage5, options6);
-  const { values } = parsed;
-  const host = values.host ?? "git.kevyn.fr";
+async function remote(args, home = homedir3()) {
+  const { values } = parse(args, usage6, options7);
+  const host = values.host ?? (await loadSettings(home)).remoteHost;
+  if (host === undefined) {
+    note(`no Forgejo host to check origin against: pass --host, or set "remoteHost" in ${settingsPath(home)}`);
+    return 0;
+  }
   const fetchUrl = await git(["remote", "get-url", "origin"]);
-  const pushUrls = (await $4`git config --get-all remote.origin.pushurl`.quiet().nothrow().text()).split(`
+  const pushUrls = (await $2`git config --get-all remote.origin.pushurl`.quiet().nothrow().text()).split(`
 `).filter(Boolean);
   const hostAddresses = new Set(await addresses(host));
   const hostnames = new Map;
@@ -2299,15 +3536,15 @@ async function remote(args) {
   if (changes.length === 0) {
     const named = originHost(fetchUrl);
     if (named === host) {
-      console.log(`origin already names ${host}: ${fetchUrl}`);
+      console.log(`origin already names ${host}: ${redactUrl(fetchUrl)}`);
       return 0;
     }
     const hostname = named === undefined ? undefined : hostnames.get(named);
-    console.log(`origin ${fetchUrl} does not reach ${host}${hostname === undefined || hostname === named ? "" : `: ssh connects ${named} to ${hostname}`}, pass --host if Forgejo lives elsewhere`);
+    console.log(`origin ${redactUrl(fetchUrl)} does not reach ${host}${hostname === undefined || hostname === named ? "" : `: ssh connects ${named} to ${hostname}`}, pass --host if Forgejo lives elsewhere`);
     return 1;
   }
   for (const [from, to] of changes)
-    console.log(`${from} -> ${to}`);
+    console.log(`${redactUrl(from)} -> ${redactUrl(to)}`);
   if (values.fix !== true) {
     console.log("run `ft remote --fix` to switch them");
     return 1;
@@ -2319,29 +3556,44 @@ async function remote(args) {
     if (pushUrls.includes(from))
       await git(["remote", "set-url", "--push", "origin", to, from]);
   }
-  await git(["ls-remote", "origin", "HEAD"]);
+  try {
+    await git(["ls-remote", "origin", "HEAD"]);
+  } catch (error) {
+    await restoreOrigin(fetchUrl, pushUrls, changes);
+    return fail(`the switched origin does not answer, so the old URLs were put back: ${redactUrl(error instanceof Error ? error.message : String(error))}`, 1);
+  }
   console.log("origin switched, and git ls-remote reaches it");
   return 0;
 }
 
 // src/commands/runs.ts
-var usage6 = `ft runs [--sha <ref>]
+var usage7 = `ft runs [--sha <ref>]
 
-Lists recent runs with what tea's own listing leaves empty: workflow, ref, duration and age.`;
-var options7 = {
-  limit: { type: "string", short: "n", description: "how many runs (10)" },
+Lists recent runs with what tea's own listing leaves empty: workflow, ref, duration and age, ten by default with the count of the rest (--full for all of them; --json is never cut unless --limit is given).
+
+Exits 0 when it listed them, 1 when Forgejo or git cannot be read, 2 on a usage error.`;
+var DEFAULT_LIMIT = 10;
+var options8 = {
+  limit: { ...limitOptions(DEFAULT_LIMIT).limit, short: "n" },
+  full: limitOptions(DEFAULT_LIMIT).full,
   sha: { type: "string", short: "s", description: "only the runs of this commit" },
   workflow: { type: "string", short: "w", description: "only this workflow file, e.g. test.yml" },
   json: jsonOption(),
   ...repoOption
 };
-var TITLE_WIDTH2 = 70;
+var TITLE_WIDTH4 = 70;
+async function onCommit(sha, repo) {
+  const found = await runsOn(await resolveCommit(sha), repo);
+  return { runs: found, total: found.length };
+}
 async function runs(args) {
-  const parsed = parse(args, usage6, options7);
+  const parsed = parse(args, usage7, options8);
   const { values } = parsed;
-  const limit = wholeNumber(values.limit, "limit", 10);
-  const found = values.sha === undefined ? await recentRuns(limit, values.repo, values.workflow) : await runsOn(await resolveCommit(values.sha), values.repo);
-  const list = found.filter((run) => values.workflow === undefined || run.workflow_id === values.workflow).slice(0, limit);
+  const limit = limitOf(values, DEFAULT_LIMIT);
+  const { runs: found, total } = values.sha === undefined ? await runsListing(limit, values.repo, values.workflow) : await onCommit(values.sha, values.repo);
+  const matching = found.filter((run) => values.workflow === undefined || run.workflow_id === values.workflow);
+  const list = matching.slice(0, limit);
+  const more = values.sha === undefined ? total - list.length : matching.length - list.length;
   if (values.json === true) {
     printJson(list.map((run) => ({ id: run.id, number: run.index_in_repo, status: run.status, workflow: run.workflow_id, ref: run.prettyref, event: run.event, sha: run.commit_sha, seconds: runSeconds(run), started: run.started, title: run.title, url: run.html_url })));
     return 0;
@@ -2352,24 +3604,29 @@ async function runs(args) {
   }
   console.log(table([
     ["ID", "STATUS", "WORKFLOW", "REF", "EVENT", "TOOK", "STARTED", "TITLE"],
-    ...list.map((run) => [String(run.id), run.status, run.workflow_id, run.prettyref, run.event, run.duration > 0 ? formatSeconds(runSeconds(run)) : "-", startedAge(run), truncate(upTo(run.title, `
-`), TITLE_WIDTH2)])
-  ]));
+    ...list.map((run) => [String(run.id), badge(run.status, process.stdout), run.workflow_id, run.prettyref, run.event, run.duration > 0 ? formatSeconds(runSeconds(run)) : "-", startedAge(run), truncate(upTo(run.title, `
+`), TITLE_WIDTH4)])
+  ], { header: true }));
+  if (more > 0)
+    console.log(moreFooter(more));
   return 0;
 }
 
 // src/cli.ts
-process8.exitCode = await runCli({
+process15.exitCode = await runCli({
   name: "ft",
   version,
   about: "Forgejo tools over tea, run from a repository whose origin is on Forgejo",
+  replaces: "tea api calls piped through jq, and sleep loops waiting on CI",
+  examples: [["ft ci", "wait for the runs of origin's tip, failures printed"], ["ft issue 12 -c", "an issue with its boxes numbered and its comments"]],
   commands: {
     runs: { run: runs, summary: "recent runs with workflow, ref, duration and age" },
-    ci: { run: ci, summary: "wait for the runs covering a commit, printing what failed" },
+    ci: { run: ci2, summary: "wait for the runs covering a commit, printing what failed" },
     watch: { run: watch, summary: "wait for runs newer than an id, or those in progress" },
-    logs: { run: logs, summary: "what the failed jobs of a run say went wrong" },
+    logs: { run: logs2, summary: "what the failed jobs of a run say went wrong" },
     release: { run: release, summary: "bump, push branch and tag atomically, wait for runs and registry" },
     board: { run: board, summary: "open issues: available, taken by a live session, or claimed by one gone" },
+    digest: { run: digest, summary: "repo state for a cold start: held and abandoned claims, red CI, unpushed commits, dirty files, stale TODOs" },
     take: { run: take, summary: "claim an issue for this Claude Code session" },
     drop: { run: drop, summary: "give back an issue this session took" },
     issue: { run: issue, summary: "an issue's claim, description and numbered boxes, -c comments" },
@@ -2382,6 +3639,8 @@ process8.exitCode = await runCli({
     reopen: { run: reopenIssues, summary: "reopen closed issues, -m posting the reason" },
     label: { run: label, summary: "add +name and remove -name labels of an issue" },
     plan,
+    milestones: { run: milestones, summary: "milestones with their open and closed issues, progress and due date" },
+    milestone: { run: milestone, summary: "show a milestone's issues like the board, `new` creates one, `close` closes it" },
     remote: { run: remote, summary: "check or fix an origin using an ssh alias tea cannot match" }
   },
   aliases: { show: "issue", view: "issue" }