@kaynooo/forgejo-tools 0.6.0 → 0.7.0

package/dist/cli.js

@@ -2,7 +2,7 @@
 // @bun
 
 // src/cli.ts
-import process14 from "process";
+import process15 from "process";
 
 // ../kit/src/args.ts
 import process4 from "process";
@@ -395,6 +395,26 @@ function printJson(value) {
   console.log(JSON.stringify(value, undefined, 2));
 }
 
+// ../kit/src/text.ts
+var ANSI = new RegExp(`${String.fromCharCode(27)}\\[[\\d;?]*[a-z]`, "gi");
+function distance(a, b) {
+  let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (const [i, left] of [...a].entries()) {
+    const current = [i + 1];
+    for (const [j, right] of [...b].entries())
+      current.push(Math.min((previous[j + 1] ?? 0) + 1, (current[j] ?? 0) + 1, (previous[j] ?? 0) + (left === right ? 0 : 1)));
+    previous = current;
+  }
+  return previous[b.length] ?? 0;
+}
+function closest(name, names) {
+  const started = names.find((known) => known.startsWith(name));
+  if (started !== undefined)
+    return started;
+  const [best] = names.map((known) => ({ known, far: distance(name, known) })).sort((a, b) => a.far - b.far);
+  return best !== undefined && best.far <= (name.length < 4 ? 1 : 2) ? best.known : undefined;
+}
+
 // ../kit/src/args.ts
 function jsonOption(holds) {
   return { type: "boolean", description: holds === undefined ? "print JSON" : `print JSON: ${holds}` };
@@ -414,8 +434,8 @@ function fail(message, code = 2, hint) {
 }
 
 class UsageError extends Exit {
-  constructor(message) {
-    super(message, 2);
+  constructor(message, hint) {
+    super(message, 2, hint);
   }
 }
 function badUsage(message) {
@@ -438,6 +458,7 @@ var completion = { active: false };
 var OPTIONAL = /\[[^\]]+\]/g;
 var USAGE_PREFIX = /^usage:\s*/i;
 var FULL_STOP = /\.$/;
+var DASHES = /^-+/;
 function usageLine(usage, colors = paint(process4.stdout)) {
   return `${colors.bold("Usage:")} ${usage.replace(USAGE_PREFIX, "").replaceAll(OPTIONAL, (part) => colors.dim(part))}`;
 }
@@ -474,10 +495,10 @@ function optionRows(options, colors = paint(process4.stdout)) {
   const rows = Object.entries(options).map(([name, option]) => {
     const short = option.short === undefined ? "    " : `${colors.cyan(`-${option.short}`)}, `;
     const value = option.type === "string" ? ` ${colors.dim("<value>")}` : "";
-    return { flag: `${short}${colors.cyan(`--${name}`)}${value}`, width: `-x, --${name}`.length + (option.type === "string" ? " <value>".length : 0), description: option.description };
+    return { flag: `${short}${colors.cyan(`--${name}`)}${value}`, width: `-x, --${name}`.length + (option.type === "string" ? " <value>".length : 0), description: option.description ?? "" };
   });
   const width = Math.max(0, ...rows.map((row) => row.width));
-  return rows.map((row) => `  ${row.flag}${" ".repeat(width - row.width)}  ${colors.dim(row.description)}`);
+  return rows.map((row) => row.description === "" ? `  ${row.flag}` : `  ${row.flag}${" ".repeat(width - row.width)}  ${colors.dim(row.description)}`);
 }
 var OUTPUT_OPTIONS = {
   color: { type: "string", description: "auto (on a terminal alone), always or never" },
@@ -509,7 +530,8 @@ function parse(args, usage, options, settings = {}) {
   try {
     parsed = parseArgs({ args: joinDashValues(own, all), options: all, allowPositionals: true, allowNegative: settings.allowNegative === true, strict: true });
   } catch (error) {
-    badUsage(parseError(error));
+    const message = parseError(error);
+    throw new UsageError(message, nearestOption(message, all, settings.allowNegative === true));
   }
   const values = parsed.values;
   applyOutput("color" in output ? values.color : undefined, "plain" in output ? values.plain : undefined);
@@ -552,12 +574,29 @@ function parseError(error) {
   const message = upTo(error instanceof Error ? error.message : String(error), ". ");
   return `${message.charAt(0).toLowerCase()}${message.slice(1)}`;
 }
+var UNKNOWN_OPTION = /^unknown option '(-[^']+)'/;
+function nearestOption(message, options, allowNegative) {
+  const typed = UNKNOWN_OPTION.exec(message)?.[1];
+  if (typed === undefined)
+    return;
+  const word = typed.replace(DASHES, "");
+  if (word.length < 2 && !typed.startsWith("--"))
+    return;
+  const known = Object.entries(options).flatMap(([name, option]) => [
+    ...option.short === undefined ? [] : [`-${option.short}`],
+    `--${name}`,
+    ...allowNegative && option.type === "boolean" ? [`--no-${name}`] : []
+  ]);
+  const meant = closest(word, known.map((flag) => flag.replace(DASHES, "")));
+  return meant === undefined ? undefined : `did you mean ${known.find((flag) => flag.replace(DASHES, "") === meant)}?`;
+}
+var WHOLE = /^\d+$/;
 function wholeNumber(value, name, fallback, min = 1) {
   if (value === undefined)
     return fallback;
   const number = Number(value);
-  if (!Number.isInteger(number) || number < min)
-    badUsage(`--${name} takes a whole number from ${min}, not ${value}`);
+  if (!WHOLE.test(value) || !Number.isSafeInteger(number) || number < min)
+    badUsage(`${name.startsWith("<") ? name : `--${name}`} takes a whole number from ${min}, not ${value}`);
   return number;
 }
 var DURATION = /^(\d+(?:\.\d+)?)(ms|[smh])?$/;
@@ -582,35 +621,363 @@ async function readInput(path, { noStdin = "nothing is piped on stdin" } = {}) {
     fail(`no file ${path}`);
   return file.text();
 }
-// ../kit/src/cli.ts
+// ../kit/src/progress.ts
+import process6 from "process";
+
+// ../kit/src/process.ts
+import { constants } from "os";
 import process5 from "process";
+var KILL_GRACE_MS = 2000;
+var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+function exitCodeOf(code, signal) {
+  if (code !== null)
+    return code;
+  if (typeof signal === "number")
+    return 128 + signal;
+  return signal === null ? 129 : 128 + constants.signals[signal];
+}
+function holdSignals(cleanup) {
+  let received;
+  let child;
+  const held = {
+    get signal() {
+      return received;
+    },
+    forward: (to) => {
+      child = to;
+    },
+    release: () => {
+      for (const signal of SIGNALS)
+        process5.off(signal, onSignal);
+    }
+  };
+  function onSignal(signal) {
+    received = signal;
+    if (child !== undefined) {
+      child.kill(signal);
+      return;
+    }
+    if (cleanup === undefined)
+      return;
+    held.release();
+    cleanup(signal);
+    process5.kill(process5.pid, signal);
+  }
+  for (const signal of SIGNALS)
+    process5.on(signal, onSignal);
+  return held;
+}
+async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal, maxBytes = Infinity, onChunk, onStart } = {}) {
+  const chunks = [];
+  const grouped = timeoutMs !== undefined || signal !== undefined || onStart !== undefined || onChunk !== undefined;
+  const proc = Bun.spawn(argv, { ...cwd === undefined ? {} : { cwd }, ...env === undefined ? {} : { env }, stdin, stdout: "pipe", stderr: "pipe", ...grouped ? { detached: true } : {} });
+  const state = { kept: 0, truncated: false, timedOut: false, failure: undefined, done: false };
+  const timers = [];
+  const killGroup = (killing) => {
+    if (state.done)
+      return;
+    try {
+      if (grouped)
+        process5.kill(-proc.pid, killing);
+      else
+        proc.kill(killing);
+    } catch {}
+  };
+  const stop = () => {
+    killGroup("SIGTERM");
+    timers.push(setTimeout(killGroup, KILL_GRACE_MS, "SIGKILL"));
+  };
+  const onAbort = () => stop();
+  if (timeoutMs !== undefined) {
+    timers.push(setTimeout(() => {
+      state.timedOut = true;
+      stop();
+    }, timeoutMs));
+  }
+  if (signal?.aborted === true)
+    onAbort();
+  else
+    signal?.addEventListener("abort", onAbort, { once: true });
+  onStart?.({ kill: (killing) => killGroup(killing) });
+  const drain = async (stream, name) => {
+    for await (const data of stream) {
+      if (state.failure !== undefined)
+        continue;
+      try {
+        onChunk?.({ stream: name, data });
+      } catch (error) {
+        state.failure = error;
+        stop();
+        continue;
+      }
+      if (state.kept + data.length > maxBytes) {
+        state.truncated = true;
+        continue;
+      }
+      state.kept += data.length;
+      chunks.push({ stream: name, data });
+    }
+  };
+  try {
+    await Promise.all([drain(proc.stdout, "stdout"), drain(proc.stderr, "stderr")]);
+    await proc.exited;
+  } finally {
+    state.done = true;
+    for (const timer of timers)
+      clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+  }
+  if (state.failure !== undefined)
+    throw state.failure;
+  const joined = () => Buffer.concat(chunks.map(({ data }) => data));
+  let output;
+  let text;
+  return {
+    code: exitCodeOf(proc.exitCode, proc.signalCode),
+    chunks,
+    timedOut: state.timedOut,
+    truncated: state.truncated,
+    get output() {
+      return output ??= joined();
+    },
+    get text() {
+      return text ??= (output ??= joined()).toString();
+    }
+  };
+}
 
-// ../kit/src/text.ts
-var ANSI = new RegExp(`${String.fromCharCode(27)}\\[[\\d;?]*[a-z]`, "gi");
-function distance(a, b) {
-  let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
-  for (const [i, left] of [...a].entries()) {
-    const current = [i + 1];
-    for (const [j, right] of [...b].entries())
-      current.push(Math.min((previous[j + 1] ?? 0) + 1, (current[j] ?? 0) + 1, (previous[j] ?? 0) + (left === right ? 0 : 1)));
-    previous = current;
+// ../kit/src/progress.ts
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var FRAME_MS = 80;
+var CLEAR_LINE = "\r\x1B[2K";
+var LINE_UP = "\x1B[1A\x1B[2K";
+var ESC = String.fromCharCode(27);
+var ESCAPE_CODE = new RegExp(`${ESC}(?:\\[[\\x30-\\x3F]*[\\x20-\\x2F]*[\\x40-\\x7E]|\\][^\\u0007${ESC}]*(?:\\u0007|${ESC}\\\\))`, "y");
+var RESET_STYLE = `${ESC}[0m`;
+var CLOSE_LINK = `${ESC}]8;;${ESC}\\`;
+var CONSOLE_METHODS = ["log", "info", "warn", "error", "debug", "dir", "dirxml", "table", "trace", "group", "groupCollapsed", "count", "timeEnd", "timeLog", "assert"];
+function liveRegion(render, stream = process6.stderr, env = process6.env) {
+  if (!takesControlCodes(stream, env))
+    return { redraw: () => {
+      return;
+    }, print: (text) => void stream.write(`${text}
+`), stop: () => {
+      return;
+    } };
+  const write = stream.write.bind(stream);
+  let frame = 0;
+  let drawn = 0;
+  const clear = () => {
+    if (drawn > 0)
+      write(`${CLEAR_LINE}${LINE_UP.repeat(drawn - 1)}`);
+    drawn = 0;
+  };
+  const draw = () => {
+    const width = (stream.columns === undefined || stream.columns === 0 ? 80 : stream.columns) - 1;
+    const height = stream.rows === undefined || stream.rows === 0 ? 24 : stream.rows;
+    const lines = render(FRAMES[frame++ % FRAMES.length]).slice(0, Math.max(1, height - 1)).map((line) => cutToWidth(line, width));
+    if (lines.length === 0) {
+      clear();
+      return;
+    }
+    write(`${drawn > 0 ? `${CLEAR_LINE}${LINE_UP.repeat(drawn - 1)}` : CLEAR_LINE}${lines.join(`
+`)}`);
+    drawn = lines.length;
+  };
+  const timer = setInterval(draw, FRAME_MS);
+  const restore = interceptOutput(clear);
+  const onExit = () => clear();
+  const signals = holdSignals(stop);
+  function stop() {
+    clearInterval(timer);
+    clear();
+    restore();
+    process6.off("exit", onExit);
+    signals.release();
+  }
+  timer.unref();
+  process6.on("exit", onExit);
+  return {
+    redraw: draw,
+    print: (text) => {
+      clear();
+      write(`${text}
+`);
+      draw();
+    },
+    stop
+  };
+}
+function cutToWidth(line, width) {
+  if (Bun.stringWidth(line) <= width)
+    return line;
+  let room = width;
+  let kept = "";
+  let index = 0;
+  let linked = false;
+  while (index < line.length) {
+    ESCAPE_CODE.lastIndex = index;
+    const escape = ESCAPE_CODE.exec(line);
+    if (escape !== null) {
+      kept += escape[0];
+      linked ||= escape[0].startsWith(`${ESC}]`);
+      index = ESCAPE_CODE.lastIndex;
+      continue;
+    }
+    const char = String.fromCodePoint(line.codePointAt(index));
+    const columns = Bun.stringWidth(char);
+    if (columns > room)
+      break;
+    kept += char;
+    room -= columns;
+    index += char.length;
+  }
+  return `${kept}${RESET_STYLE}${linked ? CLOSE_LINK : ""}`;
+}
+function interceptOutput(clear) {
+  const targets = [...CONSOLE_METHODS.map((name) => [console, name]), [process6.stdout, "write"], [process6.stderr, "write"]];
+  const wrapped = targets.map(([target, name]) => {
+    const original = Reflect.get(target, name);
+    const wrapper = (...args) => {
+      clear();
+      return original.apply(target, args);
+    };
+    Reflect.set(target, name, wrapper);
+    return { target, name, original, wrapper };
+  });
+  return () => {
+    for (const { target, name, original, wrapper } of wrapped) {
+      if (Reflect.get(target, name) === wrapper)
+        Reflect.set(target, name, original);
+    }
+  };
+}
+
+// ../kit/src/tool.ts
+import process7 from "process";
+var PERMANENT = /\bHTTP (?:401|403|404)\b|unauthorized|forbidden|not found|couldn't be found|token is required/i;
+function cwdGone() {
+  try {
+    process7.cwd();
+    return false;
+  } catch {
+    return true;
   }
-  return previous[b.length] ?? 0;
 }
 
+class SpawnError extends Error {
+  missing;
+  constructor(message, missing) {
+    super(message);
+    this.missing = missing;
+  }
+}
+function spawnFailure(command, error) {
+  const gone = cwdGone();
+  const missing = !gone && error?.code === "ENOENT";
+  return new SpawnError(`${command}: ${error instanceof Error ? error.message : String(error)}${gone ? " (the working directory was removed)" : ""}`, missing);
+}
+function isPermanentFailure(error) {
+  if (!(error instanceof Error))
+    return false;
+  return error instanceof SpawnError && error.missing || PERMANENT.test(error.message);
+}
+async function runTool(label, argv, { timeoutMs, cwd, onStart } = {}) {
+  let ran;
+  try {
+    ran = await runCommand(argv, { env: process7.env, ...timeoutMs === undefined ? {} : { timeoutMs }, ...cwd === undefined ? {} : { cwd }, ...onStart === undefined ? {} : { onStart } });
+  } catch (error) {
+    throw spawnFailure(label, error);
+  }
+  if (ran.timedOut)
+    throw new Error(`${label}: no answer in ${formatDuration(timeoutMs ?? 0)}`);
+  const decoder = new TextDecoder;
+  const streams = { stdout: "", stderr: "" };
+  for (const { stream, data } of ran.chunks)
+    streams[stream] += decoder.decode(data, { stream: true });
+  return { code: ran.code, ...streams };
+}
+
+// ../kit/src/ci.ts
+var POLL = 15000;
+async function waitForCi(wait) {
+  const { tool, short, giveUpMs, noneMs, stalledMs, pollMs = POLL } = wait;
+  const started = Date.now();
+  let seen = started;
+  let moving = started;
+  let followed = "";
+  let found;
+  const region = wait.lines === undefined ? undefined : liveRegion((spinner) => wait.lines?.(spinner, found, started) ?? []);
+  const suffix = () => found === undefined ? "" : `: ${wait.links(found)}`;
+  async function stallOf(current) {
+    try {
+      return await wait.stall?.(current);
+    } catch (error) {
+      if (error instanceof Exit || isPermanentFailure(error))
+        throw error;
+      console.warn(`${tool}: ${error instanceof Error ? error.message : String(error)}, polling again`);
+      return "unknown";
+    }
+  }
+  try {
+    for (;; ) {
+      if (Date.now() - started > giveUpMs)
+        fail(`CI has not finished on ${short} in ${formatDuration(giveUpMs)}${suffix()}`);
+      try {
+        found = await wait.covering();
+      } catch (error) {
+        if (error instanceof Exit)
+          throw error;
+        if (cwdGone())
+          fail(`the working directory was removed while waiting for CI on ${short}${suffix()}`);
+        if (isPermanentFailure(error))
+          fail(error instanceof Error ? error.message : String(error));
+        console.warn(`${tool}: ${error instanceof Error ? error.message : String(error)}, polling again`);
+        const latest = found === undefined ? undefined : await wait.settle(found);
+        if (latest !== undefined)
+          return latest;
+        await Bun.sleep(pollMs);
+        continue;
+      }
+      if (found !== undefined) {
+        seen = Date.now();
+        const key = wait.key(found);
+        if (key !== followed) {
+          followed = key;
+          moving = Date.now();
+          wait.announce(found);
+        }
+        if (wait.finished(found))
+          return found;
+        const stall = await stallOf(found);
+        if (stall === undefined)
+          moving = Date.now();
+        else if (stall !== "unknown" && (stall.certain === true || Date.now() - moving > stalledMs))
+          fail(stall.message);
+      } else if (Date.now() - seen > noneMs) {
+        fail(wait.noneMessage);
+      }
+      await Bun.sleep(pollMs);
+    }
+  } finally {
+    region?.stop();
+  }
+}
 // ../kit/src/cli.ts
+import process8 from "process";
 var LEVEL_OPTIONS = {
   ...OUTPUT_OPTIONS,
   help: { type: "boolean", short: "h", description: "show this help" }
 };
 var TOP_OPTIONS = { ...LEVEL_OPTIONS, version: { type: "boolean", short: "v", description: "print the version" } };
-function commandRows(commands, colors) {
+async 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 summaries = await Promise.all(Object.values(commands).map(async ({ summary }) => resolveSummary(summary)));
+  for (const [index, [name, { group }]] of Object.entries(commands).entries()) {
     const heading = group === undefined ? "Commands:" : `${group}:`;
     const rows = groups.get(heading) ?? [];
-    rows.push(`  ${colors.cyan(name.padEnd(width))}  ${colors.dim(summary)}`);
+    rows.push(`  ${colors.cyan(name.padEnd(width))}  ${colors.dim(summaries[index])}`);
     groups.set(heading, rows);
   }
   return [...groups].filter(([, rows]) => rows.length > 0).flatMap(([heading, rows], index) => [...index === 0 ? [] : [""], colors.bold(heading), ...rows]);
@@ -630,28 +997,38 @@ function takeOutputFlags(argv) {
   }
   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 resolveSummary(summary) {
+  return typeof summary === "string" ? summary : summary();
+}
+function scopeOf(commands, extra, aliases) {
+  return { commands: typeof commands === "function" ? {} : commands, lazy: [...typeof commands === "function" ? [commands] : [], ...extra === undefined ? [] : [extra]], aliases };
+}
+async function expand(scope, words) {
+  if (scope.lazy.length === 0)
+    return scope;
+  const commands = { ...scope.commands };
+  for (const added of await Promise.all(scope.lazy.map(async (lazy) => lazy(words)))) {
+    for (const [name, command] of Object.entries(added))
+      commands[name] ??= command;
+  }
+  return { ...scope, commands, lazy: [] };
 }
-async function help({ path, header, summary, commands, defaultCommand, examples, replaces }, stream) {
+async function help({ path, header, summary: lazySummary, commands, defaultCommand, examples, replaces }, stream) {
   const colors = paint(stream);
   const prefix = path.join(" ");
+  const summary = await resolveSummary(lazySummary);
   if (wantsHelpJson())
     return JSON.stringify(description(`${prefix} <command> [options]: ${summary}`, { examples, replaces }));
   const fallback = defaultCommand === undefined ? undefined : commands[defaultCommand];
   const options = fallback !== undefined && "run" in fallback ? await optionsOf(fallback.run) : undefined;
   const own = Object.entries(options ?? {}).filter(([name]) => !(name in TOP_OPTIONS));
   return [
-    header(colors),
+    header(colors, summary),
     "",
     usageLine(`${prefix} ${defaultCommand === undefined ? colors.cyan("<command>") : `[${colors.cyan("<command>")}]`} [options]`, colors),
     ...replacesRows(replaces, colors),
     "",
-    ...commandRows(commands, colors),
+    ...await commandRows(commands, colors),
     ...own.length === 0 ? [] : ["", `${colors.bold(`Options of ${defaultCommand}:`)} ${colors.dim("the command run when none is named")}`, ...optionRows(Object.fromEntries(own), colors)],
     "",
     colors.bold("Options:"),
@@ -663,8 +1040,8 @@ async function help({ path, header, summary, commands, defaultCommand, examples,
 `);
 }
 function printError(prefix, message, hint, cause) {
-  const colors = paint(process5.stderr);
-  const styled = takesControlCodes(process5.stderr);
+  const colors = paint(process8.stderr);
+  const styled = takesControlCodes(process8.stderr);
   const head = styled ? `${colors.red.bold("error")} ${colors.dim(`${prefix}:`)}` : `error: ${prefix}:`;
   const under = (label, text, tint) => text === undefined ? "" : `
   ${styled ? tint(label) : `${label}:`} ${text}`;
@@ -674,8 +1051,8 @@ 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}`);
+  const colors = paint(process8.stderr);
+  console.error(`  ${takesControlCodes(process8.stderr) ? colors.yellow("hint") : "hint:"} ${hint}`);
 }
 function printJsonError(message, hint, cause) {
   console.error(JSON.stringify({ error: message, ...hint === undefined ? {} : { hint }, ...cause === undefined ? {} : { cause } }));
@@ -704,11 +1081,11 @@ async function dispatch(level, typed, { version, redact }) {
   }
   const [name, ...args] = argv;
   if (name === undefined && level.path.length > 1) {
-    console.error(await help(level, process5.stderr));
+    console.error(await help(await expand(level, [...level.path.slice(1), ...argv]), process8.stderr));
     return 2;
   }
   if (name === undefined || name === "help" || name === "--help" || name === "-h") {
-    console.log(await help(level, process5.stdout));
+    console.log(await help(await expand(level, [...level.path.slice(1), ...argv]), process8.stdout));
     return 0;
   }
   if (level.path.length === 1 && (name === "--version" || name === "-v")) {
@@ -717,6 +1094,10 @@ async function dispatch(level, typed, { version, redact }) {
   }
   let command = level.commands[level.aliases?.[name] ?? name];
   let rest = args;
+  if (command === undefined && level.lazy.length > 0) {
+    level = await expand(level, [...level.path.slice(1), ...argv]);
+    command = level.commands[level.aliases?.[name] ?? name];
+  }
   if (command === undefined && level.defaultCommand !== undefined) {
     command = level.commands[level.defaultCommand];
     rest = argv;
@@ -728,7 +1109,7 @@ async function dispatch(level, typed, { version, redact }) {
   }
   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 });
+    return dispatch({ path: [...level.path, name], header: (colors, text) => `${colors.bold(`${prefix} ${name}`)}  ${text}`, summary, ...scopeOf(command.commands, command.extraCommands, command.aliases), defaultCommand: undefined, examples: command.examples, replaces: undefined }, rest, { version, redact });
   }
   try {
     return await command.run(rest);
@@ -753,28 +1134,68 @@ async function optionsOf(run) {
 async function leafCandidates(run, words) {
   if (!(words.at(-1) ?? "").startsWith("-"))
     return [FILES];
-  return Object.entries(await optionsOf(run)).map(([name, option]) => `--${name}	${option.description}`);
+  return Object.entries(await optionsOf(run)).map(([name, option]) => option.description === undefined ? `--${name}` : `--${name}	${option.description}`);
 }
-async function candidates(commands, aliases, defaultCommand, words) {
+async function candidates(scope, defaultCommand, words, before = []) {
   const [word = "", ...rest] = words;
-  const command = commands[aliases?.[word] ?? word];
-  if (rest.length === 0 && !word.startsWith("-"))
-    return Object.entries(commands).map(([name, { summary }]) => `${name}	${summary}`);
+  const listing = rest.length === 0 && !word.startsWith("-");
+  let { commands, aliases } = scope;
+  let command = commands[aliases?.[word] ?? word];
+  if (listing || command === undefined) {
+    ({ commands, aliases } = await expand(scope, [...before, ...words]));
+    command = commands[aliases?.[word] ?? word];
+  }
+  if (listing)
+    return Promise.all(Object.entries(commands).map(async ([name, { summary }]) => `${name}	${await resolveSummary(summary)}`));
   if (command === undefined) {
     const fallback = defaultCommand === undefined ? undefined : commands[defaultCommand];
     return fallback !== undefined && "run" in fallback ? leafCandidates(fallback.run, words) : [];
   }
-  return "commands" in command ? candidates(command.commands, command.aliases, undefined, rest) : leafCandidates(command.run, rest);
+  return "commands" in command ? candidates(scopeOf(command.commands, command.extraCommands, command.aliases), undefined, rest, [...before, word]) : leafCandidates(command.run, rest);
 }
 async function printCandidates(found) {
   for (const line of await found)
     console.log(line);
   return 0;
 }
-async function runCli(cli, argv = process5.argv.slice(2)) {
+async function runCli(cli, argv = process8.argv.slice(2)) {
   if (argv[0] === COMPLETE)
-    return printCandidates(candidates(cli.commands, cli.aliases, cli.defaultCommand, argv.slice(1)));
-  return dispatch({ path: [cli.name], header: (colors) => `${colors.bold(cli.name)} ${colors.dim(cli.version)}  ${cli.about}`, 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 });
+    return printCandidates(candidates(scopeOf(cli.commands, cli.extraCommands, cli.aliases), cli.defaultCommand, argv.slice(1)));
+  return dispatch({ path: [cli.name], header: (colors, about) => `${colors.bold(cli.name)} ${colors.dim(cli.version)}  ${about}`, summary: cli.about, ...scopeOf(cli.commands, cli.extraCommands, cli.aliases), defaultCommand: cli.defaultCommand, examples: cli.examples, replaces: cli.replaces }, argv, { version: cli.version, redact: cli.redact });
+}
+// ../kit/src/git.ts
+import { basename, dirname } from "path";
+import process9 from "process";
+var ORIGIN_PREFIX = /^origin\//;
+var GIT_NETWORK_MS = 60000;
+async function git(args, timeoutMs) {
+  const result = await runTool(`git ${args.join(" ")}`, ["git", ...args], { timeoutMs });
+  if (result.code !== 0)
+    throw new Error(`git ${args.join(" ")}: ${result.stderr.trim() || `exit ${result.code}`}${cwdGone() ? " (the working directory was removed)" : ""}`);
+  return result.stdout.trim();
+}
+async function gitOk(args) {
+  return (await runTool(`git ${args.join(" ")}`, ["git", ...args])).code === 0;
+}
+async function resolveCommit(ref) {
+  const sha = (await runTool("git rev-parse", ["git", "rev-parse", "--verify", "-q", "--end-of-options", `${ref}^{commit}`])).stdout.trim();
+  if (sha === "")
+    fail(`no commit ${ref}`);
+  return sha;
+}
+async function fetchBranch(branch) {
+  if (branch.startsWith("-") || !await gitOk(["check-ref-format", "--branch", branch]))
+    fail(`${branch} is not a branch name`);
+  await git(["fetch", "-q", "origin", `refs/heads/${branch}`], GIT_NETWORK_MS);
+}
+async function defaultBranch() {
+  const head = (await runTool("git symbolic-ref", ["git", "symbolic-ref", "--short", "-q", "refs/remotes/origin/HEAD"])).stdout.trim();
+  return head === "" ? "main" : head.replace(ORIGIN_PREFIX, "");
+}
+async function leaveWorktree() {
+  const common = await git(["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  if (basename(common) === ".git")
+    process9.chdir(dirname(common));
 }
 // ../kit/src/limit.ts
 function limitOptions(fallback) {
@@ -797,62 +1218,12 @@ 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() };
-}
+// ../kit/src/logs.ts
+var DAY_MS = 24 * 60 * 60 * 1000;
+// ../kit/src/secrets.ts
+var SECRET_WORDS = new Set(["key", "pass", "pwd", "auth", "salt", "cookie", "session", "jwt", "ssn", "iban", "card", "cvv", "otp"]);
 // package.json
-var version = "0.6.0";
+var version = "0.7.0";
 
 // src/args.ts
 var repoOption = {
@@ -864,27 +1235,41 @@ function issueNumber(value, usage) {
     fail(`an issue number is needed
 
 ${usage}`);
-  return wholeNumber(value.replace(ISSUE_HASH, ""), "issue", 0);
+  return wholeNumber(value.replace(ISSUE_HASH, ""), "<issue>", 0);
 }
 function issueNumbers(values, usage) {
   return values.length === 0 ? [issueNumber(undefined, usage)] : values.map((value) => issueNumber(value, usage));
 }
 
 // src/checklist.ts
-var BOX = /^(\s*[-*+] \[)([ x])(\]\s)(.*)\r?$/i;
-var FENCE = /^\s*(?:```|~~~)/;
+var BOX = /^(\s*[-*+] \[)([ x])(\]\s)(.*?)\r?$/is;
+var FENCE = /^\s*(`{3,}|~{3,})/;
+var LIST_ITEM = /^\s*(?:[-*+]|\d+[.)])\s/;
+var INDENT_CODE = /^(?: {4}|\t)/;
 function boxes(body) {
   const found = [];
-  let fenced = false;
+  let fence;
+  let inList = false;
   for (const [line, text] of body.split(`
 `).entries()) {
-    if (FENCE.test(text)) {
-      fenced = !fenced;
+    const marker = FENCE.exec(text)?.[1];
+    if (fence !== undefined) {
+      if (marker?.startsWith(fence[0] ?? "") === true && marker.length >= fence.length && text.trim() === marker)
+        fence = undefined;
       continue;
     }
-    const match = fenced ? null : BOX.exec(text);
+    if (marker !== undefined) {
+      fence = marker;
+      continue;
+    }
+    const blank = text.trim() === "";
+    const match = INDENT_CODE.test(text) && !inList ? null : BOX.exec(text);
     if (match !== null)
       found.push({ number: found.length + 1, line, done: match[2] !== " ", text: match[4] ?? "" });
+    if (LIST_ITEM.test(text))
+      inList = true;
+    else if (!blank && !text.startsWith(" ") && !text.startsWith("\t"))
+      inList = false;
   }
   return found;
 }
@@ -917,13 +1302,17 @@ function numberedBody(body) {
   return lines.join(`
 `).trim();
 }
+var NUMBERED_PICK = /^(\d+):(.+)$/s;
+var WHOLE_PICK = /^\d+$/;
 function setBoxes(body, picks, done) {
   const all = boxes(body);
   const chosen = new Map;
   for (const pick of picks) {
-    const number = Number(pick);
-    const needle = pick.toLowerCase();
-    const matches = Number.isInteger(number) && String(number) === pick ? all.filter((box) => box.number === number) : all.filter((box) => box.text.toLowerCase().includes(needle));
+    if (pick.trim() === "")
+      throw new Error("an empty box pick matches every box");
+    const guarded = NUMBERED_PICK.exec(pick);
+    const needle = (guarded?.[2] ?? pick).trim().toLowerCase();
+    const matches = guarded === null && !WHOLE_PICK.test(pick) ? all.filter((box) => box.text.toLowerCase().includes(needle)) : all.filter((box) => box.number === Number(guarded?.[1] ?? pick) && (guarded === null || box.text.toLowerCase().startsWith(needle)));
     if (matches.length === 0)
       throw new Error(`no box matches ${pick}`);
     if (matches.length > 1)
@@ -961,8 +1350,8 @@ function tickReferences(body, wanted) {
 }
 
 // src/claims.ts
-var TAKEN = /^\s*taken by session ([\w.@:-]+?)\.?\s*$/im;
-var RELEASED = /^\s*released by session ([\w.@:-]+?)\.?\s*$/im;
+var TAKEN = /^\s*taken by session ([\w.@:-]+?)\.?\s*$/i;
+var RELEASED = /^\s*released by session ([\w.@:-]+?)\.?\s*$/i;
 var LANE = /^lane-([^-]+)-/;
 function takenComment(name) {
   return `Taken by session ${name}.`;
@@ -970,9 +1359,12 @@ function takenComment(name) {
 function releasedComment(name) {
   return `Released by session ${name}.`;
 }
-function latestClaim(comments) {
+function isClaimant(comment, author) {
+  return author === undefined || comment.user === undefined || comment.user.login === author;
+}
+function latestClaim(comments, author) {
   let claim;
-  for (const comment of [...comments].sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at))) {
+  for (const comment of comments.filter((each) => isClaimant(each, author)).sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at))) {
     const taken = TAKEN.exec(comment.body)?.[1];
     if (taken !== undefined) {
       claim = { holder: taken, at: comment.created_at };
@@ -992,87 +1384,22 @@ function latestNote(comments) {
 }
 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));
+  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 TEA_MS = 60000;
 function repoFlag(repo) {
   return repo === undefined ? [] : ["--repo", repo];
 }
 async function request(path, repo) {
-  let result;
-  try {
-    result = await $2`tea api ${repoFlag(repo)} ${path}`.quiet().nothrow();
-  } catch (error) {
-    throw spawnFailure(`tea api ${path}`, error);
-  }
-  if (result.exitCode !== 0)
-    throw new Error(`tea api ${path}: ${result.stderr.toString().trim() || `exit ${result.exitCode}`}`);
-  return result.stdout.toString();
+  const result = await runTool(`tea api ${path}`, ["tea", "api", ...repoFlag(repo), path], { timeoutMs: TEA_MS });
+  if (result.code !== 0)
+    throw new Error(`tea api ${path}: ${result.stderr.trim() || `exit ${result.code}`}`);
+  return result.stdout;
 }
 function parseJson(path, text) {
   let value;
@@ -1082,10 +1409,16 @@ function parseJson(path, text) {
     throw new Error(`tea api ${path}: ${upTo(text.trim(), `
 `) || "empty answer"}`);
   }
-  if (value !== null && typeof value === "object" && !Array.isArray(value) && "message" in value && typeof value.message === "string" && "url" in value)
-    throw new Error(`tea api ${path}: ${value.message}`);
+  const failure = apiError(value);
+  if (failure !== undefined)
+    throw new Error(`tea api ${path}: ${failure}`);
   return value;
 }
+function apiError(value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value) && "message" in value && typeof value.message === "string" && "url" in value)
+    return value.message;
+  return;
+}
 async function api(path, repo) {
   return parseJson(path, await request(path, repo));
 }
@@ -1095,29 +1428,30 @@ async function repoApi(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());
+  const result = await runTool(`tea api ${full}`, ["tea", "api", ...repoFlag(repo), "-X", method, ...flags, full], { timeoutMs: TEA_MS });
+  if (result.code !== 0)
+    throw new Error(`tea api ${full}: ${result.stderr.trim() || `exit ${result.code}`}`);
+  return parseJson(full, result.stdout);
 }
 async function repoApiText(path, repo) {
-  return request(`repos/{owner}/{repo}/${path}`, repo);
-}
-async function tea(args, repo) {
-  let result;
+  const full = `repos/{owner}/{repo}/${path}`;
+  const text = await request(full, repo);
+  let value;
   try {
-    result = await $2`tea ${args} ${repoFlag(repo)}`.quiet().nothrow();
-  } catch (error) {
-    throw spawnFailure(`tea ${args[0] ?? ""}`, error);
+    value = JSON.parse(text);
+  } catch {
+    return text;
   }
-  if (result.exitCode !== 0)
-    throw new Error(`tea ${args[0] ?? ""}: ${result.stderr.toString().trim() || result.stdout.toString().trim() || `exit ${result.exitCode}`}`);
-  return result.stdout.toString();
+  const failure = apiError(value);
+  if (failure !== undefined)
+    throw new Error(`tea api ${full}: ${failure}`);
+  return text;
+}
+async function tea(command, args, repo) {
+  const result = await runTool(`tea ${command.join(" ")}`, ["tea", ...command, ...repoFlag(repo), ...args], { timeoutMs: TEA_MS });
+  if (result.code !== 0)
+    throw new Error(`tea ${command.join(" ")}: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`}`);
+  return result.stdout;
 }
 
 // src/issues.ts
@@ -1155,46 +1489,75 @@ async function commentsOfAll(issues, repo) {
   return result;
 }
 async function editIssue(number, change, repo) {
-  const args = ["issues", "edit", String(number)];
+  const args = [String(number)];
   if (change.title !== undefined)
     args.push("-t", change.title);
   if (change.body !== undefined)
     args.push("-d", change.body);
   if (change.milestone !== undefined)
     args.push("-m", change.milestone);
-  await tea(args, repo);
+  await tea(["issues", "edit"], 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];
+  const args = ["-t", title, "-d", body];
+  const same = (found) => found.title === title && sameText(found.body, body);
+  const known = new Set((await openIssues(undefined, repo)).filter(same).map((found) => found.number));
   if (labels !== undefined)
     args.push("-L", labels);
   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)
+  await tea(["issues", "create"], args, repo);
+  const created = (await openIssues(undefined, repo)).filter((found) => same(found) && !known.has(found.number));
+  if (created.length > 1)
+    throw new Error(`created "${title}" but ${created.map((found) => `#${found.number}`).join(" and ")} both match: another session created the same issue at once`);
+  if (created[0] === undefined)
     throw new Error(`created "${title}" but cannot find it among the open issues`);
-  return created;
+  return created[0];
+}
+function sameText(a, b) {
+  return a.replaceAll(`\r
+`, `
+`).trimEnd() === b.replaceAll(`\r
+`, `
+`).trimEnd();
 }
+var EDIT_TRIES = 3;
 async function editBody(number, change, repo) {
-  const { body } = await getIssue(number, repo);
-  const next = change(body);
-  if (next === body)
-    return false;
-  await setBody(number, next, repo);
-  return true;
+  let wrote = false;
+  for (let attempt = 0;attempt < EDIT_TRIES; attempt++) {
+    const { body } = await getIssue(number, repo);
+    const next = change(body);
+    if (next === body)
+      return wrote;
+    await setBody(number, next, repo);
+    wrote = true;
+    if (sameText((await getIssue(number, repo)).body, next))
+      return true;
+  }
+  throw new Error(`#${number}: its description keeps changing under the edit, so it was not written reliably`);
+}
+var login;
+async function sessionAuthor() {
+  if (login !== undefined)
+    return login;
+  try {
+    login = (await api("user")).login;
+  } catch {
+    return;
+  }
+  return login;
 }
 async function comment(number, body, repo) {
-  await tea(["comment", String(number), body], repo);
+  await repoWrite("POST", `issues/${number}/comments`, { body }, repo);
 }
 async function close(number, repo) {
-  await tea(["issues", "close", String(number)], repo);
+  await tea(["issues", "close"], [String(number)], repo);
 }
 async function reopen(number, repo) {
-  await tea(["issues", "reopen", String(number)], repo);
+  await tea(["issues", "reopen"], [String(number)], repo);
 }
 async function repoLabels(repo) {
   const names = [];
@@ -1206,12 +1569,12 @@ async function repoLabels(repo) {
   }
 }
 async function editLabels(number, add, remove, repo) {
-  const args = ["issues", "edit", String(number)];
+  const args = [String(number)];
   if (add.length > 0)
     args.push("--add-labels", add.join(","));
   if (remove.length > 0)
     args.push("--remove-labels", remove.join(","));
-  await tea(args, repo);
+  await tea(["issues", "edit"], args, repo);
 }
 
 // src/milestones.ts
@@ -1265,15 +1628,15 @@ async function closeMilestone(id, repo) {
 // src/sessions.ts
 import { homedir } from "os";
 import { join } from "path";
-import process9 from "process";
+import process11 from "process";
 var {Glob } = globalThis.Bun;
 var SESSION_FILES = new Glob("*.json");
 var ACCOUNT_DIRS = new Glob("*/sessions");
 async function sessionDirs() {
   const home = homedir();
   const dirs = new Set([join(home, ".claude", "sessions")]);
-  if (process9.env.CLAUDE_CONFIG_DIR !== undefined)
-    dirs.add(join(process9.env.CLAUDE_CONFIG_DIR, "sessions"));
+  if (process11.env.CLAUDE_CONFIG_DIR !== undefined)
+    dirs.add(join(process11.env.CLAUDE_CONFIG_DIR, "sessions"));
   try {
     for await (const dir of ACCOUNT_DIRS.scan({ cwd: join(home, ".claude-accounts"), onlyFiles: false, absolute: true }))
       dirs.add(dir);
@@ -1319,7 +1682,7 @@ async function liveSessions() {
 }
 async function currentSession(sessions) {
   const byPid = new Map(sessions.map((session) => [session.pid, session]));
-  let pid = process9.ppid;
+  let pid = process11.ppid;
   for (let depth = 0;depth < 32 && pid > 1; depth++) {
     const session = byPid.get(pid);
     if (session !== undefined)
@@ -1381,9 +1744,10 @@ ${lines.join(`
 }
 async function boardRows(issues, sessions, repo) {
   const comments = await commentsOfAll(issues, repo);
+  const author = await sessionAuthor();
   return issues.map((issue) => {
     const own = comments.get(issue.number) ?? [];
-    return { issue, standing: standing(latestClaim(own), sessions), comments: own };
+    return { issue, standing: standing(latestClaim(own, author), sessions), comments: own };
   });
 }
 function boardJson(rows) {
@@ -1499,12 +1863,13 @@ async function take(args) {
   const numbers = issueNumbers(positionals, takeUsage);
   const sessions = await liveSessions();
   const nameFor = await claimant(values, sessions);
+  const author = await sessionAuthor();
   return eachIssue("take", numbers, async (number) => {
     const name = nameFor(number);
     const [found, comments] = await Promise.all([getIssue(number, values.repo), commentsOf(number, values.repo)]);
     if (found.state === "closed")
       fail(`#${number} is closed`, 1, runHint(`ft reopen ${number}`, "reopen it"));
-    const claim = latestClaim(comments);
+    const claim = latestClaim(comments, author);
     const current = standing(claim, sessions);
     if (claim?.holder === name) {
       console.log(`#${number} is already taken by ${name}`);
@@ -1515,6 +1880,9 @@ async function take(args) {
     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);
+    const standingNow = latestClaim(await commentsOf(number, values.repo), author);
+    if (standingNow?.holder !== name)
+      fail(`#${number} was taken by ${standingNow?.holder ?? "another session"} at the same moment`, 1);
     console.log(`took #${number} as ${name}: ${found.title}`);
   });
 }
@@ -1533,9 +1901,10 @@ async function drop(args) {
   const { values, positionals } = parsed;
   const numbers = issueNumbers(positionals, dropUsage);
   const nameFor = await claimant(values, await liveSessions());
+  const author = await sessionAuthor();
   return eachIssue("drop", numbers, async (number) => {
     const name = nameFor(number);
-    const claim = latestClaim(await commentsOf(number, values.repo));
+    const claim = latestClaim(await commentsOf(number, values.repo), author);
     if (claim?.holder !== name)
       fail(`#${number} is ${claim === undefined ? "not taken" : `taken by ${claim.holder}, not ${name}`}`, 1);
     await comment(number, releasedComment(name), values.repo);
@@ -1544,114 +1913,20 @@ async function drop(args) {
 }
 
 // src/commands/ci.ts
-import process11 from "process";
+import process12 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 : ""}`;
+// src/git.ts
+async function tagsAt(commit) {
+  return (await git(["tag", "--points-at", commit])).split(`
+`).filter(Boolean);
 }
-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 };
+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) };
   });
-  return () => {
-    for (const { target, name, original, wrapper } of wrapped) {
-      if (Reflect.get(target, name) === wrapper)
-        Reflect.set(target, name, original);
-    }
-  };
 }
 
 // src/log.ts
@@ -1728,7 +2003,13 @@ async function recentRuns(limit, repo, workflow) {
   return (await runsListing(limit, repo, workflow)).runs;
 }
 async function runsOn(sha, repo) {
-  return (await repoApi(`actions/runs?head_sha=${sha}`, repo)).workflow_runs ?? [];
+  const runs = [];
+  for (let page = 1;; page++) {
+    const list = (await repoApi(`actions/runs?head_sha=${sha}&page=${page}&limit=${RUNS_PAGE}`, repo)).workflow_runs ?? [];
+    runs.push(...list);
+    if (list.length < RUNS_PAGE)
+      return runs;
+  }
 }
 async function runById(id, repo) {
   return repoApi(`actions/runs/${id}`, repo);
@@ -1814,9 +2095,9 @@ var options = {
   job: { type: "string", short: "j", description: "a job whose skipping means the run left its work to a newer push" },
   timeout: { type: "string", short: "t", description: "how long before giving up (30m), a bare number in minutes" }
 };
-var POLL = 15000;
 var NO_RUN = 3 * 60000;
 var STALLED = 3 * 60000;
+var MAX_LOOKUPS = 20;
 function judge(runs, jobSkipped, tagged) {
   if (runs.length === 0)
     return { kind: "none" };
@@ -1828,7 +2109,13 @@ function judge(runs, jobSkipped, tagged) {
     return { kind: "runs", runs };
   return tagged ? { kind: "runs", runs: runs.map((run) => ({ ...run, status: "skipped" })) } : { kind: "passed-over" };
 }
-async function ci(args) {
+function commitsToAsk(commits, passedOver, max = MAX_LOOKUPS) {
+  return commits.filter((commit) => !passedOver.has(commit)).slice(0, max);
+}
+function settled(latest) {
+  return latest !== undefined && latest.every((run) => FINISHED.has(run.status)) && judge(latest, false, false).kind === "runs" ? latest : undefined;
+}
+async function ci2(args) {
   const parsed = parse(args, usage, options);
   const { values, positionals } = parsed;
   const branch = values.branch ?? await defaultBranch();
@@ -1852,71 +2139,44 @@ async function ci(args) {
     return coverage;
   }
   async function covering() {
-    await git(["fetch", "-q", "origin", branch]);
+    await fetchBranch(branch);
     if (!await gitOk(["merge-base", "--is-ancestor", sha, `origin/${branch}`]))
       fail(`${short} is not on origin/${branch}`, 2, runHint(`git push origin ${branch}`));
     const later = (await git(["rev-list", "--reverse", "--first-parent", `${sha}..origin/${branch}`])).split(`
 `).filter(Boolean);
-    for (const commit of [sha, ...later]) {
+    for (const commit of commitsToAsk([sha, ...later], passedOver)) {
       const coverage = await coverageOf(commit);
       if (coverage.kind === "runs")
         return coverage.runs;
     }
     return;
   }
-  const started = Date.now();
-  let seen = started;
-  let moving = started;
-  let followed = "";
-  let runs;
-  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 { dim } = paint(process12.stderr);
+  const runs = await waitForCi({
+    tool: "ft ci",
+    short,
+    giveUpMs: giveUp,
+    noneMs: NO_RUN,
+    stalledMs: STALLED,
+    noneMessage: `no run covers ${short} yet: its own was cancelled by a later push or never started, so the next push's will`,
+    covering,
+    finished: (found) => found.every((run) => FINISHED.has(run.status)),
+    key: (found) => found.map((run) => run.id).join(","),
+    announce: (found) => {
+      for (const run of found)
+        console.log(`following ${run.workflow_id} run ${run.id} on ${run.commit_sha.slice(0, 7)}${run.commit_sha === sha ? "" : `, which covers ${short}`}: ${run.html_url}`);
+    },
+    links: (found) => found.map((run) => run.html_url).join(" "),
+    settle: async (found) => settled(await refreshed(found)),
+    stall: async (found) => {
+      const stall = await stallReason(found);
+      return stall === undefined ? undefined : { message: `runs queued on ${short} are not moving: ${stall.reason}`, certain: stall.certain };
+    },
+    lines: (spinner, found, started) => [
+      `${spinner} CI on ${short} ${dim(formatDuration(Date.now() - started))}`,
+      ...(found ?? []).map((run) => `  ${badge(run.status, process12.stderr)} ${run.workflow_id} ${dim(`run ${run.id}`)}`)
+    ]
+  });
   const status = overall(runs);
   if (status !== "failure") {
     console.log(`CI ${status === "success" ? "passed" : "skipped its tests, a release tag's workflow testing them"} on ${short}`);
@@ -1933,7 +2193,7 @@ run ${run.id} failed${run.commit_sha === sha ? "" : `, testing every commit from
 }
 
 // src/commands/digest.ts
-import process12 from "process";
+import process13 from "process";
 var RUNS_SCANNED = 50;
 var TITLE_WIDTH2 = 70;
 var SHOWN = 8;
@@ -1983,7 +2243,7 @@ async function quietly(read) {
   }
 }
 async function staleTodos() {
-  const bin = Bun.which("todo-scan", { PATH: process12.env.PATH ?? "" });
+  const bin = Bun.which("todo-scan", { PATH: process13.env.PATH ?? "" });
   if (bin === null)
     return [];
   let found;
@@ -2044,7 +2304,8 @@ async function digest(args) {
   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 author = await sessionAuthor();
+  const rows = issues.map((issue) => ({ issue, claim: latestClaim(comments.get(issue.number) ?? [], author) }));
   const [unpushed, dirty, stale] = await Promise.all([quietly(unpushedCommits), quietly(dirtyTree), staleTodos()]);
   const summary = { ...claims(rows, sessions, me), ci: unsettled(runs, branch), unpushed, dirty, stale };
   if (values.json === true)
@@ -2161,7 +2422,7 @@ var issueOptions = {
   ...repoOption
 };
 function renderIssue(found, comments, view, now = Date.now()) {
-  const claim = latestClaim(comments);
+  const claim = latestClaim(comments, view.author);
   const list = boxes(found.body);
   const left = list.filter((box) => !box.done);
   const facts = [found.state];
@@ -2189,14 +2450,14 @@ ${each.body.replaceAll(`\r
 
 `);
 }
-function issueJson(found, comments) {
+function issueJson(found, comments, author) {
   return {
     number: found.number,
     title: found.title,
     state: found.state,
     url: found.html_url,
     labels: found.labels.map((label) => label.name),
-    claim: latestClaim(comments) ?? null,
+    claim: latestClaim(comments, author) ?? null,
     boxes: boxes(found.body).map(({ number, done, text }) => ({ number, done, text })),
     body: found.body,
     comments: comments.map((each) => ({ author: each.user.login, at: each.created_at, body: each.body }))
@@ -2216,12 +2477,13 @@ async function issue(args) {
     return 0;
   }
   const read = await Promise.all(numbers.map(async (number) => Promise.all([getIssue(number, values.repo), commentsOf(number, values.repo)])));
+  const author = await sessionAuthor();
   if (values.json === true) {
-    const json = read.map(([found, comments]) => issueJson(found, comments));
+    const json = read.map(([found, comments]) => issueJson(found, comments, author));
     printJson(json.length === 1 ? json[0] : json);
     return 0;
   }
-  const view = { todo: values.todo === true, comments: values.comments === true };
+  const view = { todo: values.todo === true, comments: values.comments === true, author };
   console.log(read.map(([found, comments]) => renderIssue(found, comments, view)).join(view.todo ? `
 
 ` : `
@@ -2240,11 +2502,14 @@ async function noteText(values) {
   const text = values.file === undefined ? values.message : await readInput(values.file);
   return text?.trim() === "" ? undefined : text?.trim();
 }
+var NOT_FOUND = /not exist|not found|couldn't be found/i;
 async function isClosed(number, repo) {
   try {
     return (await getIssue(number, repo)).state === "closed";
-  } catch {
-    return false;
+  } catch (error) {
+    if (error instanceof Error && NOT_FOUND.test(error.message))
+      return false;
+    throw error;
   }
 }
 async function closedReferences(body, repo) {
@@ -2317,17 +2582,21 @@ ${editUsage}`);
   const milestone = await milestoneTitle(values.milestone, values.repo);
   if (milestone !== undefined)
     change.milestone = milestone;
-  if (text !== undefined && values.append !== true)
+  const grows = text !== undefined && values.append === true || added.length > 0;
+  if (text !== undefined && !grows)
     change.body = text;
-  else if (text !== undefined || added.length > 0)
-    change.body = (await getIssue(number, values.repo)).body;
-  if (text !== undefined && values.append === true)
-    change.body = `${(change.body ?? "").trimEnd()}
-
-${text}`;
-  if (added.length > 0)
-    change.body = appendBoxes(change.body ?? "", added);
-  await editIssue(number, change, values.repo);
+  if (Object.keys(change).length > 0)
+    await editIssue(number, change, values.repo);
+  if (grows) {
+    await editBody(number, (body) => {
+      const appended = text !== undefined && values.append === true && !body.trimEnd().endsWith(text) ? `${body.trimEnd()}
+
+${text}` : body;
+      const present = new Set(boxes(appended).map((box) => box.text));
+      const missing = added.filter((box) => !present.has(box));
+      return missing.length > 0 ? appendBoxes(appended, missing) : appended;
+    }, values.repo);
+  }
   console.log(`edited #${number}`);
   return 0;
 }
@@ -2343,6 +2612,13 @@ var tickOptions = {
   ...noteOptions,
   ...repoOption
 };
+function tickedOrFail(number, run) {
+  try {
+    return run();
+  } catch (error) {
+    fail(`#${number}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
 async function tick(args) {
   const parsed = parse(args, tickUsage, tickOptions);
   const { values, positionals } = parsed;
@@ -2360,17 +2636,13 @@ ${tickUsage}`);
   const found = await getIssue(number, values.repo);
   const done = values.undo !== true;
   const closed = values.closed === true ? await closedReferences(found.body, values.repo) : undefined;
-  let result;
-  try {
-    result = closed === undefined ? setBoxes(found.body, picks, done) : tickReferences(found.body, (issue) => closed.has(issue));
-  } catch (error) {
-    fail(`#${number}: ${error instanceof Error ? error.message : String(error)}`);
-  }
+  const apply = (body) => closed === undefined ? setBoxes(body, picks, done) : tickReferences(body, (issue) => closed.has(issue));
+  let result = tickedOrFail(number, () => apply(found.body));
   if (result.changed.length > 0) {
-    if (closed === undefined)
-      await setBody(number, result.body, values.repo);
-    else
-      await editBody(number, (body) => tickReferences(body, (issue) => closed.has(issue)).body, values.repo);
+    await editBody(number, (body) => {
+      result = tickedOrFail(number, () => apply(body));
+      return result.body;
+    }, values.repo);
   }
   for (const box of result.changed)
     console.log(`${done ? "ticked" : "unticked"} ${box.number}: ${box.text}`);
@@ -2461,7 +2733,7 @@ async function fixed(args) {
     fail(`#${number} is already closed`, 1, runHint(`ft reopen ${number}`, "reopen it"));
   const left = boxes(found.body).filter((box) => !box.done);
   if (left.length > 0 && values.tick === true) {
-    await setBody(number, setBoxes(found.body, left.map((box) => String(box.number)), true).body, values.repo);
+    await editBody(number, (body) => setBoxes(body, boxes(body).filter((box) => !box.done).map((box) => String(box.number)), true).body, values.repo);
     console.log(`ticked ${left.length} box${left.length === 1 ? "" : "es"} of #${number}`);
   } else if (left.length > 0 && values.force !== true) {
     fail(`#${number} has ${left.length} boxes left:
@@ -2469,7 +2741,9 @@ ${left.map((box) => `${String(box.number).padStart(3)} [ ] ${box.text}`).join(`
 `)}`, 1, `${runHint(`ft fixed ${number} --tick`, "tick them and close")}, or ${runHint(`ft fixed ${number} --force`, "close with them left")}`);
   }
   const shas = joinShas(commits.map((each) => each.sha.slice(0, 7)));
-  await comment(number, `Fixed in ${shas}: ${values.message ?? commits[0]?.subject ?? ""}`, values.repo);
+  const line = `Fixed in ${shas}: ${values.message ?? commits[0]?.subject ?? ""}`;
+  if ((await commentsOf(number, values.repo)).at(-1)?.body.trim() !== line.trim())
+    await comment(number, line, values.repo);
   await close(number, values.repo);
   console.log(`closed #${number}: fixed in ${shas}`);
   await tickListings(number, values.repo);
@@ -2484,22 +2758,22 @@ 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" },
+  job: { type: "string", short: "j", description: "only this job, by name or id" },
   full: { type: "boolean", short: "f", description: "the whole log, timestamps stripped" },
   ...repoOption
 };
-function pickJobs(jobs, name) {
-  if (name !== undefined)
-    return jobs.filter((job) => job.name === name);
+function pickJobs(jobs, wanted) {
+  if (wanted !== undefined)
+    return jobs.filter((job) => job.name === wanted || String(job.id) === wanted);
   const failed = jobs.filter((job) => job.status === "failure");
   return failed.length > 0 ? failed : jobs;
 }
-async function logs(args) {
+async function logs2(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 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)
@@ -2776,8 +3050,8 @@ function report(plan, added, skipped) {
 
 // src/commands/release.ts
 import { basename as basename2, join as join2, relative, resolve } from "path";
-import process13 from "process";
-var {$: $3 } = globalThis.Bun;
+import process14 from "process";
+var {$ } = globalThis.Bun;
 
 // src/commands/watch.ts
 var usage4 = `ft watch [--after <id>]
@@ -2795,18 +3069,15 @@ var STALLED2 = 3 * 60000;
 async function watchRuns(pick, timeout, repo, idle) {
   const started = Date.now();
   const reported = new Map;
+  const followed = new Set;
+  const failed = new Set;
   let moving = started;
-  for (;; ) {
-    await Bun.sleep(timing.poll);
-    if (Date.now() - started > timeout)
-      fail(`the runs did not finish in ${formatDuration(timeout)}`);
-    let runs;
-    try {
-      runs = pick(await recentRuns(LIMIT, repo));
-    } catch (error) {
-      console.warn(`ft watch: ${error instanceof Error ? error.message : String(error)}, polling again`);
-      continue;
-    }
+  async function poll() {
+    const newest = await recentRuns(LIMIT, repo);
+    const gone = await Promise.all([...followed].filter((id) => !newest.some((run) => run.id === id)).map(async (id) => runById(id, repo)));
+    const runs = [...pick(newest), ...gone];
+    for (const run of runs)
+      followed.add(run.id);
     for (const run of runs) {
       if (reported.get(run.id) !== run.status)
         console.log(`${run.workflow_id} run ${run.id} on ${run.prettyref}: ${badge(run.status, process.stdout)}`);
@@ -2817,26 +3088,44 @@ async function watchRuns(pick, timeout, repo, idle) {
         console.log("no run started, so nothing was waited for");
         return 0;
       }
-      continue;
+      return;
     }
-    const status = overall(runs);
-    if (status === "failure" || status === "cancelled") {
-      for (const run of runs) {
-        if (run.status === "failure")
-          console.error(`
+    for (const run of runs) {
+      if (run.status === "failure" && !failed.has(run.id)) {
+        console.error(`
 ${await failureReport(run, repo)}
 
 ${run.html_url}`);
+        failed.add(run.id);
       }
-      return 1;
     }
-    if (runs.every((run) => FINISHED.has(run.status)))
-      return 0;
+    if (runs.every((run) => FINISHED.has(run.status))) {
+      const status = overall(runs);
+      return status === "failure" || status === "cancelled" ? 1 : 0;
+    }
     const stall = await stallReason(runs, repo);
     if (stall === undefined)
       moving = Date.now();
     else if (stall.certain || Date.now() - moving > STALLED2)
       fail(`queued runs are not moving: ${stall.reason}`);
+    return;
+  }
+  for (;; ) {
+    await Bun.sleep(timing.poll);
+    if (Date.now() - started > timeout)
+      fail(`the runs did not finish in ${formatDuration(timeout)}`);
+    try {
+      const code = await poll();
+      if (code !== undefined)
+        return code;
+    } catch (error) {
+      if (error instanceof Exit)
+        throw error;
+      const message = error instanceof Error ? error.message : String(error);
+      if (isPermanentFailure(error))
+        fail(message);
+      console.warn(`ft watch: ${message}, polling again`);
+    }
   }
 }
 async function watch(args) {
@@ -2862,7 +3151,7 @@ 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.
+A refused or interrupted push drops the bump commit and its tag, so a retry starts clean; with --tagged the commit and tag are yours and stay.
 Once released, an open milestone titled like the version (\`1.2.0\`, \`v1.2.0\` or the tag) has its closed issues listed and is closed; a failure there only warns.
 --dry-run checks the same and prints the plan: the version bump, the tag, the pushes and the runs and registry it would wait for, changing nothing.
 Exits 0 once released or planned, 1 when a run fails, origin refuses a push or the registry never serves the version, 2 on a timeout, a stalled queue, a refusal before anything ran (another branch, uncommitted changes, origin ahead) or a usage error.`;
@@ -2879,6 +3168,8 @@ var PARTS = /^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/;
 var LAST_NUMBER = /\d+$/;
 var REGISTRY_TRIES = 12;
 var REGISTRY_POLL = 5000;
+var limits = { pushMs: 5 * 60000 };
+var REGISTRY_INFO_MS = 30000;
 var NO_RUN2 = 3 * 60000;
 function taggedVersion(tag, prefix) {
   const version = tag.slice(prefix.length);
@@ -2921,7 +3212,7 @@ async function commitPackageBump(dir, prefix) {
   const { version } = await Bun.file(join2(dir, "package.json")).json();
   const root = await git(["rev-parse", "--show-toplevel"]);
   const tag = `${prefix}${version}`;
-  const lock = await $3`bun install --lockfile-only`.cwd(root).quiet().nothrow();
+  const lock = await $`bun install --lockfile-only`.cwd(root).quiet().nothrow();
   if (lock.exitCode !== 0)
     fail(`bun install --lockfile-only after the bump: ${lock.stderr.toString().trim()}`);
   await git(["add", join2(dir, "package.json"), join2(root, "bun.lock")]);
@@ -2930,8 +3221,14 @@ async function commitPackageBump(dir, prefix) {
 }
 async function waitForRegistry(name, version) {
   for (let attempt = 0;attempt < REGISTRY_TRIES; attempt++) {
-    const served = (await $3`bun info ${name} version --no-cache`.quiet().nothrow().text()).trim().split(`
+    let served;
+    try {
+      served = (await runTool("bun info", ["bun", "info", name, "version", "--no-cache"], { timeoutMs: REGISTRY_INFO_MS })).stdout.trim().split(`
 `).at(-1);
+    } catch (error) {
+      if (isPermanentFailure(error))
+        throw error;
+    }
     if (served === version)
       return true;
     await Bun.sleep(REGISTRY_POLL);
@@ -2940,10 +3237,18 @@ async function waitForRegistry(name, version) {
 }
 async function testsPass(sha, branch, timeout) {
   if (!await gitOk(["merge-base", "--is-ancestor", sha, `origin/${branch}`])) {
-    const push = await $3`git push origin ${`${sha}:refs/heads/${branch}`}`.quiet().nothrow();
-    if (push.exitCode !== 0)
+    const held = holdSignals();
+    let push;
+    try {
+      push = await runTool("git push", ["git", "push", "origin", `${sha}:refs/heads/${branch}`], { timeoutMs: limits.pushMs, onStart: (child) => held.forward(child) });
+    } finally {
+      held.release();
+    }
+    if (held.signal !== undefined)
+      fail(`interrupted by ${held.signal} while pushing ${sha.slice(0, 7)}, so nothing was bumped`, exitCodeOf(null, held.signal));
+    if (push.code !== 0)
       fail(`origin refused the push of ${sha.slice(0, 7)}, so nothing was bumped:
-${push.stderr.toString().trim()}`, 1);
+${push.stderr.trim()}`, 1);
     console.log(`pushed ${branch} at ${sha.slice(0, 7)}, waiting for its runs before the bump`);
   }
   return await watchRuns((runs) => newestPerWorkflow(runs.filter((run) => run.commit_sha === sha)), timeout, undefined, NO_RUN2) === 0;
@@ -2951,8 +3256,8 @@ ${push.stderr.toString().trim()}`, 1);
 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 name = pkg?.name ?? basename2(dir ?? process14.cwd());
+  const where = dir === undefined ? "" : ` in ${relative(process14.cwd(), dir) || "."}`;
   const sha = base.slice(0, 7);
   let version;
   let bump;
@@ -2983,6 +3288,17 @@ async function printPlan({ level, dir, prefix, branch, base, timeout, registry }
   console.log("dry run: nothing was pushed, committed or tagged");
   return 0;
 }
+async function rollBack(preBump, tagsBefore) {
+  try {
+    for (const name of await tagsAt("HEAD")) {
+      if (!tagsBefore.has(name))
+        await git(["tag", "-d", name]);
+    }
+    await git(["reset", "--keep", preBump]);
+  } catch (error) {
+    warn(`could not undo the bump, back to ${preBump.slice(0, 7)} by hand`, error instanceof Error ? error.message : String(error));
+  }
+}
 async function release(args) {
   const parsed = parse(args, usage5, options6);
   const { values, positionals } = parsed;
@@ -3003,34 +3319,61 @@ ${usage5}`);
     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)
+  await fetchBranch(branch);
+  if ((await $`git merge-base --is-ancestor ${`origin/${branch}`} HEAD`.quiet().nothrow()).exitCode !== 0)
     fail(`origin/${branch} has commits HEAD lacks`, 2, runHint(`git pull --rebase origin ${branch}`));
   const base = await git(["rev-parse", tagged ? "HEAD~1" : "HEAD"]);
   if (values["dry-run"] === true)
     return printPlan({ level, dir, prefix, branch, base, timeout, registry: values["no-registry"] !== true });
   if (!await testsPass(base, branch, timeout))
     fail(`the runs on ${base.slice(0, 7)} failed, so nothing was bumped or tagged`, 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 preBump = await git(["rev-parse", "HEAD"]);
+  const tagsBefore = new Set(await tagsAt("HEAD"));
   const before = (await recentRuns(1))[0]?.id ?? 0;
-  const push = await $3`git push --atomic origin ${`HEAD:refs/heads/${branch}`} ${tag}`.quiet().nothrow();
-  if (push.exitCode !== 0) {
-    await git(["tag", "-d", tag]);
-    await git(["reset", "--keep", "HEAD~1"]);
-    fail(`origin refused the push, so ${tag} and its commit were dropped for a clean retry:
-${push.stderr.toString().trim()}`, 1);
+  const held = holdSignals();
+  const signalOf = () => held.signal;
+  let tag = "";
+  let head = "";
+  let pushed = false;
+  let isPushUnknown = false;
+  try {
+    if (level !== undefined) {
+      const bump = dir === undefined ? await $`bun pm version ${level}`.quiet().nothrow() : await $`bun pm version ${level} --no-git-tag-version`.cwd(dir).quiet().nothrow();
+      if (bump.exitCode !== 0)
+        fail(`bun pm version ${level}: ${bump.stderr.toString().trim() || bump.stdout.toString().trim()}`);
+      if (dir !== undefined)
+        await commitPackageBump(dir, prefix);
+    }
+    const found = (await tagsAt("HEAD")).find((name) => taggedVersion(name, prefix) !== undefined);
+    if (found === undefined)
+      fail(tagged ? `HEAD carries no ${prefix}* tag` : `the bump made no ${prefix}* tag`);
+    tag = found;
+    head = await git(["rev-parse", "HEAD"]);
+    if (held.signal !== undefined)
+      fail(`interrupted by ${held.signal} before the push`, exitCodeOf(null, held.signal));
+    let push;
+    try {
+      push = await runTool("git push", ["git", "push", "--atomic", "origin", `HEAD:refs/heads/${branch}`, tag], { timeoutMs: limits.pushMs, onStart: (child) => held.forward(child) });
+    } catch (error) {
+      isPushUnknown = true;
+      fail(`${error instanceof Error ? error.message : String(error)}, so ${tag} and its commit are kept: the push may have landed`, 2, `git ls-remote origin refs/tags/${tag} tells; if it is there, ft release --tagged waits for its runs`);
+    }
+    if (push.code !== 0) {
+      const signal = signalOf();
+      fail(`origin refused the push${signal === undefined ? "" : `, or ${signal} interrupted it`}, so ${level === undefined ? `${tag} and its commit are kept for a retry` : `${tag} and its commit were dropped for a clean retry`}:
+${push.stderr.trim()}`, signal === undefined ? 1 : exitCodeOf(null, signal));
+    }
+    pushed = true;
+  } finally {
+    held.release();
+    if (!pushed && !isPushUnknown && level !== undefined)
+      await rollBack(preBump, tagsBefore);
   }
+  const late = signalOf();
+  if (late !== undefined)
+    fail(`interrupted by ${late} after ${tag} was pushed: its runs are not waited for`, exitCodeOf(null, late));
   console.log(`pushed ${branch} and ${tag}, waiting for their runs`);
-  const code = await watchRuns((runs) => runs.filter((run) => run.id > before), timeout);
+  const code = await watchRuns((runs) => runs.filter((run) => run.id > before && run.commit_sha === head), timeout, undefined, NO_RUN2);
   if (code !== 0)
     return code;
   const file = Bun.file(join2(dir ?? ".", "package.json"));
@@ -3069,7 +3412,7 @@ ${done.map((issue) => `  #${issue.number} ${issue.title}`).join(`
 // src/commands/remote.ts
 import { lookup } from "dns/promises";
 import { homedir as homedir3 } from "os";
-var {$: $4 } = globalThis.Bun;
+var {$: $2 } = globalThis.Bun;
 
 // src/config.ts
 import { homedir as homedir2 } from "os";
@@ -3078,30 +3421,53 @@ function settingsPath(home = homedir2()) {
   return join3(home, ".config", "ft", "config.json");
 }
 async function loadSettings(home = homedir2()) {
-  const file = Bun.file(settingsPath(home));
+  const path = settingsPath(home);
+  const file = Bun.file(path);
   if (!await file.exists())
     return {};
   let raw;
   try {
     raw = await file.json();
-  } catch {
+  } catch (error) {
+    warn(`${path} is not valid JSON, so its settings are ignored`, error instanceof Error ? error.message : String(error));
+    return {};
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    warn(`${path} is not a JSON object, so its settings are ignored`);
     return {};
   }
-  const host = typeof raw === "object" && raw !== null && "remoteHost" in raw ? raw.remoteHost : undefined;
+  const host = "remoteHost" in raw ? raw.remoteHost : undefined;
+  if (host !== undefined && (typeof host !== "string" || host === ""))
+    warn(`remoteHost in ${path} must be a non-empty string, so it is ignored`);
   return typeof host === "string" && host !== "" ? { remoteHost: host } : {};
 }
 
 // src/remote.ts
 var SCP_LIKE = /^(?:([^@/]+)@)?([^:/]+):(?!\/)(.+?)(?:\.git)?\/?$/;
-var SSH_URL = /^ssh:\/\/(?:([^@/]+)@)?([^:/]+)(?::\d+)?\/(.+?)(?:\.git)?\/?$/;
+var SSH_URL = /^ssh:\/\/(?:([^@/]+)@)?([^:/]+)(?::(\d+))?\/(.+?)(?:\.git)?\/?$/;
+var USERINFO = /^([a-z][a-z\d+.-]*:\/\/)[^@/]*@/i;
+var DEFAULT_PORT = "22";
 function parseSshRemote(url) {
-  const match = SSH_URL.exec(url) ?? (url.includes("://") ? null : SCP_LIKE.exec(url));
-  return match === null ? undefined : { user: match[1] ?? "git", host: match[2] ?? "", path: match[3] ?? "" };
+  const ssh = SSH_URL.exec(url);
+  const scp = ssh === null && !url.includes("://") ? SCP_LIKE.exec(url) : null;
+  const match = ssh ?? scp;
+  if (match === null || match[2]?.startsWith("-") === true)
+    return;
+  const login = match[1] ?? "git";
+  const user = login.includes(":") ? login.slice(0, login.indexOf(":")) : login;
+  if (ssh === null)
+    return { user, host: match[2] ?? "", path: match[3] ?? "" };
+  return { user, host: match[2] ?? "", path: match[4] ?? "", ...ssh[3] === undefined ? {} : { port: ssh[3] } };
+}
+function redactUrl(url) {
+  return url.replace(USERINFO, "$1");
 }
 function canonicalRemote(url, host, reaches) {
   const remote = parseSshRemote(url);
   if (remote === undefined || remote.host === host || !reaches(remote.host))
     return;
+  if (remote.port !== undefined && remote.port !== DEFAULT_PORT)
+    return `ssh://${remote.user}@${host}:${remote.port}/${remote.path}.git`;
   return `${remote.user}@${host}:${remote.path}.git`;
 }
 async function reachesHost(hostname, host, hostAddresses, addressesOf) {
@@ -3124,7 +3490,7 @@ var options7 = {
 };
 var HOSTNAME = /^hostname (.+)$/m;
 async function sshHostname(alias) {
-  return HOSTNAME.exec(await $4`ssh -G ${alias}`.quiet().nothrow().text())?.[1];
+  return HOSTNAME.exec(await $2`ssh -G -- ${alias}`.quiet().nothrow().text())?.[1];
 }
 async function addresses(name) {
   try {
@@ -3133,6 +3499,14 @@ async function addresses(name) {
     return [];
   }
 }
+async function restoreOrigin(fetchUrl, pushUrls, changes) {
+  if (changes.some(([from]) => from === fetchUrl))
+    await git(["remote", "set-url", "origin", fetchUrl]);
+  for (const [from, to] of changes) {
+    if (pushUrls.includes(from))
+      await git(["remote", "set-url", "--push", "origin", from, to]);
+  }
+}
 function originHost(url) {
   return parseSshRemote(url)?.host ?? (URL.canParse(url) ? new URL(url).hostname : undefined);
 }
@@ -3144,7 +3518,7 @@ async function remote(args, home = homedir3()) {
     return 0;
   }
   const fetchUrl = await git(["remote", "get-url", "origin"]);
-  const pushUrls = (await $4`git config --get-all remote.origin.pushurl`.quiet().nothrow().text()).split(`
+  const pushUrls = (await $2`git config --get-all remote.origin.pushurl`.quiet().nothrow().text()).split(`
 `).filter(Boolean);
   const hostAddresses = new Set(await addresses(host));
   const hostnames = new Map;
@@ -3162,15 +3536,15 @@ async function remote(args, home = homedir3()) {
   if (changes.length === 0) {
     const named = originHost(fetchUrl);
     if (named === host) {
-      console.log(`origin already names ${host}: ${fetchUrl}`);
+      console.log(`origin already names ${host}: ${redactUrl(fetchUrl)}`);
       return 0;
     }
     const hostname = named === undefined ? undefined : hostnames.get(named);
-    console.log(`origin ${fetchUrl} does not reach ${host}${hostname === undefined || hostname === named ? "" : `: ssh connects ${named} to ${hostname}`}, pass --host if Forgejo lives elsewhere`);
+    console.log(`origin ${redactUrl(fetchUrl)} does not reach ${host}${hostname === undefined || hostname === named ? "" : `: ssh connects ${named} to ${hostname}`}, pass --host if Forgejo lives elsewhere`);
     return 1;
   }
   for (const [from, to] of changes)
-    console.log(`${from} -> ${to}`);
+    console.log(`${redactUrl(from)} -> ${redactUrl(to)}`);
   if (values.fix !== true) {
     console.log("run `ft remote --fix` to switch them");
     return 1;
@@ -3182,7 +3556,12 @@ async function remote(args, home = homedir3()) {
     if (pushUrls.includes(from))
       await git(["remote", "set-url", "--push", "origin", to, from]);
   }
-  await git(["ls-remote", "origin", "HEAD"]);
+  try {
+    await git(["ls-remote", "origin", "HEAD"]);
+  } catch (error) {
+    await restoreOrigin(fetchUrl, pushUrls, changes);
+    return fail(`the switched origin does not answer, so the old URLs were put back: ${redactUrl(error instanceof Error ? error.message : String(error))}`, 1);
+  }
   console.log("origin switched, and git ls-remote reaches it");
   return 0;
 }
@@ -3234,7 +3613,7 @@ async function runs(args) {
 }
 
 // src/cli.ts
-process14.exitCode = await runCli({
+process15.exitCode = await runCli({
   name: "ft",
   version,
   about: "Forgejo tools over tea, run from a repository whose origin is on Forgejo",
@@ -3242,9 +3621,9 @@ process14.exitCode = await runCli({
   examples: [["ft ci", "wait for the runs of origin's tip, failures printed"], ["ft issue 12 -c", "an issue with its boxes numbered and its comments"]],
   commands: {
     runs: { run: runs, summary: "recent runs with workflow, ref, duration and age" },
-    ci: { run: ci, summary: "wait for the runs covering a commit, printing what failed" },
+    ci: { run: ci2, summary: "wait for the runs covering a commit, printing what failed" },
     watch: { run: watch, summary: "wait for runs newer than an id, or those in progress" },
-    logs: { run: logs, summary: "what the failed jobs of a run say went wrong" },
+    logs: { run: logs2, summary: "what the failed jobs of a run say went wrong" },
     release: { run: release, summary: "bump, push branch and tag atomically, wait for runs and registry" },
     board: { run: board, summary: "open issues: available, taken by a live session, or claimed by one gone" },
     digest: { run: digest, summary: "repo state for a cold start: held and abandoned claims, red CI, unpushed commits, dirty files, stale TODOs" },