@kaynooo/forgejo-tools 0.0.0-stage → 0.6.0

package/dist/cli.js

@@ -0,0 +1,3268 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli.ts
+import process14 from "process";
+
+// ../kit/src/args.ts
+import process4 from "process";
+import { parseArgs } from "util";
+
+// ../kit/src/format.ts
+import process3 from "process";
+
+// ../kit/src/style.ts
+import process2 from "process";
+
+// ../../node_modules/.bun/@kaynooo+utils@2.31.0+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-mtetydvc.js
+function x(s) {
+  let r = s.startsWith("#") ? s.slice(1).toLowerCase() : s.toLowerCase();
+  if (!/^[a-f0-9]+$/.test(r))
+    return [0, 0, 0];
+  let t = r.length, n = (c) => Number.parseInt(c, 16);
+  if (t === 3 || t === 4) {
+    let c = n(r[0] + r[0]), u = n(r[1] + r[1]), h = n(r[2] + r[2]), g = t === 4 ? n(r[3] + r[3]) : undefined;
+    return g !== undefined ? [c, u, h, g] : [c, u, h];
+  }
+  if (t !== 6 && t !== 8)
+    throw Error(`Invalid hex color length: ${t}`);
+  let a = n(r.slice(0, 2)), b = n(r.slice(2, 4)), o = n(r.slice(4, 6)), y = t === 8 ? n(r.slice(6, 8)) : undefined;
+  if ([a, b, o].some(Number.isNaN) || y !== undefined && Number.isNaN(y))
+    throw Error(`Invalid hex color value: ${s}`);
+  return y !== undefined ? [a, b, o, y] : [a, b, o];
+}
+function A(s) {
+  let [r, t, n, a] = s;
+  if (a)
+    return `#${(r << 24 | t << 16 | n << 8 | Math.round((a ?? 1) * 255)).toString(16).padStart(8, "0").toUpperCase()}`;
+  return `#${(r << 16 | t << 8 | n).toString(16).padStart(6, "0").toUpperCase()}`;
+}
+function R(s, r, t) {
+  s = (s % 360 + 360) % 360, t /= 100;
+  let n = r * Math.min(t, 1 - t) / 100, a = (b) => {
+    let o = (b + s / 30) % 12, y = t - n * Math.max(Math.min(o - 3, 9 - o, 1), -1);
+    return Math.round(255 * y);
+  };
+  return [a(0), a(8), a(4)];
+}
+function k(s) {
+  let [r, t, n] = s;
+  r /= 255, t /= 255, n /= 255;
+  let a = Math.max(r, t, n), b = Math.min(r, t, n), o = 0, y = 0, c = (a + b) / 2;
+  if (a !== b) {
+    let u = a - b;
+    if (y = c > 0 && c < 1 ? u / (1 - Math.abs(2 * c - 1)) : 0, a === r)
+      o = (t - n) / u + (t < n ? 6 : 0);
+    else if (a === t)
+      o = (n - r) / u + 2;
+    else
+      o = (r - t) / u + 4;
+    o /= 6;
+  }
+  return [Math.round(o * 360), Math.round(y * 100), Math.round(c * 100)];
+}
+function H(s, r, t) {
+  s = (s % 360 + 360) % 360, r /= 100, t /= 100;
+  let n = (a) => {
+    let b = (a + s / 60) % 6, o = t - t * r * Math.max(Math.min(b, 4 - b, 1), 0);
+    return Math.round(255 * o);
+  };
+  return [n(5), n(3), n(1)];
+}
+function f(s) {
+  let [r, t, n] = s;
+  r /= 255, t /= 255, n /= 255;
+  let a = Math.max(r, t, n), b = Math.min(r, t, n), o = a - b, y = 0, c = a === 0 ? 0 : o / a, u = a;
+  if (o !== 0) {
+    if (a === r)
+      y = (t - n) / o + (t < n ? 6 : 0);
+    else if (a === t)
+      y = (n - r) / o + 2;
+    else
+      y = (r - t) / o + 4;
+    y /= 6;
+  }
+  return [Math.round(y * 360), Math.round(c * 100), Math.round(u * 100)];
+}
+function O(s) {
+  let r = s[0] / 255, t = s[1] / 255, n = s[2] / 255, a = 1 - Math.max(r, t, n);
+  if (a === 1)
+    return [0, 0, 0, 100];
+  let b = (1 - r - a) / (1 - a), o = (1 - t - a) / (1 - a), y = (1 - n - a) / (1 - a);
+  return [Math.round(b * 100), Math.round(o * 100), Math.round(y * 100), Math.round(a * 100)];
+}
+function v(s, r, t, n) {
+  return s /= 100, r /= 100, t /= 100, n /= 100, [Math.round(255 * (1 - s) * (1 - n)), Math.round(255 * (1 - r) * (1 - n)), Math.round(255 * (1 - t) * (1 - n))];
+}
+var m = (s) => s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+var p = (s) => s <= 0.0031308 ? 12.92 * s : 1.055 * s ** 0.4166666666666667 - 0.055;
+var i = (s, r) => Math.round(s * 10 ** r) / 10 ** r;
+function T(s) {
+  let r = m(s[0] / 255), t = m(s[1] / 255), n = m(s[2] / 255), a = Math.cbrt(0.4122214708 * r + 0.5363325363 * t + 0.0514459929 * n), b = Math.cbrt(0.2119034982 * r + 0.6806995451 * t + 0.1073969566 * n), o = Math.cbrt(0.0883024619 * r + 0.2817188376 * t + 0.6299787005 * n);
+  return [i(0.2104542553 * a + 0.793617785 * b - 0.0040720468 * o, 4), i(1.9779984951 * a - 2.428592205 * b + 0.4505937099 * o, 4), i(0.0259040371 * a + 0.7827717662 * b - 0.808675766 * o, 4)];
+}
+function M(s, r, t) {
+  let n = (s + 0.3963377774 * r + 0.2158037573 * t) ** 3, a = (s - 0.1055613458 * r - 0.0638541728 * t) ** 3, b = (s - 0.0894841775 * r - 1.291485548 * t) ** 3, o = p(4.0767416621 * n - 3.3077115913 * a + 0.2309699292 * b), y = p(-1.2684380046 * n + 2.6097574011 * a - 0.3413193965 * b), c = p(-0.0041960863 * n - 0.7034186147 * a + 1.707614701 * b), u = (h) => Math.min(255, Math.max(0, Math.round(h * 255)));
+  return [u(o), u(y), u(c)];
+}
+function d(s) {
+  let [r, t, n] = T(s), a = Math.sqrt(t * t + n * n), b = (Math.atan2(n, t) * 180 / Math.PI + 360) % 360;
+  return [i(r, 4), i(a, 4), i(b, 2)];
+}
+function C(s, r, t) {
+  let n = t * Math.PI / 180;
+  return M(s, r * Math.cos(n), r * Math.sin(n));
+}
+function l(s) {
+  let r = s / 255;
+  return r <= 0.03928 ? r / 12.92 : ((r + 0.055) / 1.055) ** 2.4;
+}
+
+class e {
+  r;
+  g;
+  b;
+  a;
+  constructor(s, r, t, n = 1) {
+    this.r = s, this.g = r, this.b = t, this.a = n;
+  }
+  static from(s, r) {
+    if (s === "hex") {
+      let [t, n, a, b] = x(r);
+      return new e(t, n, a, b);
+    }
+    if (s === "rgb") {
+      if (Array.isArray(r)) {
+        let [o, y, c, u] = r;
+        return new e(o, y, c, u);
+      }
+      let { r: t, g: n, b: a, a: b } = r;
+      return new e(t, n, a, b);
+    }
+    if (s === "hsl") {
+      let t, n, a, b;
+      if (Array.isArray(r))
+        [t, n, a, b] = r;
+      else
+        ({ h: t, s: n, l: a, a: b } = r);
+      let [o, y, c] = R(t, n, a);
+      return new e(o, y, c, b);
+    }
+    if (s === "hsv") {
+      let t, n, a, b;
+      if (Array.isArray(r))
+        [t, n, a, b] = r;
+      else
+        ({ h: t, s: n, v: a, a: b } = r);
+      let [o, y, c] = H(t, n, a);
+      return new e(o, y, c, b);
+    }
+    if (s === "cmyk") {
+      let t, n, a, b, o;
+      if (Array.isArray(r))
+        [t, n, a, b, o] = r;
+      else
+        ({ c: t, m: n, y: a, k: b, a: o } = r);
+      let [y, c, u] = v(t, n, a, b);
+      return new e(y, c, u, o);
+    }
+    if (s === "oklch") {
+      let t, n, a, b;
+      if (Array.isArray(r))
+        [t, n, a, b] = r;
+      else
+        ({ l: t, c: n, h: a, a: b } = r);
+      let [o, y, c] = C(t, n, a);
+      return new e(o, y, c, b);
+    }
+    if (s === "oklab") {
+      let t, n, a, b;
+      if (Array.isArray(r))
+        [t, n, a, b] = r;
+      else
+        ({ l: t, a: n, b: a, alpha: b } = r);
+      let [o, y, c] = M(t, n, a);
+      return new e(o, y, c, b);
+    }
+    throw Error("Invalid input");
+  }
+  to(s) {
+    switch (s) {
+      case "rgb":
+        return [this.r, this.g, this.b];
+      case "rgba":
+        return [this.r, this.g, this.b, this.a];
+      case "hex":
+        return A([this.r, this.g, this.b]);
+      case "hexa":
+        return A([this.r, this.g, this.b, this.a]);
+      case "hsl":
+        return k([this.r, this.g, this.b]);
+      case "hsla":
+        return [...k([this.r, this.g, this.b]), this.a];
+      case "hsv":
+        return f([this.r, this.g, this.b]);
+      case "hsva":
+        return [...f([this.r, this.g, this.b]), this.a];
+      case "cmyk":
+        return O([this.r, this.g, this.b]);
+      case "cmyka":
+        return [...O([this.r, this.g, this.b]), this.a];
+      case "oklch":
+        return d([this.r, this.g, this.b]);
+      case "oklcha":
+        return [...d([this.r, this.g, this.b]), this.a];
+      case "oklab":
+        return T([this.r, this.g, this.b]);
+      case "oklaba":
+        return [...T([this.r, this.g, this.b]), this.a];
+      default:
+        return [this.r, this.g, this.b];
+    }
+  }
+  getLuminance() {
+    let s = l(this.r), r = l(this.g), t = l(this.b);
+    return 0.2126 * s + 0.7152 * r + 0.0722 * t;
+  }
+  contrastRatio(s) {
+    let r = this.getLuminance(), t = s.getLuminance(), [n, a] = r >= t ? [r, t] : [t, r];
+    return (n + 0.05) / (a + 0.05);
+  }
+  bestContrastForeground() {
+    let s = new e(255, 255, 255, 1), r = new e(0, 0, 0, 1), t = this.contrastRatio(s), n = this.contrastRatio(r);
+    return t >= n ? s : r;
+  }
+}
+
+// ../../node_modules/.bun/@kaynooo+utils@2.31.0+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-y1msbssb.js
+var r = 39;
+var o = 49;
+var f2 = "\x1B[";
+var C2 = { reset: [0, 0], bold: [1, 22], dim: [2, 22], italic: [3, 23], underline: [4, 24], inverse: [7, 27], hidden: [8, 28], strikethrough: [9, 29], black: [30, r], red: [31, r], green: [32, r], yellow: [33, r], blue: [34, r], magenta: [35, r], cyan: [36, r], white: [37, r], gray: [90, r], grey: [90, r], blackBright: [90, r], redBright: [91, r], greenBright: [92, r], yellowBright: [93, r], blueBright: [94, r], magentaBright: [95, r], cyanBright: [96, r], whiteBright: [97, r], bgBlack: [40, o], bgRed: [41, o], bgGreen: [42, o], bgYellow: [43, o], bgBlue: [44, o], bgMagenta: [45, o], bgCyan: [46, o], bgWhite: [47, o], bgBlackBright: [100, o], bgRedBright: [101, o], bgGreenBright: [102, o], bgYellowBright: [103, o], bgBlueBright: [104, o], bgMagentaBright: [105, o], bgCyanBright: [106, o], bgWhiteBright: [107, o], rgb: (i, n, a, l = "fg") => [`${l === "fg" ? 38 : 48};2;${i};${n};${a}`, l === "fg" ? r : o], hex: (i, n = "fg") => {
+  let [a, l, s] = e.from("hex", i).to("rgb");
+  return [`${n === "fg" ? 38 : 48};2;${a};${l};${s}`, n === "fg" ? r : o];
+}, ansi256: (i, n = "fg") => [`${n === "fg" ? 38 : 48};5;${i}`, n === "fg" ? r : o] };
+var b = new Set(["", "1", "2", "3", "true"]);
+function h(i, n = globalThis.process?.env ?? {}) {
+  if (n.FORCE_COLOR !== undefined)
+    return b.has(n.FORCE_COLOR);
+  if (n.NO_COLOR !== undefined || n.NODE_DISABLE_COLORS !== undefined || n.TERM === "dumb")
+    return false;
+  return i?.isTTY === true;
+}
+function d2(i, n, a) {
+  if (!h(a.stream ?? globalThis.process?.stdout, a.env))
+    return n;
+  let l = "", s = "";
+  for (let g = 0, y = i.length;g < y; g++) {
+    let [c, p] = i[g];
+    l += `${f2}${c}m`, s = `${f2}${p}m${s}`;
+  }
+  return l + n + s;
+}
+function u(i, n = []) {
+  return new Proxy((l) => d2(n, l, i), { get(l, s) {
+    let g = C2[s];
+    if (Array.isArray(g))
+      return u(i, [...n, g]);
+    if (typeof g === "function")
+      return (...y) => u(i, [...n, g(...y)]);
+    throw Error(`Unknown style: ${String(s)}`);
+  } });
+}
+function le(i = {}) {
+  return u(i);
+}
+var t = le();
+
+// ../kit/src/style.ts
+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 = 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 },
+  running: { symbol: "\u25CF", words: ["running", "in_progress", "started"], paint: (colors) => colors.cyan },
+  queued: { symbol: "\u25CB", words: ["queued", "waiting", "pending", "created", "blocked", "scheduled"], paint: (colors) => colors.yellow },
+  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]];
+function formatSeconds(total) {
+  let rest = Math.max(0, Math.round(total));
+  const amounts = UNITS.map(([unit, size]) => {
+    const amount = Math.floor(rest / size);
+    rest -= amount * size;
+    return `${amount}${unit}`;
+  });
+  const first = amounts.findIndex((amount) => !amount.startsWith("0"));
+  if (first === -1)
+    return "0s";
+  const next = amounts[first + 1];
+  return next === undefined || next.startsWith("0") ? amounts[first] ?? "0s" : `${amounts[first]} ${next}`;
+}
+function formatDuration(ms) {
+  return ms < 60000 ? `${(Math.max(0, ms) / 1000).toFixed(1)}s` : formatSeconds(ms / 1000);
+}
+function upTo(text, separator) {
+  const end = text.indexOf(separator);
+  return end === -1 ? text : text.slice(0, end);
+}
+function formatAge(date, now = Date.now()) {
+  const at = typeof date === "number" ? date : Date.parse(date);
+  if (Number.isNaN(at))
+    return "-";
+  const seconds = (now - at) / 1000;
+  return seconds < 60 ? "just now" : `${upTo(formatSeconds(seconds), " ")} ago`;
+}
+function truncate(text, width) {
+  return text.length <= width ? text : `${text.slice(0, Math.max(0, width - 1))}\u2026`;
+}
+var LINE_BREAKS = /\s*\n\s*/g;
+var ESCAPE = String.fromCharCode(27);
+function textWidth(text) {
+  return Bun.stringWidth(text);
+}
+function table(rows, { cellWidth, header = false, align = [], fit } = {}) {
+  const cells = cellWidth === undefined ? rows : rows.map((row) => row.map((cell) => truncate(cell.replaceAll(LINE_BREAKS, " "), cellWidth)));
+  const widths = [];
+  for (const row of cells) {
+    for (const [index, cell] of row.entries())
+      widths[index] = Math.max(widths[index] ?? 0, textWidth(cell));
+  }
+  const shown = fit === undefined ? cells : narrow(cells, widths, fit);
+  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)));
+    if (align[index] === "right")
+      return `${gap}${cell}`;
+    return index === row.length - 1 ? cell : `${cell}${gap}`;
+  }).join("  ").trimEnd());
+  return lines.map((line, index) => header && index === 0 ? colors.bold(line) : line).join(`
+`);
+}
+function narrow(rows, widths, limit) {
+  const used = () => widths.reduce((sum, width) => sum + width, 0) + 2 * Math.max(0, widths.length - 1);
+  const cuttable = (index) => rows.every((row) => !(row[index] ?? "").includes(ESCAPE));
+  const floor = 8;
+  while (used() > limit) {
+    let widest = -1;
+    for (const [index, width] of widths.entries()) {
+      if (cuttable(index) && width > floor && width > (widths[widest] ?? 0))
+        widest = index;
+    }
+    if (widest === -1)
+      break;
+    widths[widest] = Math.max(floor, (widths[widest] ?? 0) - (used() - limit));
+  }
+  return rows.map((row) => row.map((cell, index) => textWidth(cell) > (widths[index] ?? 0) ? truncate(cell, widths[index] ?? 0) : cell));
+}
+function printJson(value) {
+  console.log(JSON.stringify(value, undefined, 2));
+}
+
+// ../kit/src/args.ts
+function jsonOption(holds) {
+  return { type: "boolean", description: holds === undefined ? "print JSON" : `print JSON: ${holds}` };
+}
+
+class Exit extends Error {
+  code;
+  hint;
+  constructor(message, code, hint) {
+    super(message);
+    this.code = code;
+    this.hint = hint;
+  }
+}
+function fail(message, code = 2, hint) {
+  throw new Exit(message, code, hint);
+}
+
+class UsageError extends Exit {
+  constructor(message) {
+    super(message, 2);
+  }
+}
+function badUsage(message) {
+  throw new UsageError(message);
+}
+
+class HelpShown extends Exit {
+  constructor() {
+    super("help shown", 0);
+  }
+}
+
+class Completing {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+}
+var completion = { active: false };
+var OPTIONAL = /\[[^\]]+\]/g;
+var USAGE_PREFIX = /^usage:\s*/i;
+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(process4.stdout), { examples = [], replaces } = {}) {
+  return [usageLine(usage, colors), ...replacesRows(replaces, colors), "", colors.bold("Options:"), ...optionRows(options, colors), ...exampleRows(examples, colors)].join(`
+`);
+}
+function replacesRows(replaces, colors = paint(process4.stdout)) {
+  return replaces === undefined ? [] : ["", `${colors.bold("Instead of:")} ${replaces}`];
+}
+function wantsHelpJson(env = process4.env) {
+  return env.KIT_HELP === "json";
+}
+function description(usage, { examples = [], replaces } = {}) {
+  const lines = usage.replace(USAGE_PREFIX, "").split(`
+`);
+  const first = lines[0];
+  const colon = first.indexOf(": ");
+  const prose = lines[lines.indexOf("") + 1] ?? "";
+  const fallback = lines.includes("") ? `${prose.charAt(0).toLowerCase()}${prose.slice(1)}`.replace(FULL_STOP, "") : "";
+  return {
+    synopsis: colon === -1 ? first : first.slice(0, colon),
+    summary: colon === -1 ? fallback : first.slice(colon + 2),
+    ...replaces === undefined ? {} : { replaces },
+    examples: examples.map((example) => typeof example === "string" ? { line: example } : { line: example[0], note: example[1] })
+  };
+}
+function exampleRows(examples, colors = paint(process4.stdout)) {
+  if (examples.length === 0)
+    return [];
+  return ["", colors.bold("Examples:"), ...examples.map((example) => typeof example === "string" ? `  ${example}` : `  ${example[0]}  ${colors.dim(`# ${example[1]}`)}`)];
+}
+function optionRows(options, colors = paint(process4.stdout)) {
+  const rows = Object.entries(options).map(([name, option]) => {
+    const short = option.short === undefined ? "    " : `${colors.cyan(`-${option.short}`)}, `;
+    const value = option.type === "string" ? ` ${colors.dim("<value>")}` : "";
+    return { flag: `${short}${colors.cyan(`--${name}`)}${value}`, width: `-x, --${name}`.length + (option.type === "string" ? " <value>".length : 0), description: option.description };
+  });
+  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 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;
+  const own = separator === -1 ? args : args.slice(0, separator);
+  const rest = separator === -1 ? undefined : args.slice(separator + 1);
+  let parsed;
+  try {
+    parsed = parseArgs({ args: joinDashValues(own, all), options: all, allowPositionals: true, allowNegative: settings.allowNegative === true, strict: true });
+  } catch (error) {
+    badUsage(parseError(error));
+  }
+  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)
+    checkPositionals(parsed.positionals, settings.positionals);
+  return { ...parsed, positionals: parsed.positionals, rest };
+}
+function checkPositionals(given, names) {
+  const variadic = names.at(-1)?.replace("]", "").endsWith("...") === true;
+  const required = names.filter((name) => !name.startsWith("[")).length;
+  if (given.length < required)
+    badUsage(`missing ${names[given.length]}`);
+  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)}`;
+}
+function wholeNumber(value, name, fallback, min = 1) {
+  if (value === undefined)
+    return fallback;
+  const number = Number(value);
+  if (!Number.isInteger(number) || number < min)
+    badUsage(`--${name} takes a whole number from ${min}, not ${value}`);
+  return number;
+}
+var DURATION = /^(\d+(?:\.\d+)?)(ms|[smh])?$/;
+var UNIT_MS = { ms: 1, s: 1000, m: 60000, h: 3600000 };
+function duration(value, name, fallback, unit = "s") {
+  if (value === undefined)
+    return fallback;
+  const match = DURATION.exec(value.trim());
+  const ms = match === null ? 0 : Number(match[1]) * UNIT_MS[match[2] ?? unit];
+  if (ms < 1)
+    badUsage(`--${name} takes a duration such as 30s, 5m or 1h, not ${value}`);
+  return ms;
+}
+async function readInput(path, { noStdin = "nothing is piped on stdin" } = {}) {
+  if (path === "-") {
+    if (process4.stdin.isTTY)
+      fail(noStdin);
+    return Bun.stdin.text();
+  }
+  const file = Bun.file(path);
+  if (!await file.exists())
+    fail(`no file ${path}`);
+  return file.text();
+}
+// ../kit/src/cli.ts
+import process5 from "process";
+
+// ../kit/src/text.ts
+var ANSI = new RegExp(`${String.fromCharCode(27)}\\[[\\d;?]*[a-z]`, "gi");
+function distance(a, b) {
+  let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (const [i, left] of [...a].entries()) {
+    const current = [i + 1];
+    for (const [j, right] of [...b].entries())
+      current.push(Math.min((previous[j + 1] ?? 0) + 1, (current[j] ?? 0) + 1, (previous[j] ?? 0) + (left === right ? 0 : 1)));
+    previous = current;
+  }
+  return previous[b.length] ?? 0;
+}
+
+// ../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)
+    return started;
+  const [best] = names.map((known) => ({ known, far: distance(name, known) })).sort((a, b) => a.far - b.far);
+  return best !== undefined && best.far <= (name.length < 4 ? 1 : 2) ? best.known : undefined;
+}
+async function help({ path, header, summary, commands, defaultCommand, examples, replaces }, stream) {
+  const colors = paint(stream);
+  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),
+    "",
+    ...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(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 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;
+  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, 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, process5.stderr));
+    return 2;
+  }
+  if (name === undefined || name === "help" || name === "--help" || name === "-h") {
+    console.log(await help(level, process5.stdout));
+    return 0;
+  }
+  if (level.path.length === 1 && (name === "--version" || name === "-v")) {
+    console.log(version);
+    return 0;
+  }
+  let command = level.commands[level.aliases?.[name] ?? name];
+  let rest = args;
+  if (command === undefined && level.defaultCommand !== undefined) {
+    command = level.commands[level.defaultCommand];
+    rest = argv;
+  }
+  if (command === undefined) {
+    const meant = closest(name, Object.keys(level.commands));
+    printError(prefix, `no command ${name}`, meant === undefined ? `run ${prefix} --help for its commands` : `did you mean ${meant}?`);
+    return 2;
+  }
+  if ("commands" in command) {
+    const { summary } = command;
+    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, wantsJson(rest));
+  }
+}
+var COMPLETE = "__complete";
+var FILES = "__files__";
+async function optionsOf(run) {
+  completion.active = true;
+  try {
+    await run([]);
+  } catch (error) {
+    if (error instanceof Completing)
+      return error.options;
+  } finally {
+    completion.active = false;
+  }
+  return {};
+}
+async function leafCandidates(run, words) {
+  if (!(words.at(-1) ?? "").startsWith("-"))
+    return [FILES];
+  return Object.entries(await optionsOf(run)).map(([name, option]) => `--${name}	${option.description}`);
+}
+async function candidates(commands, aliases, defaultCommand, words) {
+  const [word = "", ...rest] = words;
+  const command = commands[aliases?.[word] ?? word];
+  if (rest.length === 0 && !word.startsWith("-"))
+    return Object.entries(commands).map(([name, { summary }]) => `${name}	${summary}`);
+  if (command === undefined) {
+    const fallback = defaultCommand === undefined ? undefined : commands[defaultCommand];
+    return fallback !== undefined && "run" in fallback ? leafCandidates(fallback.run, words) : [];
+  }
+  return "commands" in command ? candidates(command.commands, command.aliases, undefined, rest) : leafCandidates(command.run, rest);
+}
+async function printCandidates(found) {
+  for (const line of await found)
+    console.log(line);
+  return 0;
+}
+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}`, 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.6.0";
+
+// src/args.ts
+var repoOption = {
+  repo: { type: "string", short: "r", description: "owner/name of the repository, instead of the one origin points at" }
+};
+var ISSUE_HASH = /^#/;
+function issueNumber(value, usage) {
+  if (value === undefined)
+    fail(`an issue number is needed
+
+${usage}`);
+  return wholeNumber(value.replace(ISSUE_HASH, ""), "issue", 0);
+}
+function issueNumbers(values, usage) {
+  return values.length === 0 ? [issueNumber(undefined, usage)] : values.map((value) => issueNumber(value, usage));
+}
+
+// src/checklist.ts
+var BOX = /^(\s*[-*+] \[)([ x])(\]\s)(.*)\r?$/i;
+var FENCE = /^\s*(?:```|~~~)/;
+function boxes(body) {
+  const found = [];
+  let fenced = false;
+  for (const [line, text] of body.split(`
+`).entries()) {
+    if (FENCE.test(text)) {
+      fenced = !fenced;
+      continue;
+    }
+    const match = fenced ? null : BOX.exec(text);
+    if (match !== null)
+      found.push({ number: found.length + 1, line, done: match[2] !== " ", text: match[4] ?? "" });
+  }
+  return found;
+}
+var INDENT = /^\s*/;
+function appendBoxes(body, texts) {
+  const end = body.includes(`\r
+`) ? "\r" : "";
+  const last = boxes(body).at(-1);
+  const lines = body.split(`
+`);
+  const indent = last === undefined ? "" : INDENT.exec(lines[last.line] ?? "")?.[0] ?? "";
+  const added = texts.map((text) => `${indent}- [ ] ${text}${end}`);
+  if (last === undefined)
+    return body.trim() === "" ? added.join(`
+`) : `${body.trimEnd()}${end}
+${end}
+${added.join(`
+`)}`;
+  lines.splice(last.line + 1, 0, ...added);
+  return lines.join(`
+`);
+}
+function numberedBody(body) {
+  const lines = body.replaceAll(`\r
+`, `
+`).split(`
+`);
+  for (const box of boxes(body))
+    lines[box.line] = `${INDENT.exec(lines[box.line] ?? "")?.[0] ?? ""}${box.number} [${box.done ? "x" : " "}] ${box.text}`;
+  return lines.join(`
+`).trim();
+}
+function setBoxes(body, picks, done) {
+  const all = boxes(body);
+  const chosen = new Map;
+  for (const pick of picks) {
+    const number = Number(pick);
+    const needle = pick.toLowerCase();
+    const matches = Number.isInteger(number) && String(number) === pick ? all.filter((box) => box.number === number) : all.filter((box) => box.text.toLowerCase().includes(needle));
+    if (matches.length === 0)
+      throw new Error(`no box matches ${pick}`);
+    if (matches.length > 1)
+      throw new Error(`${pick} matches ${matches.length} boxes: ${matches.map((box) => box.number).join(", ")}`);
+    const [box] = matches;
+    if (box !== undefined)
+      chosen.set(box.number, box);
+  }
+  const lines = body.split(`
+`);
+  const changed = [];
+  for (const box of chosen.values()) {
+    if (box.done === done)
+      continue;
+    const line = lines[box.line] ?? "";
+    lines[box.line] = line.replace(BOX, `$1${done ? "x" : " "}$3$4`) + (line.endsWith("\r") ? "\r" : "");
+    changed.push({ ...box, done });
+  }
+  return { body: lines.join(`
+`), changed };
+}
+var REFERENCE = /^#(\d+)(?!\d)/;
+function referencedBoxes(body) {
+  const found = [];
+  for (const box of boxes(body)) {
+    const match = REFERENCE.exec(box.text);
+    if (match?.[1] !== undefined)
+      found.push({ box, issue: Number(match[1]) });
+  }
+  return found;
+}
+function tickReferences(body, wanted) {
+  const picks = referencedBoxes(body).filter(({ box, issue }) => !box.done && wanted(issue)).map(({ box }) => String(box.number));
+  return setBoxes(body, picks, true);
+}
+
+// src/claims.ts
+var TAKEN = /^\s*taken by session ([\w.@:-]+?)\.?\s*$/im;
+var RELEASED = /^\s*released by session ([\w.@:-]+?)\.?\s*$/im;
+var LANE = /^lane-([^-]+)-/;
+function takenComment(name) {
+  return `Taken by session ${name}.`;
+}
+function releasedComment(name) {
+  return `Released by session ${name}.`;
+}
+function latestClaim(comments) {
+  let claim;
+  for (const comment of [...comments].sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at))) {
+    const taken = TAKEN.exec(comment.body)?.[1];
+    if (taken !== undefined) {
+      claim = { holder: taken, at: comment.created_at };
+      continue;
+    }
+    if (claim !== undefined && RELEASED.exec(comment.body)?.[1] === claim.holder)
+      claim = undefined;
+  }
+  return claim;
+}
+function laneSuffix(session) {
+  const suffix = session.slice(session.lastIndexOf("-") + 1);
+  return session.includes("-") && suffix !== "" ? suffix : undefined;
+}
+function latestNote(comments) {
+  return comments.filter((comment) => !TAKEN.test(comment.body) && !RELEASED.test(comment.body)).sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at)).at(-1);
+}
+function holderSession(holder, sessions) {
+  const own = sessions.find((session) => session.name === holder);
+  if (own !== undefined)
+    return own;
+  const lane = LANE.exec(holder)?.[1];
+  return lane === undefined ? undefined : sessions.find((session) => session.name.endsWith(`-${lane}`));
+}
+
+// src/tea.ts
+var {$: $2 } = globalThis.Bun;
+
+// src/git.ts
+import { basename, dirname } from "path";
+import process8 from "process";
+var {$ } = globalThis.Bun;
+var ORIGIN_PREFIX = /^origin\//;
+function spawnFailure(command, error) {
+  return new Error(`${command}: ${error instanceof Error ? error.message : String(error)}${cwdGone() ? " (the working directory was removed)" : ""}`);
+}
+async function git(args) {
+  let result;
+  try {
+    result = await $`git ${args}`.quiet().nothrow();
+  } catch (error) {
+    throw spawnFailure(`git ${args.join(" ")}`, error);
+  }
+  if (result.exitCode !== 0)
+    throw new Error(`git ${args.join(" ")}: ${result.stderr.toString().trim() || `exit ${result.exitCode}`}`);
+  return result.stdout.toString().trim();
+}
+async function gitOk(args) {
+  return (await $`git ${args}`.quiet().nothrow()).exitCode === 0;
+}
+async function resolveCommit(ref) {
+  const sha = (await $`git rev-parse --verify -q ${`${ref}^{commit}`}`.quiet().nothrow().text()).trim();
+  if (sha === "")
+    fail(`no commit ${ref}`);
+  return sha;
+}
+async function defaultBranch() {
+  const head = (await $`git symbolic-ref --short -q refs/remotes/origin/HEAD`.quiet().nothrow().text()).trim();
+  return head === "" ? "main" : head.replace(ORIGIN_PREFIX, "");
+}
+async function tagsAt(commit) {
+  return (await git(["tag", "--points-at", commit])).split(`
+`).filter(Boolean);
+}
+async function commitsNaming(issue, ref) {
+  const out = await git(["log", ref, "--reverse", "--extended-regexp", `--grep=#${issue}([^0-9]|$)`, "--format=%H %s"]);
+  return out.split(`
+`).filter(Boolean).map((line) => {
+    const space = line.indexOf(" ");
+    return { sha: line.slice(0, space), subject: line.slice(space + 1) };
+  });
+}
+function cwdGone() {
+  try {
+    process8.cwd();
+    return false;
+  } catch {
+    return true;
+  }
+}
+async function leaveWorktree() {
+  const common = await git(["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  if (basename(common) === ".git")
+    process8.chdir(dirname(common));
+}
+
+// src/tea.ts
+function repoFlag(repo) {
+  return repo === undefined ? [] : ["--repo", repo];
+}
+async function request(path, repo) {
+  let result;
+  try {
+    result = await $2`tea api ${repoFlag(repo)} ${path}`.quiet().nothrow();
+  } catch (error) {
+    throw spawnFailure(`tea api ${path}`, error);
+  }
+  if (result.exitCode !== 0)
+    throw new Error(`tea api ${path}: ${result.stderr.toString().trim() || `exit ${result.exitCode}`}`);
+  return result.stdout.toString();
+}
+function parseJson(path, text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new Error(`tea api ${path}: ${upTo(text.trim(), `
+`) || "empty answer"}`);
+  }
+  if (value !== null && typeof value === "object" && !Array.isArray(value) && "message" in value && typeof value.message === "string" && "url" in value)
+    throw new Error(`tea api ${path}: ${value.message}`);
+  return value;
+}
+async function api(path, repo) {
+  return parseJson(path, await request(path, repo));
+}
+async function repoApi(path, repo) {
+  return api(`repos/{owner}/{repo}/${path}`, repo);
+}
+async function 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);
+}
+async function tea(args, repo) {
+  let result;
+  try {
+    result = await $2`tea ${args} ${repoFlag(repo)}`.quiet().nothrow();
+  } catch (error) {
+    throw spawnFailure(`tea ${args[0] ?? ""}`, error);
+  }
+  if (result.exitCode !== 0)
+    throw new Error(`tea ${args[0] ?? ""}: ${result.stderr.toString().trim() || result.stdout.toString().trim() || `exit ${result.exitCode}`}`);
+  return result.stdout.toString();
+}
+
+// src/issues.ts
+var PAGE = 50;
+var CONCURRENCY = 8;
+async function getIssue(number, repo) {
+  return repoApi(`issues/${number}`, repo);
+}
+async function listIssues(state, filter, repo) {
+  const issues = [];
+  for (let page = 1;; page++) {
+    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);
+}
+async function commentsOfAll(issues, repo) {
+  const result = new Map;
+  const queue = issues.filter((issue) => issue.comments > 0);
+  async function worker() {
+    for (let issue = queue.shift();issue !== undefined; issue = queue.shift())
+      result.set(issue.number, await commentsOf(issue.number, repo));
+  }
+  await Promise.all(Array.from({ length: CONCURRENCY }, worker));
+  return result;
+}
+async function editIssue(number, change, repo) {
+  const args = ["issues", "edit", String(number)];
+  if (change.title !== undefined)
+    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, 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)
+    throw new Error(`created "${title}" but cannot find it among the open issues`);
+  return created;
+}
+async function editBody(number, change, repo) {
+  const { body } = await getIssue(number, repo);
+  const next = change(body);
+  if (next === body)
+    return false;
+  await setBody(number, next, repo);
+  return true;
+}
+async function comment(number, body, repo) {
+  await tea(["comment", String(number), body], repo);
+}
+async function close(number, repo) {
+  await tea(["issues", "close", String(number)], repo);
+}
+async function reopen(number, repo) {
+  await tea(["issues", "reopen", String(number)], repo);
+}
+async function repoLabels(repo) {
+  const names = [];
+  for (let page = 1;; page++) {
+    const batch = await repoApi(`labels?page=${page}&limit=${PAGE}`, repo);
+    names.push(...batch.map((each) => each.name));
+    if (batch.length < PAGE)
+      return names;
+  }
+}
+async function editLabels(number, add, remove, repo) {
+  const args = ["issues", "edit", String(number)];
+  if (add.length > 0)
+    args.push("--add-labels", add.join(","));
+  if (remove.length > 0)
+    args.push("--remove-labels", remove.join(","));
+  await tea(args, repo);
+}
+
+// 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 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 (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);
+  } catch {}
+  return [...dirs];
+}
+async function procStat(pid) {
+  try {
+    const stat = await Bun.file(`/proc/${pid}/stat`).text();
+    return stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+  } catch {
+    return;
+  }
+}
+async function isAlive(pid, procStart) {
+  const stat = await procStat(pid);
+  if (stat === undefined)
+    return false;
+  return procStart === undefined || stat[19] === procStart;
+}
+async function liveSessions() {
+  const sessions = new Map;
+  for (const dir of await sessionDirs()) {
+    let files;
+    try {
+      files = await Array.fromAsync(SESSION_FILES.scan({ cwd: dir, absolute: true }));
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      let entry;
+      try {
+        entry = await Bun.file(file).json();
+      } catch {
+        continue;
+      }
+      if (entry.name === undefined || entry.pid === undefined || sessions.has(entry.pid) || !await isAlive(entry.pid, entry.procStart))
+        continue;
+      sessions.set(entry.pid, { name: entry.name, pid: entry.pid, status: entry.status ?? "unknown", cwd: entry.cwd ?? "" });
+    }
+  }
+  return [...sessions.values()];
+}
+async function currentSession(sessions) {
+  const byPid = new Map(sessions.map((session) => [session.pid, session]));
+  let pid = process9.ppid;
+  for (let depth = 0;depth < 32 && pid > 1; depth++) {
+    const session = byPid.get(pid);
+    if (session !== undefined)
+      return session;
+    const parent = Number((await procStat(pid))?.[1]);
+    if (!Number.isInteger(parent))
+      return;
+    pid = parent;
+  }
+  return;
+}
+
+// src/commands/board.ts
+var LINE_START = /^/gm;
+var TITLE_WIDTH = 80;
+function standing(claim, sessions) {
+  if (claim === undefined)
+    return { state: "available" };
+  const session = holderSession(claim.holder, sessions);
+  return session === undefined ? { state: "away", claim } : { state: "taken", claim, session };
+}
+var NOTE_WIDTH = 100;
+var STATES = new Set(["available", "taken", "away"]);
+function boxesLeft(issue) {
+  const list = boxes(issue.body);
+  return list.length === 0 ? "" : `${list.filter((box) => !box.done).length}/${list.length} left`;
+}
+function claimRow(issue, row, now) {
+  const holder = row.state === "taken" && row.session.name !== row.claim.holder ? `${row.claim.holder} via ${row.session.name}` : row.claim.holder;
+  const status = row.state === "taken" ? ` (${row.session.status})` : "";
+  return [`#${issue.number}`, `${holder}${status}`, formatAge(row.claim.at, now), boxesLeft(issue), truncate(issue.title, TITLE_WIDTH)];
+}
+function noteLine(comments, now) {
+  const note = latestNote(comments);
+  const first = note?.body.split(`
+`).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 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, ...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(`
+`).replace(LINE_START, "  ")}`).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, 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.
+
+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
+};
+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;
+  try {
+    query = values.query === undefined ? undefined : new RegExp(values.query, "i");
+  } catch (error) {
+    fail(`--query: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const milestone = values.milestone === undefined ? undefined : (await findMilestone(values.milestone, values.repo)).id;
+  const [open, sessions] = await Promise.all([openIssues(values.labels, values.repo, milestone), liveSessions()]);
+  const issues = query === undefined ? open : open.filter((issue) => query.test(issue.title));
+  const rows = (await boardRows(issues, sessions, values.repo)).filter((row) => state === undefined || row.standing.state === state);
+  if (values.json === true) {
+    printJson(boardJson(rows));
+    return 0;
+  }
+  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) {
+  if (as !== undefined)
+    return as;
+  const session = await currentSession(sessions);
+  if (session === undefined)
+    fail("not run from a Claude Code session: pass --as <name>");
+  return session.name;
+}
+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.
+
+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" }
+};
+var takeOptions = {
+  as: { type: "string", description: "the name to claim as, instead of this session's" },
+  ...laneOption,
+  "take-stale": { type: "boolean", description: "take it over from a claim no live session here answers to" },
+  ...repoOption
+};
+async function claimant(values, sessions) {
+  const name = await me(values.as, sessions);
+  if (values.lane !== true)
+    return () => name;
+  const suffix = laneSuffix(name);
+  if (suffix === undefined)
+    fail(`a lane is named after a session whose name ends in -<n>, not ${name}: pass --as`);
+  return (number) => `lane-${suffix}-${number}`;
+}
+async function eachIssue(command, numbers, step) {
+  let code = 0;
+  for (const number of numbers) {
+    try {
+      await step(number);
+    } catch (error) {
+      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);
+    }
+  }
+  return code;
+}
+async function take(args) {
+  const parsed = parse(args, takeUsage, takeOptions);
+  const { values, positionals } = parsed;
+  const numbers = issueNumbers(positionals, takeUsage);
+  const sessions = await liveSessions();
+  const nameFor = await claimant(values, sessions);
+  return eachIssue("take", numbers, async (number) => {
+    const name = nameFor(number);
+    const [found, comments] = await Promise.all([getIssue(number, values.repo), commentsOf(number, values.repo)]);
+    if (found.state === "closed")
+      fail(`#${number} is closed`, 1, runHint(`ft reopen ${number}`, "reopen it"));
+    const claim = latestClaim(comments);
+    const current = standing(claim, sessions);
+    if (claim?.holder === name) {
+      console.log(`#${number} is already taken by ${name}`);
+      return;
+    }
+    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`, 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.
+
+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,
+  ...repoOption
+};
+async function drop(args) {
+  const parsed = parse(args, dropUsage, dropOptions);
+  const { values, positionals } = parsed;
+  const numbers = issueNumbers(positionals, dropUsage);
+  const nameFor = await claimant(values, await liveSessions());
+  return eachIssue("drop", numbers, async (number) => {
+    const name = nameFor(number);
+    const claim = latestClaim(await commentsOf(number, values.repo));
+    if (claim?.holder !== name)
+      fail(`#${number} is ${claim === undefined ? "not taken" : `taken by ${claim.holder}, not ${name}`}`, 1);
+    await comment(number, releasedComment(name), values.repo);
+    console.log(`released #${number}`);
+  });
+}
+
+// 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\]$/;
+var FAIL = "(fail) ";
+var PASS = "(pass) ";
+var MAX_TESTS = 10;
+var STAMP = /^\S+Z /;
+var FAILED_STEP = /\u274C\s+Failure - Main /;
+var STEP_TAIL = 30;
+var TAIL = 40;
+function logLines(log) {
+  return log.split(`
+`).map((line) => line.replace(STAMP, ""));
+}
+function failedTests(lines) {
+  const seen = new Set;
+  const blocks = [];
+  for (const [index, line] of lines.entries()) {
+    const name = line.replace(DURATION2, "");
+    if (!line.startsWith(FAIL) || seen.has(name))
+      continue;
+    seen.add(name);
+    if (blocks.length < MAX_TESTS)
+      blocks.push(lines.slice(lines.findLastIndex((text, at) => at < index && BOUNDARY.test(text)) + 1, index + 1).filter((text) => !text.startsWith("::")).join(`
+`).trim());
+  }
+  if (seen.size > MAX_TESTS)
+    blocks.push(`and ${seen.size - MAX_TESTS} more failed tests`);
+  return blocks;
+}
+function excerpt(log) {
+  const lines = logLines(log);
+  const parts = failedTests(lines);
+  for (const [index, line] of lines.entries()) {
+    if (FAILED_STEP.test(line))
+      parts.push(lines.slice(Math.max(0, index - STEP_TAIL), index + 1).filter((text) => text.trim() !== "" && !text.startsWith(PASS) && !text.startsWith("::")).join(`
+`));
+  }
+  return parts.length === 0 ? lines.slice(-TAIL).join(`
+`).trim() : parts.join(`
+
+`);
+}
+
+// src/runs.ts
+var FINISHED = new Set(["success", "failure", "skipped", "cancelled"]);
+var QUEUED = new Set(["waiting", "blocked"]);
+var NANOSECONDS = 1e9;
+var EPOCH = Date.parse("2000-01-01T00:00:00Z");
+function runSeconds(run) {
+  return run.duration / NANOSECONDS;
+}
+function startedAge(run, now = Date.now()) {
+  return Date.parse(run.started) < EPOCH ? "-" : formatAge(run.started, now);
+}
+var RUNS_PAGE = 50;
+async function runsListing(limit, repo, workflow) {
+  const filter = workflow === undefined ? "" : `&workflow_id=${encodeURIComponent(workflow)}`;
+  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 ?? [];
+}
+async function runById(id, repo) {
+  return repoApi(`actions/runs/${id}`, repo);
+}
+async function jobsOf(run, repo) {
+  return repoApi(`actions/runs/${run}/jobs`, repo);
+}
+async function jobLog(job, repo) {
+  return repoApiText(`actions/jobs/${job}/logs`, repo);
+}
+async function refreshed(runs, repo) {
+  try {
+    return await Promise.all(runs.map(async (run) => runById(run.id, repo)));
+  } catch {
+    return;
+  }
+}
+function newestPerWorkflow(runs, workflow) {
+  const newest = new Map;
+  for (const run of runs) {
+    if (run.event !== "push" || workflow !== undefined && run.workflow_id !== workflow)
+      continue;
+    const kept = newest.get(run.workflow_id);
+    if (kept === undefined || run.id > kept.id)
+      newest.set(run.workflow_id, run);
+  }
+  return [...newest.values()].sort((a, b) => a.workflow_id.localeCompare(b.workflow_id));
+}
+function overall(runs) {
+  const statuses = new Set(runs.map((run) => run.status));
+  for (const status of ["failure", "cancelled"]) {
+    if (statuses.has(status))
+      return status;
+  }
+  const pending = runs.find((run) => !FINISHED.has(run.status));
+  if (pending !== undefined)
+    return pending.status;
+  return statuses.has("success") ? "success" : "skipped";
+}
+async function stallReason(runs, repo) {
+  const queued = runs.filter((run) => QUEUED.has(run.status));
+  if (queued.length === 0)
+    return;
+  let runners;
+  try {
+    runners = await api("admin/actions/runners");
+  } catch {
+    return;
+  }
+  const online = runners.filter((runner) => runner.status !== "offline");
+  if (online.length === 0)
+    return { reason: runners.length === 0 ? "no runner is registered" : `every runner is offline (${runners.map((runner) => runner.name).join(", ")})`, certain: false };
+  for (const run of queued) {
+    for (const job of await jobsOf(run.id, repo)) {
+      const labels = job.runs_on ?? [];
+      if (QUEUED.has(job.status) && !online.some((runner) => labels.every((label) => (runner.labels ?? []).includes(label))))
+        return { reason: `job ${job.name} of ${run.workflow_id} runs on ${labels.join(", ")}, which no online runner carries (${online.map((runner) => `${runner.name}: ${(runner.labels ?? []).join(", ")}`).join("; ")})`, certain: true };
+    }
+  }
+  return online.some((runner) => runner.status === "active") ? undefined : { reason: "no runner is working on anything: is it up?", certain: false };
+}
+async function failureReport(run, repo) {
+  const parts = [];
+  for (const job of await jobsOf(run.id, repo)) {
+    if (job.status === "failure")
+      parts.push(`job ${job.name} of ${run.workflow_id} failed:
+${excerpt(await jobLog(job.id, repo))}`);
+  }
+  return parts.join(`
+
+`);
+}
+
+// src/commands/ci.ts
+var usage = `ft ci [ref]
+
+Waits for the push runs covering a commit on the branch, by default origin's tip, and prints what each failed job's log says.
+A push's run tests every commit since the previous push, so a commit whose own run was cancelled, or whose --job was skipped, is covered by the next commit's runs.
+Exits 0 when they pass, 1 when one fails, 2 on a timeout, a stalled queue or a commit not on the branch.`;
+var options = {
+  branch: { type: "string", short: "b", description: "branch the commit is on, by default the one origin/HEAD names" },
+  workflow: { type: "string", short: "w", description: "only this workflow file, e.g. test.yml; by default every workflow a push starts" },
+  job: { type: "string", short: "j", description: "a job whose skipping means the run left its work to a newer push" },
+  timeout: { type: "string", short: "t", description: "how long before giving up (30m), a bare number in minutes" }
+};
+var POLL = 15000;
+var NO_RUN = 3 * 60000;
+var STALLED = 3 * 60000;
+function judge(runs, jobSkipped, tagged) {
+  if (runs.length === 0)
+    return { kind: "none" };
+  if (runs.some((run) => !FINISHED.has(run.status)))
+    return { kind: "runs", runs };
+  if (runs.some((run) => run.status === "cancelled"))
+    return { kind: "passed-over" };
+  if (!jobSkipped)
+    return { kind: "runs", runs };
+  return tagged ? { kind: "runs", runs: runs.map((run) => ({ ...run, status: "skipped" })) } : { kind: "passed-over" };
+}
+async function ci(args) {
+  const parsed = parse(args, usage, options);
+  const { values, positionals } = parsed;
+  const branch = values.branch ?? await defaultBranch();
+  const giveUp = duration(values.timeout, "timeout", 30 * 60000, "m");
+  const sha = await resolveCommit(positionals[0] ?? `origin/${branch}`);
+  const short = sha.slice(0, 7);
+  await leaveWorktree();
+  const passedOver = new Set;
+  async function coverageOf(commit) {
+    if (passedOver.has(commit))
+      return { kind: "passed-over" };
+    const runs = newestPerWorkflow(await runsOn(commit), values.workflow);
+    let jobSkipped = false;
+    if (values.job !== undefined && runs.every((run) => FINISHED.has(run.status))) {
+      for (const run of runs)
+        jobSkipped ||= (await jobsOf(run.id)).some((job) => job.name === values.job && job.status === "skipped");
+    }
+    const coverage = judge(runs, jobSkipped, jobSkipped && (await tagsAt(commit)).length > 0);
+    if (coverage.kind === "passed-over")
+      passedOver.add(commit);
+    return coverage;
+  }
+  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}`, 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]) {
+      const coverage = await coverageOf(commit);
+      if (coverage.kind === "runs")
+        return coverage.runs;
+    }
+    return;
+  }
+  const started = Date.now();
+  let seen = started;
+  let moving = started;
+  let followed = "";
+  let runs;
+  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;
+      }
+      if (runs !== undefined) {
+        seen = Date.now();
+        const ids = runs.map((run) => run.id).join(",");
+        if (ids !== followed) {
+          followed = ids;
+          for (const run of runs)
+            console.log(`following ${run.workflow_id} run ${run.id} on ${run.commit_sha.slice(0, 7)}${run.commit_sha === sha ? "" : `, which covers ${short}`}: ${run.html_url}`);
+        }
+        if (runs.every((run) => FINISHED.has(run.status)))
+          break;
+        const stall = await stallReason(runs);
+        if (stall === undefined)
+          moving = Date.now();
+        else if (stall.certain || Date.now() - moving > STALLED)
+          fail(`runs queued on ${short} are not moving: ${stall.reason}`);
+      } else if (Date.now() - seen > NO_RUN) {
+        fail(`no run covers ${short} yet: its own was cancelled by a later push or never started, so the next push's will`);
+      }
+      await Bun.sleep(POLL);
+    }
+  } finally {
+    region.stop();
+  }
+  const status = overall(runs);
+  if (status !== "failure") {
+    console.log(`CI ${status === "success" ? "passed" : "skipped its tests, a release tag's workflow testing them"} on ${short}`);
+    return 0;
+  }
+  for (const run of runs) {
+    if (run.status === "failure")
+      console.error(`
+${await failureReport(run)}
+
+run ${run.id} failed${run.commit_sha === sha ? "" : `, testing every commit from ${short} to ${run.commit_sha.slice(0, 7)}`}: ${run.html_url}`);
+  }
+  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)
+    return;
+  const known = await repoLabels(repo);
+  const missing = names.filter((name) => !known.includes(name));
+  if (missing.length > 0)
+    fail(`no label ${missing.join(", ")} in this repository, ${known.length === 0 ? "which has none" : `it has: ${known.join(", ")}`}`);
+}
+var stateOptions = {
+  message: { type: "string", short: "m", description: "a comment posted first, saying why" },
+  ...repoOption
+};
+async function setState(args, usage, wanted) {
+  const parsed = parse(args, usage, stateOptions);
+  const { values, positionals } = parsed;
+  for (const number of issueNumbers(positionals, usage)) {
+    if ((await getIssue(number, values.repo)).state === wanted) {
+      console.log(`#${number} is already ${wanted}`);
+      continue;
+    }
+    if (values.message !== undefined && values.message.trim() !== "")
+      await comment(number, values.message.trim(), values.repo);
+    if (wanted === "closed")
+      await close(number, values.repo);
+    else
+      await reopen(number, values.repo);
+    console.log(`${wanted === "closed" ? "closed" : "reopened"} #${number}`);
+  }
+  return 0;
+}
+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.
+
+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.
+
+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");
+}
+var LABEL_FLAGS = new Set(["-h", "--help"]);
+var REPO_FLAGS = new Set(["-r", "--repo"]);
+function labelChanges(args) {
+  const rest = [];
+  const add = [];
+  const remove = [];
+  for (let at = 0;at < args.length; at++) {
+    const arg = args[at] ?? "";
+    if (REPO_FLAGS.has(arg) && at + 1 < args.length)
+      rest.push(arg, args[++at] ?? "");
+    else if (arg.startsWith("+") && arg.length > 1)
+      add.push(arg.slice(1));
+    else if (arg.startsWith("-") && !arg.startsWith("--") && arg.length > 1 && !LABEL_FLAGS.has(arg) && !REPO_FLAGS.has(arg))
+      remove.push(arg.slice(1));
+    else
+      rest.push(arg);
+  }
+  return { rest, add, remove };
+}
+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.
+
+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);
+  const { values, positionals } = parsed;
+  const number = issueNumber(positionals[0], labelUsage);
+  const add = [...positionals.slice(1), ...changes.add];
+  const { remove } = changes;
+  if (add.length === 0 && remove.length === 0)
+    fail(`name labels to add or remove
+
+${labelUsage}`);
+  const both = add.filter((name) => remove.includes(name));
+  if (both.length > 0)
+    fail(`${both.join(", ")} is both added and removed`);
+  await checkLabels(add, values.repo);
+  await editLabels(number, add, remove, values.repo);
+  const labels = (await getIssue(number, values.repo)).labels.map((each) => each.name);
+  console.log(`#${number} labels: ${labels.length === 0 ? "none" : labels.join(", ")}`);
+  return 0;
+}
+
+// src/commands/issue.ts
+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\`.
+
+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" },
+  body: { type: "boolean", short: "b", description: "only the raw description, without numbered boxes" },
+  json: jsonOption("number, title, state, url, labels, claim, boxes, body and comments, an array for several issues"),
+  ...repoOption
+};
+function renderIssue(found, comments, view, now = Date.now()) {
+  const claim = latestClaim(comments);
+  const list = boxes(found.body);
+  const left = list.filter((box) => !box.done);
+  const facts = [found.state];
+  if (list.length > 0)
+    facts.push(`${left.length} of ${list.length} boxes left`);
+  if (claim !== undefined)
+    facts.push(`taken by ${claim.holder} ${formatAge(claim.at, now)}`);
+  const header = `#${found.number} ${found.title} (${facts.join(", ")})`;
+  if (view.todo)
+    return [header, ...left.map((box) => `${String(box.number).padStart(3)} [ ] ${box.text}`)].join(`
+`);
+  const parts = [`${header}
+${found.html_url}`];
+  const body = numberedBody(found.body);
+  if (body !== "")
+    parts.push(body);
+  if (view.comments) {
+    for (const each of comments)
+      parts.push(`--- ${each.user.login}, ${formatAge(each.created_at, now)}
+${each.body.replaceAll(`\r
+`, `
+`).trim()}`);
+  }
+  return parts.join(`
+
+`);
+}
+function issueJson(found, comments) {
+  return {
+    number: found.number,
+    title: found.title,
+    state: found.state,
+    url: found.html_url,
+    labels: found.labels.map((label) => label.name),
+    claim: latestClaim(comments) ?? null,
+    boxes: boxes(found.body).map(({ number, done, text }) => ({ number, done, text })),
+    body: found.body,
+    comments: comments.map((each) => ({ author: each.user.login, at: each.created_at, body: each.body }))
+  };
+}
+async function issue(args) {
+  const parsed = parse(args, issueUsage, issueOptions);
+  const { values, positionals } = parsed;
+  const numbers = issueNumbers(positionals, issueUsage);
+  if (values.body === true) {
+    const bodies = await Promise.all(numbers.map(async (number) => (await getIssue(number, values.repo)).body.replaceAll(`\r
+`, `
+`)));
+    console.log(bodies.join(`
+
+`));
+    return 0;
+  }
+  const read = await Promise.all(numbers.map(async (number) => Promise.all([getIssue(number, values.repo), commentsOf(number, values.repo)])));
+  if (values.json === true) {
+    const json = read.map(([found, comments]) => issueJson(found, comments));
+    printJson(json.length === 1 ? json[0] : json);
+    return 0;
+  }
+  const view = { todo: values.todo === true, comments: values.comments === true };
+  console.log(read.map(([found, comments]) => renderIssue(found, comments, view)).join(view.todo ? `
+
+` : `
+
+
+`));
+  return 0;
+}
+var noteOptions = {
+  message: { type: "string", short: "m", description: "comment this text on the issue" },
+  file: { type: "string", short: "F", description: "comment the text of this file, - for stdin" }
+};
+async function noteText(values) {
+  if (values.message !== undefined && values.file !== undefined)
+    fail("give the comment once, as text or with -F");
+  const text = values.file === undefined ? values.message : await readInput(values.file);
+  return text?.trim() === "" ? undefined : text?.trim();
+}
+async function isClosed(number, repo) {
+  try {
+    return (await getIssue(number, repo)).state === "closed";
+  } catch {
+    return false;
+  }
+}
+async function closedReferences(body, repo) {
+  const listed = [...new Set(referencedBoxes(body).filter(({ box }) => !box.done).map(({ issue }) => issue))];
+  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>] [-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 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;
+  if (values.title === undefined || values.title.trim() === "")
+    fail(`give the issue a title with -t
+
+${newUsage}`);
+  const body = await noteText({ file: values.file });
+  await checkLabels((values.labels ?? "").split(",").map((name) => name.trim()).filter((name) => name !== ""), 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>]... [-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.
+
+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) {
+  const parsed = parse(args, editUsage, editOptions);
+  const { values, positionals } = parsed;
+  const number = issueNumber(positionals[0], editUsage);
+  const text = await noteText({ file: values.file });
+  const added = values["add-box"] ?? [];
+  if (values.file !== undefined && text === undefined)
+    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 && 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)
+    change.body = (await getIssue(number, values.repo)).body;
+  if (text !== undefined && values.append === true)
+    change.body = `${(change.body ?? "").trimEnd()}
+
+${text}`;
+  if (added.length > 0)
+    change.body = appendBoxes(change.body ?? "", added);
+  await editIssue(number, change, values.repo);
+  console.log(`edited #${number}`);
+  return 0;
+}
+var tickUsage = `ft tick <n> <box>...
+
+Ticks checklist boxes of issue <n>, each given by its number from \`ft issue\` or by text matching exactly one box, then posts the -m or -F comment.
+With --closed, ticks instead every box opening with \`#<issue>\` whose issue is closed, as a release plan lists them.
+
+Exits 0 when it ticked the boxes, 1 when Forgejo refuses, 2 on a usage error or a box matching none or several.`;
+var tickOptions = {
+  undo: { type: "boolean", short: "u", description: "untick them instead" },
+  closed: { type: "boolean", description: "tick the boxes listing a closed issue, no box to name" },
+  ...noteOptions,
+  ...repoOption
+};
+async function tick(args) {
+  const parsed = parse(args, tickUsage, tickOptions);
+  const { values, positionals } = parsed;
+  const number = issueNumber(positionals[0], tickUsage);
+  const picks = positionals.slice(1);
+  if (values.closed === true && (picks.length > 0 || values.undo === true))
+    fail(`--closed takes no boxes and no --undo
+
+${tickUsage}`);
+  if (picks.length === 0 && values.closed !== true)
+    fail(`name the boxes to tick
+
+${tickUsage}`);
+  const note = await noteText(values);
+  const found = await getIssue(number, values.repo);
+  const done = values.undo !== true;
+  const closed = values.closed === true ? await closedReferences(found.body, values.repo) : undefined;
+  let result;
+  try {
+    result = closed === undefined ? setBoxes(found.body, picks, done) : tickReferences(found.body, (issue) => closed.has(issue));
+  } catch (error) {
+    fail(`#${number}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (result.changed.length > 0) {
+    if (closed === undefined)
+      await setBody(number, result.body, values.repo);
+    else
+      await editBody(number, (body) => tickReferences(body, (issue) => closed.has(issue)).body, values.repo);
+  }
+  for (const box of result.changed)
+    console.log(`${done ? "ticked" : "unticked"} ${box.number}: ${box.text}`);
+  const left = boxes(result.body).filter((box) => !box.done).length;
+  console.log(`#${number}: ${result.changed.length === 0 ? "nothing to change, " : ""}${left} box${left === 1 ? "" : "es"} left`);
+  if (note !== undefined) {
+    await comment(number, note, values.repo);
+    console.log(`commented on #${number}`);
+  }
+  return 0;
+}
+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.
+
+Exits 0 when it posted the comment, 1 when Forgejo refuses, 2 on a usage error.`;
+var commentOptions = {
+  file: noteOptions.file,
+  ...repoOption
+};
+async function commentOn(args) {
+  const parsed = parse(args, commentUsage, commentOptions);
+  const { values, positionals } = parsed;
+  const number = issueNumber(positionals[0], commentUsage);
+  const given = positionals.slice(1).join(" ") || undefined;
+  const text = await noteText({ message: given, file: values.file ?? (given === undefined ? "-" : undefined) });
+  if (text === undefined)
+    fail(`nothing to comment
+
+${commentUsage}`);
+  await comment(number, text, values.repo);
+  console.log(`commented on #${number}`);
+  return 0;
+}
+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.
+
+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" },
+  force: { type: "boolean", description: "close even with boxes left" },
+  ...repoOption
+};
+function joinShas(shas) {
+  const last = shas.at(-1) ?? "";
+  return shas.length < 2 ? last : `${shas.slice(0, -1).join(", ")} and ${last}`;
+}
+async function fixingCommits(number, given) {
+  if (given.length > 0) {
+    const named = [];
+    for (const ref of given) {
+      const sha = await resolveCommit(ref);
+      named.push({ sha, subject: await git(["log", "-1", "--format=%s", sha]) });
+    }
+    return named;
+  }
+  const ref = `origin/${await defaultBranch()}`;
+  const found = await commitsNaming(number, ref);
+  if (found.length > 0) {
+    console.log(`commits on ${ref} naming #${number}:
+${found.map((each) => `  ${each.sha.slice(0, 7)} ${each.subject}`).join(`
+`)}`);
+    return found;
+  }
+  const sha = await resolveCommit("HEAD");
+  console.log(`no commit on ${ref} names #${number}, using HEAD`);
+  return [{ sha, subject: await git(["log", "-1", "--format=%s", sha]) }];
+}
+async function tickListings(closed, repo) {
+  for (const listing of await openIssues(undefined, repo)) {
+    if (!referencedBoxes(listing.body).some(({ box, issue }) => issue === closed && !box.done))
+      continue;
+    if (await editBody(listing.number, (body) => tickReferences(body, (issue) => issue === closed).body, repo))
+      console.log(`ticked #${closed} in #${listing.number}`);
+  }
+}
+async function fixed(args) {
+  const parsed = parse(args, fixedUsage, fixedOptions);
+  const { values, positionals } = parsed;
+  const number = issueNumber(positionals[0], fixedUsage);
+  const commits = await fixingCommits(number, positionals.slice(1));
+  const found = await getIssue(number, values.repo);
+  if (found.state === "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:
+${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);
+  await close(number, values.repo);
+  console.log(`closed #${number}: fixed in ${shas}`);
+  await tickListings(number, values.repo);
+  return 0;
+}
+
+// src/commands/logs.ts
+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.
+
+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
+};
+function pickJobs(jobs, name) {
+  if (name !== undefined)
+    return jobs.filter((job) => job.name === name);
+  const failed = jobs.filter((job) => job.status === "failure");
+  return failed.length > 0 ? failed : jobs;
+}
+async function logs(args) {
+  const parsed = parse(args, usage3, options3);
+  const { values, positionals } = parsed;
+  if (positionals[0] === undefined)
+    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(", ")}`, 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}: ${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) {
+  return line.replaceAll(MARKUP, "").toLowerCase();
+}
+function insertionPoint(lines, body, section) {
+  const all = boxes(body);
+  if (section === undefined)
+    return all.length === 0 ? undefined : (all.at(-1)?.line ?? 0) + 1;
+  const title = heading(section);
+  const at = lines.findIndex((line) => heading(line) === title);
+  if (at === -1)
+    return;
+  const lineOfBox = new Set(all.map((box) => box.line));
+  let end = at + 1;
+  for (let next = at + 1;next < lines.length; next++) {
+    if (lineOfBox.has(next))
+      end = next + 1;
+    else if (lines[next]?.trim() !== "")
+      break;
+  }
+  return end;
+}
+function addLines(body, added, section) {
+  if (added.length === 0)
+    return body;
+  const eol = body.includes(`\r
+`) ? "\r" : "";
+  const lines = body.split(`
+`);
+  const at = insertionPoint(lines, body, section);
+  const fresh = added.map((line) => `${line}${eol}`);
+  if (at !== undefined) {
+    lines.splice(at, 0, ...fresh);
+    return lines.join(`
+`);
+  }
+  const text = body.trimEnd();
+  return `${text}${text === "" ? "" : `${eol}
+${eol}
+`}${section === undefined ? "" : `${section}${eol}
+`}${fresh.join(`
+`)}${body.endsWith(`
+`) ? `
+` : ""}`;
+}
+function listedIssues(body) {
+  return new Set(referencedBoxes(body).map(({ issue }) => issue));
+}
+function openLines(body) {
+  return referencedBoxes(body).filter(({ box }) => !box.done).map(({ box, issue }) => ({ issue, line: `- [ ] ${box.text}` }));
+}
+
+// src/commands/plan.ts
+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.
+
+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.
+
+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
+};
+var plan = {
+  summary: "add issues to a release plan's checklist, or carry its unticked lines to the next plan",
+  commands: {
+    add: { run: add, summary: "list issues in a plan's checklist" },
+    carry: { run: carry, summary: "copy a plan's unticked lines into the next plan" }
+  }
+};
+async function add(args) {
+  const parsed = parse(args, addUsage, options4);
+  const { section, repo } = parsed.values;
+  const [target, ...listed] = parsed.positionals;
+  const planNumber = issueNumber(target, addUsage);
+  if (listed.length === 0)
+    fail(`name the issues to add
+
+${addUsage}`);
+  const numbers = issueNumbers(listed, addUsage);
+  const titled = await Promise.all(numbers.map(async (number) => ({ number, title: (await getIssue(number, repo)).title })));
+  let added = [];
+  await editBody(planNumber, (body) => {
+    const known = listedIssues(body);
+    const fresh = titled.filter(({ number }) => !known.has(number));
+    added = fresh.map(({ number, title }) => `- [ ] #${number} ${title}`);
+    return addLines(body, added, section);
+  }, repo);
+  report(planNumber, added, titled.length - added.length);
+  return 0;
+}
+async function carry(args) {
+  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);
+  const source = openLines((await getIssue(from, repo)).body);
+  let added = [];
+  await editBody(to, (body) => {
+    const known = listedIssues(body);
+    added = source.filter(({ issue }) => !known.has(issue)).map(({ line }) => line);
+    return addLines(body, added, section);
+  }, repo);
+  report(to, added, source.length - added.length);
+  return 0;
+}
+function report(plan, added, skipped) {
+  for (const line of added)
+    console.log(`#${plan}: ${line}`);
+  console.log(`#${plan}: ${added.length} added${skipped === 0 ? "" : `, ${skipped} already listed`}`);
+}
+
+// src/commands/release.ts
+import { basename as basename2, join as join2, relative, resolve } from "path";
+import process13 from "process";
+var {$: $3 } = globalThis.Bun;
+
+// src/commands/watch.ts
+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 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
+};
+var timing = { poll: 1e4 };
+var LIMIT = 20;
+var STALLED2 = 3 * 60000;
+async function watchRuns(pick, timeout, repo, idle) {
+  const started = Date.now();
+  const reported = new Map;
+  let moving = started;
+  for (;; ) {
+    await Bun.sleep(timing.poll);
+    if (Date.now() - started > timeout)
+      fail(`the runs did not finish in ${formatDuration(timeout)}`);
+    let runs;
+    try {
+      runs = pick(await recentRuns(LIMIT, repo));
+    } catch (error) {
+      console.warn(`ft watch: ${error instanceof Error ? error.message : String(error)}, polling again`);
+      continue;
+    }
+    for (const run of runs) {
+      if (reported.get(run.id) !== 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) {
+      if (idle !== undefined && Date.now() - started > idle) {
+        console.log("no run started, so nothing was waited for");
+        return 0;
+      }
+      continue;
+    }
+    const status = overall(runs);
+    if (status === "failure" || status === "cancelled") {
+      for (const run of runs) {
+        if (run.status === "failure")
+          console.error(`
+${await failureReport(run, repo)}
+
+${run.html_url}`);
+      }
+      return 1;
+    }
+    if (runs.every((run) => FINISHED.has(run.status)))
+      return 0;
+    const stall = await stallReason(runs, repo);
+    if (stall === undefined)
+      moving = Date.now();
+    else if (stall.certain || Date.now() - moving > STALLED2)
+      fail(`queued runs are not moving: ${stall.reason}`);
+  }
+}
+async function watch(args) {
+  const parsed = parse(args, usage4, options5);
+  const { values } = parsed;
+  const timeout = duration(values.timeout, "timeout", 15 * 60000, "m");
+  if (values.after !== undefined) {
+    const after = wholeNumber(values.after, "after", 0, 0);
+    return watchRuns((runs) => runs.filter((run) => run.id > after), timeout, values.repo);
+  }
+  const active = new Set((await recentRuns(LIMIT, values.repo)).filter((run) => !FINISHED.has(run.status)).map((run) => run.id));
+  if (active.size === 0) {
+    console.log("no run in progress");
+    return 0;
+  }
+  return watchRuns((runs) => runs.filter((run) => active.has(run.id)), timeout, values.repo);
+}
+
+// src/commands/release.ts
+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.
+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;
+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())
+      return dir;
+  }
+  fail(`no package.json in ${value} nor in packages/${value}`);
+}
+async function commitPackageBump(dir, prefix) {
+  const { version } = await Bun.file(join2(dir, "package.json")).json();
+  const root = await git(["rev-parse", "--show-toplevel"]);
+  const tag = `${prefix}${version}`;
+  const lock = await $3`bun install --lockfile-only`.cwd(root).quiet().nothrow();
+  if (lock.exitCode !== 0)
+    fail(`bun install --lockfile-only after the bump: ${lock.stderr.toString().trim()}`);
+  await git(["add", join2(dir, "package.json"), join2(root, "bun.lock")]);
+  await git(["commit", "-q", "-m", tag]);
+  await git(["tag", "-a", tag, "-m", tag]);
+}
+async function waitForRegistry(name, version) {
+  for (let attempt = 0;attempt < REGISTRY_TRIES; attempt++) {
+    const served = (await $3`bun info ${name} version --no-cache`.quiet().nothrow().text()).trim().split(`
+`).at(-1);
+    if (served === version)
+      return true;
+    await Bun.sleep(REGISTRY_POLL);
+  }
+  return false;
+}
+async function testsPass(sha, branch, timeout) {
+  if (!await gitOk(["merge-base", "--is-ancestor", sha, `origin/${branch}`])) {
+    const push = await $3`git push origin ${`${sha}:refs/heads/${branch}`}`.quiet().nothrow();
+    if (push.exitCode !== 0)
+      fail(`origin refused the push of ${sha.slice(0, 7)}, so nothing was bumped:
+${push.stderr.toString().trim()}`, 1);
+    console.log(`pushed ${branch} at ${sha.slice(0, 7)}, waiting for its runs before the bump`);
+  }
+  return await watchRuns((runs) => newestPerWorkflow(runs.filter((run) => run.commit_sha === sha)), timeout, undefined, NO_RUN2) === 0;
+}
+async function printPlan({ level, dir, prefix, branch, base, timeout, registry }) {
+  const file = Bun.file(join2(dir ?? ".", "package.json"));
+  const pkg = await file.exists() ? await file.json() : undefined;
+  const name = pkg?.name ?? basename2(dir ?? 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, 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
+
+${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");
+  const dir = values.package === undefined ? undefined : await packageDir(values.package);
+  const prefix = dir === undefined ? "v" : `${basename2(dir)}-v`;
+  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"}`, 2, runHint(`git switch ${branch}`));
+  if (await git(["status", "--porcelain"]) !== "")
+    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`, 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`, 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)
+      fail(`bun pm version ${level}: ${bump.stderr.toString().trim() || bump.stdout.toString().trim()}`);
+    if (dir !== undefined)
+      await commitPackageBump(dir, prefix);
+  }
+  const tag = (await tagsAt("HEAD")).find((name) => taggedVersion(name, prefix) !== undefined);
+  if (tag === undefined)
+    fail(tagged ? `HEAD carries no ${prefix}* tag` : `the bump made no ${prefix}* tag`);
+  const before = (await recentRuns(1))[0]?.id ?? 0;
+  const push = await $3`git push --atomic origin ${`HEAD:refs/heads/${branch}`} ${tag}`.quiet().nothrow();
+  if (push.exitCode !== 0) {
+    await git(["tag", "-d", tag]);
+    await git(["reset", "--keep", "HEAD~1"]);
+    fail(`origin refused the push, so ${tag} and its commit were dropped for a clean retry:
+${push.stderr.toString().trim()}`, 1);
+  }
+  console.log(`pushed ${branch} and ${tag}, waiting for their runs`);
+  const code = await watchRuns((runs) => runs.filter((run) => run.id > before), timeout);
+  if (code !== 0)
+    return code;
+  const file = Bun.file(join2(dir ?? ".", "package.json"));
+  const pkg = await file.exists() ? await file.json() : undefined;
+  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)?\/?$/;
+function parseSshRemote(url) {
+  const match = SSH_URL.exec(url) ?? (url.includes("://") ? null : SCP_LIKE.exec(url));
+  return match === null ? undefined : { user: match[1] ?? "git", host: match[2] ?? "", path: match[3] ?? "" };
+}
+function canonicalRemote(url, host, reaches) {
+  const remote = parseSshRemote(url);
+  if (remote === undefined || remote.host === host || !reaches(remote.host))
+    return;
+  return `${remote.user}@${host}:${remote.path}.git`;
+}
+async function reachesHost(hostname, host, hostAddresses, addressesOf) {
+  if (hostname === undefined)
+    return false;
+  return hostname === host || (await addressesOf(hostname)).some((address) => hostAddresses.has(address));
+}
+
+// src/commands/remote.ts
+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\`.
+The host comes from --host, else \`remoteHost\` in ~/.config/ft/config.json; with neither, it checks nothing.
+
+Exits 0 when origin names the Forgejo host (or was switched) or no host is set, 1 when it does not or a switch is still to run, 2 on a usage error.`;
+var options7 = {
+  host: { type: "string", description: "the Forgejo ssh host, instead of remoteHost in ~/.config/ft/config.json" },
+  fix: { type: "boolean", description: "rewrite the alias URLs" }
+};
+var HOSTNAME = /^hostname (.+)$/m;
+async function sshHostname(alias) {
+  return HOSTNAME.exec(await $4`ssh -G ${alias}`.quiet().nothrow().text())?.[1];
+}
+async function addresses(name) {
+  try {
+    return (await lookup(name, { all: true })).map((entry) => entry.address);
+  } catch {
+    return [];
+  }
+}
+function originHost(url) {
+  return parseSshRemote(url)?.host ?? (URL.canParse(url) ? new URL(url).hostname : undefined);
+}
+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);
+  const hostAddresses = new Set(await addresses(host));
+  const hostnames = new Map;
+  const reaching = new Set;
+  for (const url of [fetchUrl, ...pushUrls]) {
+    const alias = parseSshRemote(url)?.host;
+    if (alias === undefined || hostnames.has(alias))
+      continue;
+    const hostname = await sshHostname(alias);
+    hostnames.set(alias, hostname);
+    if (await reachesHost(hostname, host, hostAddresses, addresses))
+      reaching.add(alias);
+  }
+  const changes = [fetchUrl, ...pushUrls].map((url) => [url, canonicalRemote(url, host, (alias) => reaching.has(alias))]).filter((change) => change[1] !== undefined);
+  if (changes.length === 0) {
+    const named = originHost(fetchUrl);
+    if (named === host) {
+      console.log(`origin already names ${host}: ${fetchUrl}`);
+      return 0;
+    }
+    const hostname = named === undefined ? undefined : hostnames.get(named);
+    console.log(`origin ${fetchUrl} does not reach ${host}${hostname === undefined || hostname === named ? "" : `: ssh connects ${named} to ${hostname}`}, pass --host if Forgejo lives elsewhere`);
+    return 1;
+  }
+  for (const [from, to] of changes)
+    console.log(`${from} -> ${to}`);
+  if (values.fix !== true) {
+    console.log("run `ft remote --fix` to switch them");
+    return 1;
+  }
+  const fetchChange = changes.find(([from]) => from === fetchUrl);
+  if (fetchChange !== undefined)
+    await git(["remote", "set-url", "origin", fetchChange[1]]);
+  for (const [from, to] of changes) {
+    if (pushUrls.includes(from))
+      await git(["remote", "set-url", "--push", "origin", to, from]);
+  }
+  await git(["ls-remote", "origin", "HEAD"]);
+  console.log("origin switched, and git ls-remote reaches it");
+  return 0;
+}
+
+// src/commands/runs.ts
+var usage7 = `ft runs [--sha <ref>]
+
+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_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, usage7, options8);
+  const { values } = parsed;
+  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;
+  }
+  if (list.length === 0) {
+    console.log("no run");
+    return 0;
+  }
+  console.log(table([
+    ["ID", "STATUS", "WORKFLOW", "REF", "EVENT", "TOOK", "STARTED", "TITLE"],
+    ...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
+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" },
+    watch: { run: watch, summary: "wait for runs newer than an id, or those in progress" },
+    logs: { run: logs, summary: "what the failed jobs of a run say went wrong" },
+    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" },
+    new: { run: newIssue, summary: "create an issue from -t and a description file or stdin" },
+    edit: { run: edit, summary: "replace an issue's title or description, from a file or stdin" },
+    tick: { run: tick, summary: "tick checklist boxes of an issue, -m to comment too" },
+    comment: { run: commentOn, summary: "comment on an issue, from stdin when no text is given" },
+    fixed: { run: fixed, summary: 'comment "Fixed in <sha>" and close an issue' },
+    close: { run: closeIssues, summary: "close issues without a fix, -m posting the reason" },
+    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" }
+});