@kaynooo/forgejo-tools 0.5.1 → 0.6.0

package/dist/cli.js

@@ -2,17 +2,17 @@
 // @bun
 
 // src/cli.ts
-import process8 from "process";
+import process14 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)));
@@ -409,14 +437,40 @@ 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 = /\.$/;
+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>")}` : "";
@@ -425,8 +479,27 @@ function optionRows(options, colors = paint(process3.stdout)) {
   const width = Math.max(0, ...rows.map((row) => row.width));
   return rows.map((row) => `  ${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 +507,14 @@ 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));
   }
-  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,6 +529,25 @@ 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)}`;
@@ -479,7 +573,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();
   }
@@ -489,7 +583,7 @@ async function readInput(path, { noStdin = "nothing is piped on stdin" } = {}) {
   return file.text();
 }
 // ../kit/src/cli.ts
-import process4 from "process";
+import process5 from "process";
 
 // ../kit/src/text.ts
 var ANSI = new RegExp(`${String.fromCharCode(27)}\\[[\\d;?]*[a-z]`, "gi");
@@ -505,6 +599,37 @@ function distance(a, b) {
 }
 
 // ../kit/src/cli.ts
+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" } };
+function commandRows(commands, colors) {
+  const width = Math.max(...Object.keys(commands).map((name) => name.length));
+  const groups = new Map([["Commands:", []]]);
+  for (const [name, { summary, group }] of Object.entries(commands)) {
+    const heading = group === undefined ? "Commands:" : `${group}:`;
+    const rows = groups.get(heading) ?? [];
+    rows.push(`  ${colors.cyan(name.padEnd(width))}  ${colors.dim(summary)}`);
+    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);
+}
 function closest(name, names) {
   const started = names.find((known) => known.startsWith(name));
   if (started !== undefined)
@@ -512,51 +637,78 @@ function closest(name, names) {
   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;
 }
-async function help({ path, header, commands, defaultCommand }, stream) {
+async function help({ path, header, summary, commands, defaultCommand, examples, replaces }, stream) {
   const colors = paint(stream);
-  const width = Math.max(...Object.keys(commands).map((name) => name.length));
   const prefix = path.join(" ");
+  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),
     "",
     usageLine(`${prefix} ${defaultCommand === undefined ? colors.cyan("<command>") : `[${colors.cyan("<command>")}]`} [options]`, colors),
+    ...replacesRows(replaces, 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)],
+    ...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("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(process5.stderr);
+  const styled = takesControlCodes(process5.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(process5.stderr);
+  console.error(`  ${takesControlCodes(process5.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(level, process5.stderr));
     return 2;
   }
   if (name === undefined || name === "help" || name === "--help" || name === "-h") {
-    console.log(await help(level, process4.stdout));
+    console.log(await help(level, process5.stdout));
     return 0;
   }
   if (level.path.length === 1 && (name === "--version" || name === "-v")) {
@@ -576,12 +728,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) => `${colors.bold(`${prefix} ${name}`)}  ${summary}`, summary, commands: command.commands, aliases: 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";
@@ -619,13 +771,88 @@ async function printCandidates(found) {
     console.log(line);
   return 0;
 }
-async function runCli(cli, argv = process4.argv.slice(2)) {
+async function runCli(cli, argv = process5.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 dispatch({ path: [cli.name], header: (colors) => `${colors.bold(cli.name)} ${colors.dim(cli.version)}  ${cli.about}`, summary: cli.about, commands: cli.commands, aliases: cli.aliases, defaultCommand: cli.defaultCommand, examples: cli.examples, replaces: cli.replaces }, argv, { version: cli.version, redact: cli.redact });
+}
+// ../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/process.ts
+import { constants } from "os";
+import process6 from "process";
+var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+async function collect(stream, name, chunks) {
+  for await (const data of stream)
+    chunks.push({ stream: name, data });
+}
+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)
+        process6.off(signal, onSignal);
+    }
+  };
+  function onSignal(signal) {
+    received = signal;
+    if (child !== undefined) {
+      child.kill(signal);
+      return;
+    }
+    if (cleanup === undefined)
+      return;
+    held.release();
+    cleanup(signal);
+    process6.kill(process6.pid, signal);
+  }
+  for (const signal of SIGNALS)
+    process6.on(signal, onSignal);
+  return held;
+}
+async function runCommand(argv, { cwd, env, stdin = "ignore" } = {}) {
+  const chunks = [];
+  const proc = Bun.spawn(argv, { ...cwd === undefined ? {} : { cwd }, ...env === undefined ? {} : { env }, stdin, stdout: "pipe", stderr: "pipe" });
+  await Promise.all([collect(proc.stdout, "stdout", chunks), collect(proc.stderr, "stderr", chunks)]);
+  await proc.exited;
+  const output = Buffer.concat(chunks.map(({ data }) => data));
+  return { code: exitCodeOf(proc.exitCode, proc.signalCode), chunks, output, text: output.toString() };
 }
 // package.json
-var version = "0.5.1";
+var version = "0.6.0";
 
 // src/args.ts
 var repoOption = {
@@ -776,7 +1003,7 @@ var {$: $2 } = globalThis.Bun;
 
 // src/git.ts
 import { basename, dirname } from "path";
-import process6 from "process";
+import process8 from "process";
 var {$ } = globalThis.Bun;
 var ORIGIN_PREFIX = /^origin\//;
 function spawnFailure(command, error) {
@@ -820,7 +1047,7 @@ async function commitsNaming(issue, ref) {
 }
 function cwdGone() {
   try {
-    process6.cwd();
+    process8.cwd();
     return false;
   } catch {
     return true;
@@ -829,7 +1056,7 @@ function cwdGone() {
 async function leaveWorktree() {
   const common = await git(["rev-parse", "--path-format=absolute", "--git-common-dir"]);
   if (basename(common) === ".git")
-    process6.chdir(dirname(common));
+    process8.chdir(dirname(common));
 }
 
 // src/tea.ts
@@ -865,6 +1092,19 @@ async function api(path, repo) {
 async function repoApi(path, repo) {
   return api(`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}`]);
+  let result;
+  try {
+    result = await $2`tea api ${repoFlag(repo)} -X ${method} ${flags} ${full}`.quiet().nothrow();
+  } catch (error) {
+    throw spawnFailure(`tea api ${full}`, error);
+  }
+  if (result.exitCode !== 0)
+    throw new Error(`tea api ${full}: ${result.stderr.toString().trim() || `exit ${result.exitCode}`}`);
+  return parseJson(full, result.stdout.toString());
+}
 async function repoApiText(path, repo) {
   return request(`repos/{owner}/{repo}/${path}`, repo);
 }
@@ -886,16 +1126,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);
 }
@@ -915,15 +1160,19 @@ async function editIssue(number, change, repo) {
     args.push("-t", change.title);
   if (change.body !== undefined)
     args.push("-d", change.body);
+  if (change.milestone !== undefined)
+    args.push("-m", change.milestone);
   await tea(args, repo);
 }
 async function setBody(number, body, repo) {
   await editIssue(number, { body }, repo);
 }
-async function createIssue(title, body, labels, repo) {
+async function createIssue(title, body, labels, milestone, repo) {
   const args = ["issues", "create", "-t", title, "-d", body];
   if (labels !== undefined)
     args.push("-L", labels);
+  if (milestone !== undefined)
+    args.push("-m", milestone);
   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)
@@ -965,18 +1214,66 @@ async function editLabels(number, add, remove, repo) {
   await tea(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 process9 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 (process9.env.CLAUDE_CONFIG_DIR !== undefined)
+    dirs.add(join(process9.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 +1319,7 @@ async function liveSessions() {
 }
 async function currentSession(sessions) {
   const byPid = new Map(sessions.map((session) => [session.pid, session]));
-  let pid = process7.ppid;
+  let pid = process9.ppid;
   for (let depth = 0;depth < 32 && pid > 1; depth++) {
     const session = byPid.get(pid);
     if (session !== undefined)
@@ -1061,18 +1358,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 +1379,45 @@ ${lines.join(`
 
 `);
 }
+async function boardRows(issues, sessions, repo) {
+  const comments = await commentsOfAll(issues, repo);
+  return issues.map((issue) => {
+    const own = comments.get(issue.number) ?? [];
+    return { issue, standing: standing(latestClaim(own), 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 +1425,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 +1434,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 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 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 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 +1456,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 +1486,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);
     }
   }
@@ -1187,7 +1503,7 @@ async function take(args) {
     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);
+      fail(`#${number} is closed`, 1, runHint(`ft reopen ${number}`, "reopen it"));
     const claim = latestClaim(comments);
     const current = standing(claim, sessions);
     if (claim?.holder === name) {
@@ -1197,14 +1513,16 @@ 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);
     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,
@@ -1225,6 +1543,117 @@ async function drop(args) {
   });
 }
 
+// src/commands/ci.ts
+import process11 from "process";
+
+// ../kit/src/progress.ts
+import process10 from "process";
+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 = process10.stderr, env = process10.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();
+    process10.off("exit", onExit);
+    signals.release();
+  }
+  timer.unref();
+  process10.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]), [process10.stdout, "write"], [process10.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);
+    }
+  };
+}
+
 // src/log.ts
 var BOUNDARY = /^(?:\((?:pass|fail|skip|todo)\) |::(?:end)?group::|\S+\.test\.[jt]sx?:$)/;
 var DURATION2 = / \[[\d.]+m?s\]$/;
@@ -1280,9 +1709,23 @@ 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 ?? [];
@@ -1411,7 +1854,7 @@ async function ci(args) {
   async function covering() {
     await git(["fetch", "-q", "origin", 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]) {
@@ -1426,44 +1869,53 @@ async function ci(args) {
   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;
+  const { dim } = paint(process11.stderr);
+  const region = liveRegion((spinner) => [
+    `${spinner} CI on ${short} ${dim(formatDuration(Date.now() - started))}`,
+    ...(runs ?? []).map((run) => `  ${badge(run.status, process11.stderr)} ${run.workflow_id} ${dim(`run ${run.id}`)}`)
+  ]);
+  try {
+    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;
       }
-      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 !== 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`);
       }
-      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);
     }
-    await Bun.sleep(POLL);
+  } finally {
+    region.stop();
   }
   const status = overall(runs);
   if (status !== "failure") {
@@ -1480,6 +1932,128 @@ run ${run.id} failed${run.commit_sha === sha ? "" : `, testing every commit from
   return 1;
 }
 
+// src/commands/digest.ts
+import process12 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: process12.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 rows = issues.map((issue) => ({ issue, claim: latestClaim(comments.get(issue.number) ?? []) }));
+  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 +2087,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 +2122,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 +2150,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" },
@@ -1670,15 +2252,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 +2278,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,11 +2309,14 @@ 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() };
+  const milestone = await milestoneTitle(values.milestone, values.repo);
+  if (milestone !== undefined)
+    change.milestone = milestone;
   if (text !== undefined && values.append !== true)
     change.body = text;
   else if (text !== undefined || added.length > 0)
@@ -1736,7 +2334,9 @@ ${text}`;
 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" },
@@ -1784,7 +2384,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 +2409,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,15 +2458,15 @@ 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);
     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);
@@ -1873,11 +2477,13 @@ ${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 = {
+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" },
   full: { type: "boolean", short: "f", description: "the whole log, timestamps stripped" },
   ...repoOption
@@ -1889,28 +2495,164 @@ function pickJobs(jobs, name) {
   return failed.length > 0 ? failed : jobs;
 }
 async function logs(args) {
-  const parsed = parse(args, usage2, options2);
+  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}`);
+    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 +2711,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 +2733,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 +2754,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 +2775,16 @@ function report(plan, added, skipped) {
 }
 
 // src/commands/release.ts
-import { basename as basename2, join as join2, resolve } from "path";
+import { basename as basename2, join as join2, relative, resolve } from "path";
+import process13 from "process";
 var {$: $3 } = 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
@@ -2062,7 +2809,7 @@ async function watchRuns(pick, timeout, repo, idle) {
     }
     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) {
@@ -2093,7 +2840,7 @@ ${run.html_url}`);
   }
 }
 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,21 +2856,27 @@ 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 push drops the bump commit and its tag, so a retry starts clean.
+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 NO_RUN2 = 3 * 60000;
@@ -2131,6 +2884,32 @@ 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())
@@ -2169,15 +2948,50 @@ ${push.stderr.toString().trim()}`, 1);
   }
   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 ?? process13.cwd());
+  const where = dir === undefined ? "" : ` in ${relative(process13.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 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,15 +3000,17 @@ ${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");
+    fail("the tree has uncommitted changes", 2, runHint("gst", "see them, then commit them with gc"));
   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(`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);
+    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"));
   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)
@@ -2222,18 +3038,59 @@ ${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";
+import { homedir as homedir3 } from "os";
 var {$: $4 } = 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 file = Bun.file(settingsPath(home));
+  if (!await file.exists())
+    return {};
+  let raw;
+  try {
+    raw = await file.json();
+  } catch {
+    return {};
+  }
+  const host = typeof raw === "object" && raw !== null && "remoteHost" in raw ? raw.remoteHost : undefined;
+  return typeof host === "string" && host !== "" ? { remoteHost: host } : {};
+}
+
 // src/remote.ts
 var SCP_LIKE = /^(?:([^@/]+)@)?([^:/]+):(?!\/)(.+?)(?:\.git)?\/?$/;
 var SSH_URL = /^ssh:\/\/(?:([^@/]+)@)?([^:/]+)(?::\d+)?\/(.+?)(?:\.git)?\/?$/;
@@ -2254,12 +3111,15 @@ 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;
@@ -2276,10 +3136,13 @@ async function addresses(name) {
 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(`
 `).filter(Boolean);
@@ -2325,23 +3188,33 @@ async function remote(args) {
 }
 
 // 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,17 +3225,21 @@ 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({
+process14.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" },
@@ -2370,6 +3247,7 @@ process8.exitCode = await runCli({
     logs: { run: logs, 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 +3260,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" }