@bensandee/forgejo-cli 0.4.2 → 0.4.3

package/dist/bin.mjs

@@ -8,63 +8,33 @@ import { z } from "zod";
 import { defineCommand, renderUsage, runCommand, runMain } from "citty";
 import { execFileSync, spawn } from "node:child_process";
 //#region ../cli-kit/src/json.ts
-/**
-* Pure logic for the `--json` entry path of a bin (`run.ts`). Kept apart from
-* that I/O-heavy entry point so it stays pure and unit-testable.
-*/
-/** True when `rawArgs` ask for JSON mode: a `--json` token (bare or `--json=<truthy>`), no
-* `--help`/`-h`, and not the bare `--version` query. The `=<value>` form is matched because citty
-* coerces a boolean flag that way (`value !== "false"`), so `--json=true` DOES put the command in
-* json mode; matching only the bare token left that invocation with `createCliOutput` suppressing
-* prose into a buffer tooling's `runBstCli` never flushed -- zero bytes of output for exit code 0.
-* `--json=false` and `--no-json` stay excluded, the way citty parses them. A `--json` that arrives
-* as the *value* of a preceding string flag (e.g. `--body --json`) is scanned the same way and is a
-* known, accepted ambiguity: this is a raw-argument scan, not an arg-aware parse. */
 function resolveJsonMode(rawArgs) {
 	if (!rawArgs.some(requestsJson)) return false;
 	if (rawArgs.includes("--help") || rawArgs.includes("-h")) return false;
 	if (rawArgs.length === 1 && (rawArgs[0] === "--version" || rawArgs[0] === "-v")) return false;
 	return true;
 }
-/** One raw token: whether it asks for json mode, mirroring citty's boolean coercion of a value
-* (anything but the literal `false` is truthy). */
 function requestsJson(token) {
 	if (token === "--json") return true;
 	if (!token.startsWith("--json=")) return false;
 	return token !== "--json=false";
 }
-/** The first token that is not a flag and not a flag's value, mirroring citty's own
-* `findSubCommandIndex` for a command whose own `args` is empty (true of `bst`'s top-level
-* command) -- a `--` sentinel ends the scan with no command found, same as citty. */
 function resolveCommandName(rawArgs) {
 	for (const arg of rawArgs) {
 		if (arg === "--") return void 0;
 		if (!arg.startsWith("-")) return arg;
 	}
 }
-/** Whether `--verbose`/`-v`/`--trace` (flag or the matching env var) was requested -- the gate on
-* whether an error document's `detail` may carry a stack trace. Mirrors `resolveLogLevel`'s
-* flag/env sources at the raw-argument level, since JSON-mode resolution runs before citty has
-* parsed anything, and must keep naming the same tokens tooling's `runBstCli` raises the log level
-* from: a run whose diagnostics are on and whose error document withholds its detail is the same
-* invocation answering the same question two ways. */
 function verboseRequested(rawArgs) {
 	if (process.env["TOOLING_TRACE"] === "true" || process.env["TOOLING_DEBUG"] === "true") return true;
 	return rawArgs.includes("--verbose") || rawArgs.includes("-v") || rawArgs.includes("--trace");
 }
-/** Narrow a subcommand map entry to a plain `CommandDef`, rejecting the function/Promise
-* variants `Resolvable` allows. None of this repo's commands are ever wrapped that way (every
-* one is a direct `defineCommand()` result), so this is a conservative "not resolvable
-* synchronously" rather than a real gap: the JSON path never invokes citty's own async
-* resolution machinery (see `run.ts`, `resolveSubCommand` note). */
 function asCommandDef(value) {
 	if (value === void 0) return void 0;
 	if (typeof value === "function") return void 0;
 	if (value instanceof Promise) return void 0;
 	return value;
 }
-/** Whether a resolved command declares a `json` argument -- what the coverage test reads to
-* decide between "granted --json" and its `EXEMPT` list. */
 function commandDeclaresJson(cmd) {
 	if (cmd === void 0) return false;
 	const argsDef = cmd.args;
@@ -73,10 +43,6 @@ function commandDeclaresJson(cmd) {
 	if (argsDef instanceof Promise) return false;
 	return "json" in argsDef;
 }
-/** Build the structured error document a `--json` failure flushes instead of prose --
-* `{ ok: false, command, version, error: { kind, message, detail? } }`. `notices` is not this
-* function's concern: `flushJsonOutput` folds the buffered notices into whatever document it
-* writes, error or payload alike. */
 function buildErrorDocument(input) {
 	const error = input.detail === void 0 ? {
 		kind: input.kind,
@@ -93,19 +59,6 @@ function buildErrorDocument(input) {
 		error
 	};
 }
-/**
-* The last-resort net for `--json`: if the process exits without `run.ts`'s flush ever
-* having written a document -- an await that never settles, for instance -- this writes one
-* parseable `{ok: false}` document and marks the exit nonzero, instead of nothing and Node's own
-* unsettled-top-level-await exit code. Distinct from the "completed without recording a JSON
-* payload" net in `run.ts`: that one runs after a command *returns*, so it cannot
-* see a process that never returns at all.
-*
-* On Node's unsettled-top-level-await path specifically, the loader prints its own warning to
-* stderr before any userland `exit` hook runs, so a merged `2>&1` capture still does not parse as
-* JSON alone -- this restores the stdout document and the exit code; it does not restore stderr's
-* cleanliness.
-*/
 function runJsonExitNet(params) {
 	if (params.wroteDocument()) return;
 	const label = params.command ?? params.binName;
@@ -120,8 +73,6 @@ function runJsonExitNet(params) {
 	} catch (_writeError) {}
 	process.exitCode = 1;
 }
-/** Install {@link runJsonExitNet} as a `process` `"exit"` listener, writing synchronously to fd 1
-* via `node:fs`. */
 function installJsonExitNet(binName, command, version, wroteDocument) {
 	process.on("exit", () => {
 		runJsonExitNet({
@@ -133,11 +84,6 @@ function installJsonExitNet(binName, command, version, wroteDocument) {
 		});
 	});
 }
-/** Classify a caught `unknown` into the error document's `kind`/`message`/`detail`. citty's
-* `CLIError` (arg-parse failures, an unknown subcommand, no command specified) is not exported
-* by the package, so it is recognised by `name` rather than `instanceof` -- still no typecast,
-* since `error instanceof Error` narrows `unknown` to `Error` first. Everything else, including
-* `FatalError`/`UnexpectedError`, is `"runtime"`. */
 function classifyThrown(error, verbose) {
 	const kind = error instanceof Error && error.name === "CLIError" ? "usage" : "runtime";
 	const message = redact(describeError(error));
@@ -157,23 +103,7 @@ function classifyThrown(error, verbose) {
 }
 //#endregion
 //#region ../cli-kit/src/env-file.ts
-/**
-* The one way a file feeds this process's environment: `BST_ENV_FILE=<path>` names an env file
-* (`KEY=value` lines, `#` comments, an optional `export` prefix) that a bin loads
-* before anything else runs (each bin passes its own name and version). Unset means no file is touched.
-*
-* Explicit and opt-in rather than "load `.env` if one exists", so a production container, which
-* receives every variable through `docker run -e`, can never pick up a stray file -- nothing sets
-* this variable there. A value that names an unreadable file is fatal instead of a warning, since
-* configuration that fails to resolve should fail where it was written, not later as a missing
-* credential. The environment always wins over the file, the same precedence as Node's own
-* `--env-file`, so a shell export or a `-e` on a container is never overridden.
-*/
 const ENV_FILE_VAR = "BST_ENV_FILE";
-/**
-* Load `$BST_ENV_FILE` into `process.env`, returning what happened, or `undefined` when the
-* variable is unset or blank. Throws {@link FatalError} on a file that cannot be read.
-*/
 function loadEnvFileFromEnv() {
 	const raw = process.env[ENV_FILE_VAR]?.trim();
 	if (raw === void 0 || raw === "") return void 0;
@@ -197,12 +127,6 @@ function loadEnvFileFromEnv() {
 		kept
 	};
 }
-/**
-* One diagnostic line about a load -- the path and the variable names, never a value -- or, for
-* `undefined`, the fact that no file was configured. The absent case is reported rather than
-* passed over because "my credential did not load" and "no file was ever named" look identical
-* from outside the process, and that is exactly the question this line is read to answer.
-*/
 function describeEnvFileLoad(load) {
 	if (load === void 0) return `No env file loaded -- ${ENV_FILE_VAR} is unset or empty.`;
 	const parts = [`Loaded ${String(load.added.length)} variable(s) from ${load.path} (${ENV_FILE_VAR}): ` + (load.added.length === 0 ? "none" : load.added.join(", "))];
@@ -218,12 +142,6 @@ const processIo = {
 	},
 	exit: (code) => process.exit(code)
 };
-/**
-* {@link loadEnvFileFromEnv} for a bin entry point: a failure ends the process with exit code 1
-* instead of propagating as an unhandled rejection with a stack trace. This runs before the CLI
-* exists, so it renders the failure itself -- as the one `{ok: false}` document `--json` promises
-* when `rawArgs` ask for it, else as a single stderr line.
-*/
 function loadEnvFileForBin(rawArgs, bin, io = processIo) {
 	try {
 		return loadEnvFileFromEnv();
@@ -245,7 +163,7 @@ function loadEnvFileForBin(rawArgs, bin, io = processIo) {
 //#region src/version.ts
 const parsed = z.object({ version: z.string() }).safeParse({
 	name: "@bensandee/forgejo-cli",
-	version: "0.4.2",
+	version: "0.4.3",
 	description: "bst-fj: Forgejo API commands without the rest of bst",
 	license: "MIT",
 	repository: {
@@ -285,20 +203,9 @@ const parsed = z.object({ version: z.string() }).safeParse({
 	}
 });
 if (!parsed.success) throw new UnexpectedError(`@bensandee/forgejo-cli's package.json has no string version.`);
-/** The package version, stamped on `--version` and on every `--json` error document. */
 const BST_FJ_VERSION = parsed.data.version;
 //#endregion
 //#region src/env-file-preload.ts
-/**
-* The `$BST_ENV_FILE` load as a module side effect, so a bin entry point can run it **before any
-* other module evaluates** simply by importing this module first. That ordering is the whole
-* point: a module that reads the environment at import time would otherwise read an environment
-* the file had not joined yet. A dynamic `import()` cannot guarantee it either: the bundler inlines
-* the target and evaluates it with the rest of the bundle, ahead of the call.
-*
-* Only the bin entry point imports this module. Nothing under test does, so a developer's exported
-* `BST_ENV_FILE` never reaches a vitest worker.
-*/
 const envFileLoad = loadEnvFileForBin(process.argv.slice(2), {
 	name: "bst-fj",
 	version: BST_FJ_VERSION
@@ -313,17 +220,10 @@ const RANK = {
 	trace: 4
 };
 let moduleLevel = "info";
-/** Set the process-global minimum level (default `info`). Read live by every non-pinned logger. */
 function setLogLevel(level) {
 	moduleLevel = level;
 }
 let moduleTimestamps = false;
-/**
-* Resolve the minimum level from flags + env, cheapest-wins: `--trace`/`TOOLING_TRACE` -> `trace`
-* (the exec/fetch firehose), else `--verbose`/`TOOLING_DEBUG` -> `debug`, else `info`. Trace
-* outranks verbose. Pure; a command passes its parsed flags and feeds the result to
-* {@link setLogLevel}.
-*/
 function resolveLogLevel(flags) {
 	if (flags.trace === true || process.env["TOOLING_TRACE"] === "true") return "trace";
 	if (flags.verbose === true || process.env["TOOLING_DEBUG"] === "true") return "debug";
@@ -332,8 +232,6 @@ function resolveLogLevel(flags) {
 const isCI = Boolean(process.env["CI"]);
 const out = (msg) => console.log(msg);
 const err = (line) => console.error(line);
-/** The plain user-facing adapter -- stdout with level tags, mirroring the pre-unification `log`.
-* The tag is what carries the level once clack's coloured symbol is gone. */
 const plainUserSink = {
 	info: out,
 	warn: (msg) => out(`[warn] ${msg}`),
@@ -342,33 +240,16 @@ const plainUserSink = {
 };
 let plainOutput = isCI;
 let jsonMode = false;
-/** Silence the four user-facing levels process-wide (default off). Diagnostic levels are
-* unaffected -- see the `jsonMode` comment above. */
 function setJsonMode(enabled) {
 	jsonMode = enabled;
 }
-/** Read the json-mode global for the one user-facing sink outside the logger (`note()` in
-* tooling's `utils/log.ts`), which the sink-selection gate below cannot reach. */
 function isJsonMode() {
 	return jsonMode;
 }
 let jsonNoticeSink;
-/** Give a suppressed `warn`/`error` line somewhere to go while `jsonMode` is on. Pass `undefined`
-* to go back to dropping them. */
 function setJsonNoticeSink(sink) {
 	jsonNoticeSink = sink;
 }
-/**
-* Render the tag a text reader sees. Widen the payload freely; widen this only for something a
-* reader needs on the line it is reading -- a multi-repo agent's reader needs the repository,
-* because a bare `#42` names an object in whichever of several repos the cycle happens to be in,
-* and recovering which one meant scrolling back to the claim line.
-*
-* `repo` renders as its trailing segment alone. What discriminates two units is the repo name; the
-* owner costs width on every line and usually repeats, and the claim line still names `owner/repo`
-* in full once per cycle, so a short name that is genuinely ambiguous is one scroll from the whole
-* one.
-*/
 function formatContext(context) {
 	const parts = [];
 	if (context.repo !== void 0) {
@@ -419,7 +300,6 @@ function build(config) {
 		})
 	};
 }
-/** Create a {@link Logger}. All seams default to real sinks and the live global level. */
 function createLogger(options = {}) {
 	return build({
 		level: options.level,
@@ -430,36 +310,9 @@ function createLogger(options = {}) {
 		now: options.now ?? (() => /* @__PURE__ */ new Date())
 	});
 }
-/** The process-wide root logger the shims delegate to. Pins nothing, so it follows both process
-* globals -- which is what makes `setLogTimestamps` reach every module that logs through `log`. */
 const rootLogger = createLogger();
 //#endregion
 //#region ../cli-kit/src/flags.ts
-/**
-* Pure logic over an invocation's flags: whether it carries one its resolved command never
-* declared, whether a `[dir]` positional names a directory (through an injected probe), and how a
-* flag's own value reads.
-* Kept apart from the bins' I/O-heavy entry points so it stays pure and unit-testable.
-* No `process`, `node:fs` or logger import -- see `flags.test.ts`'s "no I/O" assertion.
-*
-* The detection mirrors citty@0.2.2's own parser (`_parser.ts`/`args.ts` in
-* `node_modules/citty/dist/index.mjs`) closely enough that it agrees with what citty would
-* silently accept: the same option table (declared name, declared alias, camelCase/kebab-case
-* pair), the same `--no-<flag>` pre-pass, and the same `node:util` `parseArgs({ strict: false,
-* allowPositionals: true })` call. Anything that call surfaces as a key we did not expect is a
-* flag citty would otherwise absorb without a word -- see `flags-differential.test.ts`, which
-* pins this mirror against the real citty rather than trusting the copy. The mirror is literal,
-* with no exception: a `--no-<x>` token is known exactly when `x` is declared, because that is the
-* key citty's pre-pass writes.
-*/
-/** The carve-out set: citty's own builtins (`--help`/`-h`, `--version`/`-v`) plus the flags every
-* command honours regardless of whether it declares them. Accepted on every command, declared or
-* not -- and each one is honoured somewhere: `--help`/`-h` short-circuit this check wherever they
-* appear (`hasHelpFlag`) and citty renders usage; `--version` and a lone `-v` are citty's version
-* query (`runMain` intercepts it only when it is the whole argv, so `isLoneVersionQuery` mirrors
-* that); `-v` beside anything else is read as `--verbose`, and `--verbose`/`--trace` set the
-* process log level in tooling's `runBstCli`. The one member with no meaning of its own past that
-* is `--version` written beside other arguments, which citty ignores. */
 const UNIVERSAL_FLAGS = [
 	"--help",
 	"-h",
@@ -468,8 +321,6 @@ const UNIVERSAL_FLAGS = [
 	"--verbose",
 	"--trace"
 ];
-/** Derived from {@link UNIVERSAL_FLAGS} rather than restated beside it: two hand-written copies of
-* one set are one edit away from disagreeing, and nothing would catch the half that was missed. */
 const UNIVERSAL_NAMES = new Set(UNIVERSAL_FLAGS.map(flagName));
 function hasHelpFlag(rawArgs) {
 	return rawArgs.includes("--help") || rawArgs.includes("-h");
@@ -477,12 +328,6 @@ function hasHelpFlag(rawArgs) {
 function isLoneVersionQuery(rawArgs) {
 	return rawArgs.length === 1 && (rawArgs[0] === "--version" || rawArgs[0] === "-v");
 }
-/** The token citty would read as a command name, mirroring its own `findSubCommandIndex`: every
-* "-"-prefixed token is skipped, and so is the token after one naming a `string`/`enum` arg the
-* command declares, since citty consumes that as the flag's value (`--repo x/y`) before it looks
-* for a name. `argsDef` is omitted for `bst`'s own top-level command, which declares no args of
-* its own, so nothing is consumed there. A `--` sentinel ends the scan with no command found,
-* same as `resolveCommandName` in @bensandee/cli-kit/json. */
 function splitAtCommand(rawArgs, argsDef) {
 	for (let i = 0; i < rawArgs.length; i++) {
 		const token = rawArgs[i];
@@ -497,7 +342,6 @@ function splitAtCommand(rawArgs, argsDef) {
 		};
 	}
 }
-/** citty's `_isValueFlag`: whether `token` names a declared arg whose value is a separate token. */
 function declaresValueFlag(token, argsDef) {
 	const name = flagName(token);
 	const normalized = toCamelCase(name);
@@ -517,9 +361,6 @@ function flagBase(token) {
 function flagName(token) {
 	return flagBase(token).replace(/^-{1,2}/, "");
 }
-/** Narrow a resolved command's `args` to a plain `ArgsDef`, rejecting the function/Promise
-* variants `Resolvable` allows -- the same conservative narrowing `commandDeclaresJson` applies
-* to a command's `json` argument. No command in this repo defines `args` dynamically. */
 function resolveStaticArgsDef(cmd) {
 	const argsDef = cmd.args;
 	if (argsDef === void 0) return void 0;
@@ -527,28 +368,12 @@ function resolveStaticArgsDef(cmd) {
 	if (argsDef instanceof Promise) return void 0;
 	return argsDef;
 }
-/** citty's own `camelCase`/`kebabCase` (from the bundled `scule`) are not part of its public
-* exports, so this is a minimal reimplementation over the hyphenated, all-lowercase names this
-* repo's `args` definitions actually use (`body-file`, `dry-run`, ...) -- not a general-purpose
-* case converter. The differential test pins that this is faithful enough for every declared arg
-* in the tree. */
 function toCamelCase(name) {
 	return name.replace(/-([a-z0-9])/g, (_match, ch) => ch.toUpperCase());
 }
 function toKebabCase(name) {
 	return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
 }
-/** Build the option table citty's `parseArgs` (`args.ts`) builds from a command's declared
-* `args`: every declared name plus its declared alias(es) and its camelCase/kebab-case pair
-* becomes its own entry in the table `node:util`'s `parseArgs` consults, typed by walking the
-* alias relationship back to whichever side declared `boolean`.
-*
-* One structural difference from citty, which additionally hands a one-character alias to
-* `parseArgs` as the partner entry's `short`: an entry registered under its own single-letter name
-* is matched by `-x` and consumes the next token exactly as a `short` mapping does, so the two
-* tables agree on every name a parse reports as unknown -- they differ only in which of the pair
-* holds the value, which nothing here reads. Pinned by the one-character-alias cases in
-* `flags-differential.test.ts`. */
 function buildParseTable(argsDef) {
 	const booleanNames = /* @__PURE__ */ new Set();
 	const aliasesByMain = /* @__PURE__ */ new Map();
@@ -588,12 +413,6 @@ function buildParseTable(argsDef) {
 		acceptedFlags
 	};
 }
-/** Mirror citty's `parseRawArgs`: strip `--no-<flag>` tokens before they ever reach
-* `node:util`'s parser (citty accepts the negated form for *any* name, declared or not -- so an
-* undeclared `--no-bogus` must still surface as `bogus` for the known-name check below, the same
-* way an undeclared `--bogus` would), then run the same `strict: false` /
-* `allowPositionals: true` parse citty runs, falling back to an empty parse on any throw exactly
-* as citty's own `try/catch` does. */
 function parsePostCommandArgs(postCommandArgs, nodeOptions) {
 	const negatedNames = [];
 	const processedArgs = [];
@@ -629,9 +448,6 @@ function parsePostCommandArgs(postCommandArgs, nodeOptions) {
 		negatedNames
 	};
 }
-/** The first positional declaring `valueHint: "dir"` whose value `probe` says is not a directory.
-* citty fills positionals in declaration order, so the Nth declared positional takes the Nth
-* positional token. An omitted positional is left to the command's own default. */
 function findBadDirArg(postCommandArgs, argsDef, nodeOptions, probe) {
 	const { positionals } = parsePostCommandArgs(postCommandArgs, nodeOptions);
 	const declared = Object.entries(argsDef).filter(([, def]) => def.type === "positional");
@@ -646,16 +462,6 @@ function findBadDirArg(postCommandArgs, argsDef, nodeOptions, probe) {
 		};
 	}
 }
-/** The bare key names citty's own parse would carry that `argsDef` never declared -- directly
-* comparable to what a stub command's `run` would see via `Object.keys(args)` for a key citty
-* never intended, which is exactly what the differential test compares against. Note that a
-* negated `--no-<x>` produces the key `x`, not `no-<x>`: citty's pre-pass strips the token down
-* to `x` and assigns `out[x] = false` *unconditionally*, whether or not `x` itself is a declared
-* name. So a negated name is known exactly when the BARE name is declared, with no second lookup
-* under `no-<x>`: no command declares a `no-`-prefixed name and both packages'
-* `flag-strictness.test.ts` forbid one, so if that guard is ever bypassed, being rejected as an
-* unknown flag is the better outcome -- the flag would otherwise parse, be accepted here, and
-* silently do nothing. */
 function computeUnknownArgNames(postCommandArgs, argsDef) {
 	const table = buildParseTable(argsDef);
 	const { values, negatedNames } = parsePostCommandArgs(postCommandArgs, table.nodeOptions);
@@ -664,9 +470,6 @@ function computeUnknownArgNames(postCommandArgs, argsDef) {
 	for (const name of negatedNames) if (!table.knownNames.has(name)) unknown.add(name);
 	return [...unknown];
 }
-/** Map each bare key `computeUnknownArgNames` can produce back to the literal token that
-* produced it, so the rendered message shows what the caller actually typed (`--no-coverage`,
-* not `--coverage`) rather than reconstructing a plausible-looking guess. */
 function buildDisplayTokenMap(postCommandArgs) {
 	const map = /* @__PURE__ */ new Map();
 	for (const token of postCommandArgs) {
@@ -682,15 +485,9 @@ function buildDisplayTokenMap(postCommandArgs) {
 	}
 	return map;
 }
-/** Fallback for a bare name with no matching raw token (e.g. one letter of a bundled short-flag
-* group such as `-yes`) -- vanishingly rare for this repo's single-letter aliases, but a
-* conservative guess beats dropping the flag from the message entirely. */
 function formatFlagToken(bareName) {
 	return bareName.length === 1 ? `-${bareName}` : `--${bareName}`;
 }
-/** Narrow a command's `subCommands` to a plain map, rejecting the function/Promise variants
-* `Resolvable` allows -- the same conservative narrowing `resolveStaticArgsDef` applies to
-* `args`. No command in this repo defines `subCommands` dynamically. */
 function resolveStaticSubCommands(cmd) {
 	const subCommands = cmd.subCommands;
 	if (subCommands === void 0) return void 0;
@@ -698,16 +495,6 @@ function resolveStaticSubCommands(cmd) {
 	if (subCommands instanceof Promise) return void 0;
 	return subCommands;
 }
-/** Walk down a command that routes to `subCommands` -- mirrors citty's own `runCommand`, which
-* recurses into `rawArgs.slice(subCommandArgIndex + 1)` against the named subcommand and measures
-* the flags there. **A router's own `args` does not stop the descent**: citty looks for the
-* subcommand token whether or not the router declares flags of its own, so a command with both
-* (`bst-fj labels`, whose `--json` exists for the `--json`-coverage test to see) must be
-* descended past rather than treated as the leaf -- otherwise every flag its subcommands declare
-* is measured against the router's table and rejected. The router's own table is the answer only
-* when no subcommand token follows. Returns `undefined` on anything the top-level check already
-* treats conservatively: an unregistered name (citty reports that itself), an entry that cannot
-* be narrowed, or a router with neither a subcommand token nor args of its own. */
 function resolveLeafCommand(cmd, chain, postCommandArgs) {
 	const argsDef = resolveStaticArgsDef(cmd);
 	const subCommands = resolveStaticSubCommands(cmd);
@@ -727,24 +514,6 @@ function resolveLeafCommand(cmd, chain, postCommandArgs) {
 		postCommandArgs
 	};
 }
-/** Returns the offending flags plus the resolved command name and its accepted flag list, or a
-* "nothing to report" result. Short-circuits, in order: `--help`/`-h` anywhere or a lone
-* `--version`/`-v` (citty's `runMain` intercepts both); no command name, or a name not in
-* `subCommands` (citty already reports those); an entry `asCommandDef` cannot narrow
-* (conservatively -- no command in this repo is a function or Promise). Flags before the command
-* name are checked against the universal set only, since the top-level `bst` command declares no
-* args of its own and citty slices them away before the subcommand ever sees them. A command
-* routing to nested `subCommands` descends via `resolveLeafCommand` -- citty parses the *nested*
-* command's args against the remaining argv, so that is where an unknown flag actually surfaces.
-* A flag written between a router and its subcommand name (`bst-fj labels --zzz sync`) goes
-* unreported: citty's own `strict: false` parse at the router absorbs it, and the subcommand
-* never sees it -- which is also why `--json` written there is silently dropped rather than
-* honoured, so a machine reader must write it after the subcommand name.
-*
-* With a `probe`, a positional declaring `valueHint: "dir"` whose value is not a directory is
-* reported too, after the flag checks. Commands hand that value to git, pnpm, or a file read as a
-* working directory, where a file produced a stack trace and `docs:check` passed without checking
-* anything. */
 function findUnknownFlags(rawArgs, subCommands, probe) {
 	if (hasHelpFlag(rawArgs) || isLoneVersionQuery(rawArgs)) return { kind: "none" };
 	const split = splitAtCommand(rawArgs);
@@ -781,50 +550,22 @@ function findUnknownFlags(rawArgs, subCommands, probe) {
 		accepted: table.acceptedFlags
 	};
 }
-/** `Unknown flag --repo for issue:comment. Nothing ran.` followed by
-* `Accepted: --body, --body-file, --json, --dry-run, --verbose (plus --help, --trace).` -- the
-* "(plus ...)" tail is {@link UNIVERSAL_FLAGS} minus what the command already declares, minus the
-* short aliases (`-h`/`-v` say nothing their long spelling does not) and minus `--version`, which
-* is a lone-invocation query citty never treats as a per-command flag (see `isLoneVersionQuery`),
-* so listing it as "accepted" here would overstate what actually happens on `<command>
-* --version`. */
 function formatUnknownFlagsMessage(result) {
 	const first = `Unknown ${result.unknownFlags.length === 1 ? "flag" : "flags"} ${result.unknownFlags.join(", ")} for ${result.commandPath}. Nothing ran.`;
 	const extras = UNIVERSAL_FLAGS.filter((flag) => flag.startsWith("--") && flag !== "--version" && !result.accepted.includes(flag));
 	return `${first}\nAccepted: ${extras.length === 0 ? result.accepted.join(", ") : `${result.accepted.join(", ")} (plus ${extras.join(", ")})`}.`;
 }
-/** `--json must come after the command name.` */
 function formatFlagBeforeCommandMessage(result) {
 	return `${result.flag} must come after the command name.`;
 }
-/** `No such directory: nope. ascii:check takes a directory as [dir]. Nothing ran.` */
 function formatNotADirectoryMessage(result) {
 	return `${result.missing ? `No such directory: ${result.value}.` : `${result.value} is not a directory.`} ${result.commandPath} takes a directory as [${result.argName}]. Nothing ran.`;
 }
-/** The single message any non-`"none"` variant renders, so `run.ts` needs one call
-* regardless of which shape the check found. */
 function formatFlagCheckMessage(result) {
 	if (result.kind === "before-command") return formatFlagBeforeCommandMessage(result);
 	if (result.kind === "not-a-directory") return formatNotADirectoryMessage(result);
 	return formatUnknownFlagsMessage(result);
 }
-/**
-* Collect every occurrence of a repeated named flag from a command's raw CLI args.
-*
-* citty@0.2.2 keeps only the LAST occurrence of a repeated named flag (see
-* `collectInputArgs` in `release/publish/dispatch.ts`, which works around the same issue for
-* `--input`), so a declared string arg cannot capture `--label bug --label chore` -- it
-* silently yields just `chore`. Scanning the raw argv directly recovers all occurrences.
-* Both `--flag v` (two tokens) and `--flag=v` (one token) forms are supported.
-* Blank/whitespace-only values are dropped rather than passed through as an empty value.
-*
-* Deliberately does not comma-split a value the way `parseListFlag`
-* (`commands/repo-run-checks.ts`) does: comma-splitting is right for that flag's contract
-* and wrong here, where a value can be a file path containing a comma.
-*
-* Stops at a `--` sentinel, the same one {@link hasNegationFlag} stops at: a token after it is a
-* positional, never a flag citty would read.
-*/
 function collectFlagValues(rawArgs, flag) {
 	const flagEq = `${flag}=`;
 	const values = [];
@@ -842,12 +583,6 @@ function collectFlagValues(rawArgs, flag) {
 	}
 	return values.map((v) => v.trim()).filter((v) => v !== "");
 }
-/**
-* Whether a bare boolean flag (e.g. `--no-assignee`) appears in a command's raw CLI args, the
-* same `--` sentinel `parsePostCommandArgs` and {@link collectFlagValues} stop at rather than a
-* bare `rawArgs.includes(flag)`: the literal token can otherwise match where citty would never
-* read it as a flag -- after a `--` sentinel.
-*/
 function hasNegationFlag(rawArgs, flag) {
 	for (const arg of rawArgs) {
 		if (arg === "--") break;
@@ -855,9 +590,6 @@ function hasNegationFlag(rawArgs, flag) {
 	}
 	return false;
 }
-/** True when `flag` (or `flag=...`) appears in `rawArgs` before any `--`, whatever it resolved
-* to. `collectFlagValues` drops a blank value, so its list alone cannot tell "flag not given"
-* from "flag given, resolved to nothing". */
 function flagPresent(rawArgs, flag) {
 	for (const arg of rawArgs) {
 		if (arg === "--") break;
@@ -865,20 +597,6 @@ function flagPresent(rawArgs, flag) {
 	}
 	return false;
 }
-/**
-* Resolve a repeatable value flag and its boolean negation (`--assignee` / `--no-assignee`) from
-* raw args, because citty keeps only the last value of a repeated flag and writes a bare `false`
-* for the negation.
-*
-* - The flag and its negation together throw: a contradiction for the user, not the tool, to
-*   resolve.
-* - The flag present but resolving to no value (an unset `$VAR`, or a trailing flag) throws, so a
-*   caller never falls through to a default on a half-typed command.
-* - Otherwise the result says whether the flag was absent, negated, or carried values. What
-*   "absent" means (a default, or nothing) is the caller's rule.
-*
-* `wording` names what the flag carries, for the refusal of a flag with no value.
-*/
 function resolveRepeatableFlag(rawArgs, flag, negation, wording) {
 	const values = collectFlagValues(rawArgs, flag);
 	const negated = hasNegationFlag(rawArgs, negation);
@@ -894,18 +612,12 @@ function resolveRepeatableFlag(rawArgs, flag, negation, wording) {
 	};
 	return { kind: "absent" };
 }
-/** `<n>[s|m|h]`, a bare integer meaning seconds. */
 const DURATION_PATTERN = /^(\d+)(s|m|h)?$/;
 const UNIT_MS = {
 	s: 1e3,
 	m: 6e4,
 	h: 36e5
 };
-/**
-* Parse a `--timeout`/`--interval`-shaped duration (`<n>[s|m|h]`, a bare integer meaning seconds)
-* into milliseconds. Anything else is a `FatalError` naming `flag`, so an unreadable value throws
-* into the standard error document rather than silently falling back to a default.
-*/
 function parseDuration(value, flag) {
 	const match = DURATION_PATTERN.exec(value.trim());
 	if (!match) throw new FatalError(`${flag} expects a duration like "30s", "15m", or "1h" (a bare integer means seconds) -- got ${JSON.stringify(value)}.`);
@@ -913,31 +625,6 @@ function parseDuration(value, flag) {
 	const multiplier = UNIT_MS[unit ?? "s"];
 	return Number.parseInt(amount ?? "0", 10) * multiplier;
 }
-/**
-* Read a repeatable comma-separated list flag (`--skip`, `--add`) out of the RAW argv, unioning
-* every occurrence.
-*
-* **The union is the point, and the raw argv is the only place it survives.** pnpm appends
-* CI-forwarded flags to the END of the resolved script, so a repo whose `check` script already
-* carries `--skip build` sees TWO occurrences the moment CI or an agent adds `--skip 'docker:*'`.
-* citty declares this arg as `type: "string"` and collapses a repeated one to the LAST value
-* before the handler ever runs -- probed against citty 0.2.2, `--skip build --skip 'docker:*'`
-* arrives as the bare string `"docker:*"`, with no array and no trace of the first occurrence.
-* So reading `args.skip` cannot be made additive; the fix has to go to `rawArgs`. That collapse
-* is how this repo's `ci:check` came to run a second full build on every CI run, and it
-* contradicts the semantics the `.tooling.json#checks.skip` path already documents: a skip is
-* additive everywhere else, so it must be additive here too.
-*
-* Handles both spellings (`--skip a` and `--skip=a`), stops at a bare `--`, and ignores an
-* occurrence whose value is missing. A malformed flag contributes nothing rather than throwing
-* -- it must not take down a check run.
-*
-* "Missing" is specifically a following token starting with `--`, not one starting with `-`.
-* The looser test reads `--skip -x` as a forgotten value and silently drops a skip the caller
-* did ask for, and it makes the two spellings disagree: `--skip=-x` has no such ambiguity and
-* would keep the value. Only a long flag can be mistaken for the next argument, so only a long
-* flag terminates.
-*/
 function parseListFlag(rawArgs, flag) {
 	const long = `--${flag}`;
 	const values = [];
@@ -953,12 +640,6 @@ function parseListFlag(rawArgs, flag) {
 	}
 	return values.flatMap((value) => value.split(",")).map((value) => value.trim()).filter((value) => value.length > 0);
 }
-/** True when `--<flag>` (or `--<flag>=...`) appears anywhere in `rawArgs`, independent of what it
-* resolved to. `parseListFlag` silently drops a value that resolves to empty -- an unset `$VAR` in
-* `--repo "$REPO"`, or a trailing `--repo` whose value fell off the line -- so a caller that only
-* checks the parsed list cannot tell "no --repo given" apart from "a --repo given that resolved to
-* nothing" and falls back to the current repo with no word said (the same failure shape
-* `parseRepoTarget`, in `@bensandee/forgejo/connection`, refuses for the issue commands). */
 function listFlagPresent(rawArgs, flag) {
 	const long = `--${flag}`;
 	return rawArgs.some((token) => token === long || token.startsWith(`${long}=`));
@@ -998,9 +679,6 @@ function createCliOutput(jsonMode) {
 		}
 	};
 }
-/** Replace what {@link flushJsonOutput} writes with an error document, discarding any payload
-* already recorded by `json()` -- buffered notices are not discarded, they fold into the error
-* document the same way they fold into a payload. */
 function recordJsonError(document) {
 	state.error = document;
 	state.hasError = true;
@@ -1020,9 +698,6 @@ function buildFlushDocument() {
 		notices: state.notices
 	};
 }
-/** Write the single recorded document -- the error document if `recordJsonError` was called,
-* otherwise the recorded payload, each with buffered notices folded in under `notices` when
-* the buffer is non-empty -- and report whether anything was written. */
 function flushJsonOutput() {
 	const document = buildFlushDocument();
 	if (document === void 0) return false;
@@ -1030,18 +705,11 @@ function flushJsonOutput() {
 	state.wrote = true;
 	return true;
 }
-/** Whether {@link flushJsonOutput} has already written a document this process -- the guard the
-* premature-exit net (`@bensandee/cli-kit/json`) reads to tell a normal flush from a process that
-* died with the command still outstanding. */
 function jsonDocumentWritten() {
 	return state.wrote;
 }
 //#endregion
 //#region ../cli-kit/src/path-probe.ts
-/** The real {@link PathKind} probe the pre-run argument check uses. A path that exists but is not
-* a directory (a file, a socket) reads as `"file"`. A path stat cannot resolve at all -- a symlink
-* loop, an unsearchable parent -- reads as `"missing"`: `throwIfNoEntry` covers ENOENT and ENOTDIR
-* only, and a stat failure here would surface as a crash where the check owes a usage error. */
 function probeCliPath(value) {
 	try {
 		const stat = statSync(value, { throwIfNoEntry: false });
@@ -1053,7 +721,6 @@ function probeCliPath(value) {
 }
 //#endregion
 //#region ../cli-kit/src/run.ts
-/** {@link classifyThrown}, with the bin's `describeError` hook's wording swapped in for the message. */
 function classifyWithHook(error, verbose, hook) {
 	const classified = classifyThrown(error, verbose);
 	const worded = hook?.(error);
@@ -1062,55 +729,17 @@ function classifyWithHook(error, verbose, hook) {
 		message: redact(worded)
 	};
 }
-/**
-* Wait until a stream's internally-buffered data has been flushed to the OS.
-*
-* On Linux, `process.stdout`/`process.stderr` are ASYNCHRONOUS when the fd is
-* a pipe (only files and TTYs get synchronous writes). A `write("", cb)` call
-* queues behind any pending writes and invokes `cb` once the underlying fd has
-* actually accepted everything buffered so far -- including when nothing was
-* pending, so this is safe to call unconditionally. Errors (e.g. EPIPE from a
-* reader that closed early, such as `| head`) are swallowed: there is nothing
-* further to flush in that case, and `runCli()` below must not throw here.
-*/
 function drain(stream) {
 	return new Promise((resolve) => {
 		stream.write("", () => resolve());
 	});
 }
-/**
-* Raise the process log level to what `--verbose`/`-v`/`--trace` in `rawArgs` ask for.
-*
-* `--verbose`/`-v`/`--trace` are universal (see flags.ts): honoured on every command whether
-* or not it declares any of them, not just the ones that parse them from their own args. Resolving
-* the level from raw argv, in addition to the environment-only default at module load, is what
-* makes that carve-out honest rather than a flag the CLI accepts but never acts on. `-v` reads as
-* verbose here and as citty's version query only when it is the whole argv, which is the sole
-* shape citty's `runMain` intercepts -- so the two never contend.
-*
-* Exported because each bin must call it **before** {@link runCli}: a bin reports its
-* `$BST_ENV_FILE` load at module top level, which is ahead of anything that parses a flag, so
-* without this call that one line is the only diagnostic in the CLI the flags cannot reach.
-* Idempotent, and deliberately called twice -- `runCli` resolves the same level again off the
-* same argv, so a caller that is not a bin is unaffected.
-*/
 function applyVerbosityFromArgs(rawArgs) {
 	setLogLevel(resolveLogLevel({
 		verbose: rawArgs.includes("--verbose") || rawArgs.includes("-v"),
 		trace: rawArgs.includes("--trace")
 	}));
 }
-/**
-* Wrap a command so a `FatalError` or `TransientError` it throws prints as one line on stderr and
-* sets exit code 1, instead of reaching citty's `runMain`, which prints the whole stack.
-*
-* The guard sits on each command's own `run`, and not around `runMain`, because `runMain` is also
-* what answers `--help` and `--version` and renders usage for a `CLIError`. Wrapping the commands
-* leaves all three untouched. Sub-commands are wrapped lazily, as citty resolves them.
-*
-* Everything else keeps citty's trace: `UnexpectedError`, an unclassified error, and any error
-* under `--verbose`, where the trace is what was asked for.
-*/
 function guardCommand(def, verbose, hook) {
 	const { run, subCommands } = def;
 	const guarded = { ...def };
@@ -1132,20 +761,10 @@ function guardCommand(def, verbose, hook) {
 	};
 	return guarded;
 }
-/**
-* The text up to and including the first period that is followed by whitespace and an uppercase
-* letter, or all of it when there is none. The "x" in "e.g. x" is lowercase, so "e.g." and
-* "i.e." do not end a sentence.
-*/
 function firstSentence(text) {
 	const match = /^[\s\S]*?\.(?=\s+[A-Z])/.exec(text);
 	return match === null ? text : match[0];
 }
-/**
-* Render `cmd`'s usage with each subcommand's description cut to its first sentence, so the
-* command table stays one short row per command. `cmd`'s own description stays whole, and a
-* subcommand's children are cut the same way when its own help lists them.
-*/
 async function renderTableUsage(cmd, parent) {
 	return renderUsage(shortenChildren(cmd), parent);
 }
@@ -1176,19 +795,6 @@ function shortenChildren(def) {
 async function showTableUsage(cmd, parent) {
 	console.log(await renderTableUsage(cmd, parent) + "\n");
 }
-/**
-* Build and run a bin's CLI from its {@link RunCliConfig}.
-*
-* citty only calls process.exit() for --help and errors. On normal completion
-* a command may leave the event loop alive (bst's @clack/prompts leaves readline
-* interfaces, signal listeners and spinner intervals), so we still call
-* process.exit() explicitly -- but only after draining stdout/stderr. Exiting
-* immediately after `runMain` resolves used to truncate piped `--json` output
-* at the ~64KB pipe buffer:
-* `process.stdout.write(bigJson)` returns before the OS has accepted all of it,
-* and `process.exit()` discards whatever is still queued. See tooling-cli's
-* test/bin-json-piping.test.ts.
-*/
 async function runCli(config) {
 	const allSubCommands = config.subCommands;
 	const main = defineCommand({
@@ -1199,12 +805,6 @@ async function runCli(config) {
 		},
 		subCommands: allSubCommands
 	});
-	/**
-	* Render a `--json` error document and exit -- the shared tail every JSON-mode rejection here
-	* needs, whether from the strict-flag check, the `--json`-support check, a thrown error
-	* mid-command, or a command that recorded no payload. `never` return type: every call site
-	* ends the process, so nothing after a call to this needs its own unreachable-code guard.
-	*/
 	const exitWithJsonError = async (command, kind, message, detail) => {
 		recordJsonError(buildErrorDocument({
 			command,
@@ -1266,7 +866,6 @@ let current = {
 function setForgejoLogger(logger) {
 	current = logger;
 }
-/** Stable call-site surface: modules bind `log` once; injection swaps the target underneath. */
 const log = {
 	warn(message) {
 		current.warn(message);
@@ -1291,42 +890,15 @@ function parseGitUrl(urlStr) {
 		return null;
 	}
 }
-/**
-* The one place RELEASE_TOKEN / FORGEJO_TOKEN precedence lives. `||` (not `??`) on
-* purpose: CI injects RELEASE_TOKEN="" for an unset secret, which must fall through to
-* FORGEJO_TOKEN instead of masking it.
-*/
 function forgeTokenFromEnv(env) {
 	return env["RELEASE_TOKEN"] || env["FORGEJO_TOKEN"];
 }
-/**
-* The repository URL a caller acts on: the `origin` remote first, since a package may advertise a
-* public mirror rather than the host its commands act on; the package manifest's URL only as a
-* last resort. `null` when neither parses. Both reads are thunks because this module does no I/O,
-* and the second is called only when the first does not parse: an eager read would let a broken
-* manifest fail a repository whose `origin` already resolves. `readOrigin` returns the remote as
-* written, and this function normalizes it.
-*/
 function resolveRepoUrlFrom(readOrigin, readPackageUrl) {
 	const originUrl = normalizeGitUrl(readOrigin() ?? "");
 	if (originUrl !== null && parseGitUrl(originUrl) !== null) return originUrl;
 	const pkgUrl = readPackageUrl();
 	return pkgUrl !== null && parseGitUrl(pkgUrl) !== null ? pkgUrl : null;
 }
-/**
-* Resolve the Forgejo connection from the environment and one repository URL the caller finds
-* (git remote origin, else package.json; this module does no I/O). `repoUrl` is a thunk, called
-* only once the environment has not settled the connection, so a complete environment never
-* costs a git subprocess or a package.json read (and never fails on a malformed one).
-*
-* Priority:
-* 1. Environment variables (FORGEJO_SERVER_URL, FORGEJO_REPOSITORY, RELEASE_TOKEN)
-* 2. `repoUrl` (server URL and owner/repo parsed from it)
-*
-* For Forgejo, a token is always required ({@link forgeTokenFromEnv}). Returns `null` where the
-* repository is on github.com or there is no repository URL at all: the caller treats that as
-* GitHub (the gh CLI handles auth).
-*/
 function resolveForgejoConnection(env, repoUrl) {
 	const serverUrl = env["FORGEJO_SERVER_URL"];
 	const repository = env["FORGEJO_REPOSITORY"];
@@ -1354,7 +926,6 @@ function resolveForgejoConnection(env, repoUrl) {
 	};
 }
 const ISSUE_PATH = /^\/([^/]+\/[^/]+)\/(?:issues|pulls?)\/(\d+)\/?$/;
-/** Parse a bare issue number or a full issue URL. A URL also carries repo coordinates. */
 function parseIssueRef(input) {
 	if (input === void 0 || input.trim() === "") return {};
 	const value = input.trim();
@@ -1382,21 +953,11 @@ function parseIssueRef(input) {
 	}
 	throw new FatalError(`Not an issue number or issue URL: "${value}" (expected e.g. 273 or https://host/owner/repo/issues/273)`);
 }
-/**
-* A repository target that was given but blank. The message names no flag: the library does not
-* know which program, or which option, a caller received the value through, so each caller words
-* the refusal for its own surface.
-*/
 var RepoTargetEmptyError = class extends FatalError {
 	constructor() {
 		super("No repository URL was given.");
 	}
 };
-/**
-* An explicit repository target that names a different repository than the issue URL beside it.
-* Both fields are `serverUrl/repository`. The message names no flag, for the reason
-* {@link RepoTargetEmptyError} gives.
-*/
 var RepoTargetMismatchError = class extends FatalError {
 	given;
 	fromReference;
@@ -1406,14 +967,6 @@ var RepoTargetMismatchError = class extends FatalError {
 		this.fromReference = fromReference;
 	}
 };
-/**
-* Parse a repository URL option value into a target. `undefined` -- the option absent -- is the
-* only input meaning "not given": a present but blank value refuses instead of resolving from the
-* working directory, because both shapes that produce one come from a caller who believes they
-* targeted another repository: an unset shell variable expands to `""`, and so does an option
-* whose value fell off the end of the line and was coerced to an empty string. Answering either
-* from the current repo is the same number, a different object, and not a word said.
-*/
 function parseRepoTarget(input) {
 	if (input === void 0) return void 0;
 	if (input.trim() === "") throw new RepoTargetEmptyError();
@@ -1427,17 +980,6 @@ function parseRepoTarget(input) {
 		hostname: new URL(serverUrl).hostname
 	};
 }
-/**
-* Reconcile an issue ref's own target (from an issue URL) with an explicit repository option.
-* Letting `ref.target ?? parseRepoTarget(repo)` discard the option the moment the ref carries a
-* target of its own is silent: a caller who passes both a URL and a disagreeing option gets an
-* answer from the URL's repository with no sign the option was ignored.
-*
-* Absent one side, the other wins outright. Present on both sides, agreement (compared on the
-* parsed `serverUrl`/`repository`, not the raw strings, so a trailing slash or `.git` -- both of
-* which `parseRepoTarget` already normalizes away -- is never mistaken for a disagreement) resolves
-* quietly; disagreement throws, naming both repositories rather than picking one without a word.
-*/
 function resolveIssueTarget(refTarget, repo) {
 	const repoTarget = parseRepoTarget(repo);
 	if (refTarget === void 0) return repoTarget;
@@ -1445,10 +987,6 @@ function resolveIssueTarget(refTarget, repo) {
 	if (refTarget.serverUrl === repoTarget.serverUrl && refTarget.repository === repoTarget.repository) return refTarget;
 	throw new RepoTargetMismatchError(`${repoTarget.serverUrl}/${repoTarget.repository}`, `${refTarget.serverUrl}/${refTarget.repository}`);
 }
-/**
-* Normalize a git remote URL to a clean HTTPS URL.
-* Handles SSH (git@host:owner/repo.git) and HTTPS variants.
-*/
 function normalizeGitUrl(raw) {
 	const sshMatch = raw.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
 	if (sshMatch) return `https://${sshMatch[1]}/${sshMatch[2]}`;
@@ -1464,53 +1002,22 @@ function normalizeGitUrl(raw) {
 }
 //#endregion
 //#region src/describe-forge-error.ts
-/**
-* The text each `--repo` refusal carries on this bin. The library names no flag, so this is the
-* one place the wording lives; the same shape sits beside `bst-fj`'s entry.
-*/
 function describeForgeError(error) {
 	if (error instanceof RepoTargetEmptyError) return "--repo was given with no repository URL (expected e.g. https://host/owner/repo).";
 	if (error instanceof RepoTargetMismatchError) return `--repo disagrees with the issue URL: --repo names ${error.given}, the issue URL names ${error.fromReference}.`;
 }
 //#endregion
 //#region ../forgejo/src/fetch-retry.ts
-/** Production policy: 5 attempts, 250ms->2s exponential backoff (four gaps, ~3.75s total). */
 const DEFAULT_RETRY_POLICY = {
 	attempts: 5,
 	baseDelayMs: 250,
 	maxDelayMs: 2e3
 };
-/**
-* Per-request wall-clock timeout for every forge fetch -- a backstop against an *infinite* hang,
-* not a tight SLA. `globalThis.fetch` has no timeout, so a stalled keep-alive socket (the peer
-* sent FIN but never answers) makes a request neither resolve nor reject: the caller then hangs
-* forever on it, and `retryOnTransient` cannot help because it only catches *thrown* errors, not
-* an indefinite stall. With the timeout, a retried read gets a fresh attempt; a non-retried
-* write surfaces the timeout as its failure. Generous (healthy forge calls finish in well under a
-* second) so it never trips a slow-but-live request; the one call
-* that can legitimately exceed it -- a large release-asset upload -- opts out with `timeoutMs: 0`.
-*/
 const DEFAULT_FETCH_TIMEOUT_MS = 12e4;
-/**
-* A transport-level error a retry can recover from by opening a fresh socket: undici's thrown
-* `TypeError` ("fetch failed": DNS blip, dead keep-alive, socket hang-up), plus the
-* `AbortSignal.timeout` abort we attach ourselves (a `DOMException` named `TimeoutError`, or
-* `AbortError` on some undici paths) -- a stalled read is exactly what a retry is for. A
-* caller's own cancel also surfaces as an abort here; {@link retryOnTransient} checks the
-* caller's signal before this classifier, so a real cancel is rethrown and never retried.
-*/
 function isTransientTransportError(error) {
 	if (error instanceof TypeError) return true;
 	return error instanceof DOMException && (error.name === "TimeoutError" || error.name === "AbortError");
 }
-/**
-* Bound every request by the wall-clock cap, composing with -- never replaced by -- a signal the
-* caller brought: with both present the request aborts on whichever fires first, so threading a
-* cancel signal in can never silently disable the stall backstop. A disabled cap (`timeoutMs <=
-* 0`) returns `init` untouched, caller signal included. Called once per attempt -- an
-* already-fired timeout signal stays aborted, so a retried request must mint a new one rather
-* than reuse the timed-out attempt's.
-*/
 function withTimeoutSignal(init, timeoutMs) {
 	if (timeoutMs <= 0) return init;
 	const timeout = AbortSignal.timeout(timeoutMs);
@@ -1523,26 +1030,11 @@ function withTimeoutSignal(init, timeoutMs) {
 		signal: timeout
 	};
 }
-/** Exponential backoff (capped) between attempts; a non-positive base is a no-op (the test seam). */
 async function retryBackoff(attempt, baseDelayMs, maxDelayMs) {
 	if (baseDelayMs <= 0) return;
 	const delay = Math.min(baseDelayMs * 2 ** (attempt - 1), maxDelayMs);
 	await new Promise((resolve) => setTimeout(resolve, delay));
 }
-/**
-* Retry `fn` on a transient transport error (see {@link isTransientTransportError}: undici's
-* "fetch failed" TypeError, or our own `AbortSignal.timeout` abort) up to `policy.attempts`
-* times, with exponential backoff between tries. Any other thrown error propagates on the first
-* attempt -- only a transport-level error is transient. A resolved value (including a 4xx/5xx
-* `Response`) is never a throw, so it is never retried. After the last attempt fails, the final
-* error is re-thrown.
-*
-* Idempotency is the caller's contract: only wrap a `fn` whose re-execution converges to the same
-* state. `retryOnTransient` cannot and does not verify that.
-*
-* `callerSignal` is the caller's own cancel: once it has fired, every error -- transient-shaped
-* or not -- is rethrown at once, because a cancelled call must never be retried.
-*/
 async function retryOnTransient(fn, policy = DEFAULT_RETRY_POLICY, callerSignal = null) {
 	let lastError;
 	for (let attempt = 1; attempt <= policy.attempts; attempt++) try {
@@ -1555,14 +1047,6 @@ async function retryOnTransient(fn, policy = DEFAULT_RETRY_POLICY, callerSignal
 	}
 	throw lastError;
 }
-/**
-* Wrap a fetch so idempotent requests retry on a transient `TypeError` (see {@link
-* retryOnTransient}). A request is idempotent when its method is GET/HEAD (a read) OR the caller
-* passed `{ idempotent: true }` as the third arg -- the escape hatch for a mutating call that
-* converges (e.g. `updatePr`'s PATCH). A non-idempotent mutation (POST create/comment) is never
-* retried: "fetch failed" does not prove the request never landed server-side, so a re-send could
-* duplicate it. `policy` is injectable so tests run with `baseDelayMs: 0` and never wait.
-*/
 function fetchWithRetry(fetchImpl, policy = DEFAULT_RETRY_POLICY, defaultTimeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
 	return (input, init, retry) => {
 		const method = (init?.method ?? "GET").toUpperCase();
@@ -1577,47 +1061,17 @@ function fetchWithRetry(fetchImpl, policy = DEFAULT_RETRY_POLICY, defaultTimeout
 		}, callerSignal);
 	};
 }
-/**
-* A real-network {@link ForgeFetcher} with the default retry policy, for a caller that has no
-* executor of its own. `globalThis.fetch` is read at call time, so a
-* stub installed after this call is still seen.
-*/
 function createForgeFetcher(policy = DEFAULT_RETRY_POLICY) {
 	return { fetch: fetchWithRetry((input, init) => globalThis.fetch(input, init), policy) };
 }
 //#endregion
 //#region src/fetcher.ts
-/**
-* The one place a command gets its real fetcher. Every command reaches the network only through
-* this function, so a test mocks this module and no other.
-*/
 function cliFetcher() {
 	return createForgeFetcher();
 }
 //#endregion
 //#region ../forgejo/src/errors.ts
-/**
-* A refusal about the caller's reach rather than about the request: 401/403 (the token lacks the
-* scope) and 404 (the resource is absent, or present and invisible to this token -- the two are
-* indistinguishable by design on both forges).
-*
-* It extends `FatalError` and carries the identical message, so every existing caller sees exactly
-* what it saw before. The subclass exists for a caller reading an *optional* enrichment **behind a
-* proof the resource exists**, which can therefore degrade instead of failing: `viewIssue`'s
-* pulls read is that caller, and the only one. Catching plain `FatalError` there would also
-* swallow a 422 or a schema mismatch as "no access", which is why the narrower type exists.
-*
-* Whether to degrade stays with the caller; this layer only reports what the forge said.
-*
-* `name` stays `"FatalError"`: the base class types it as that literal, and the discriminator here
-* is `instanceof`, not the string.
-*/
 var ForgeAccessError = class extends FatalError {};
-/**
-* Request headers shared by every Forgejo API caller in this package. Sitting on the leaf module
-* that already owns {@link ForgejoConnection} is what lets `issues.ts`, `issue-labels.ts`,
-* `issue-comments.ts`, and `label-provisioning.ts` all use them with no edge back to `issues.ts`.
-*/
 function authHeaders$2(conn) {
 	return { Authorization: `token ${conn.token}` };
 }
@@ -1627,29 +1081,15 @@ function jsonHeaders(conn) {
 		"Content-Type": "application/json"
 	};
 }
-/** Shared "not found" wording so it isn't duplicated across every function that reads a repo. */
 function repoNotFoundMessage(conn) {
 	return `Repository ${conn.repository} not found (or the token cannot see it)`;
 }
-/** Base URL for a repo's issues endpoint -- shared by `issues.ts`, `issue-labels.ts`, and
-* `issue-comments.ts`, all of which mutate issue/PR state under this same route. */
 function issuesBase(conn) {
 	return `${conn.serverUrl}/api/v1/repos/${conn.repository}/issues`;
 }
-/** Shared "not found" wording for a numbered issue or PR (both forges number them from one
-* sequence). */
 function issueNotFoundMessage(conn, number) {
 	return `Issue #${String(number)} not found in ${conn.repository}`;
 }
-/**
-* Field names come from a real Forgejo response. Note `browser_download_url` --
-* NOT `download_url`. The URL is a web route (`/attachments/<uuid>`), not an
-* `/api/v1` route, and an API token does authenticate against it.
-*
-* Lives on this leaf module -- rather than on `issues.ts`, which normalizes the attachments
-* inline on an issue, or `issue-comments.ts`, which reads a comment's own attachments -- because
-* both need it and neither may import from the other.
-*/
 const AttachmentSchema = z.object({
 	id: z.number(),
 	name: z.string(),
@@ -1667,7 +1107,6 @@ function normalizeAttachment(raw) {
 		downloadUrl: raw.browser_download_url
 	};
 }
-/** Safely read response body text for inclusion in error messages. */
 async function responseBodyText(res) {
 	try {
 		const text = await res.text();
@@ -1681,13 +1120,6 @@ const SwaggerEnvelopeSchema = z.union([z.object({ message: z.literal("") }), z.o
 	message: z.string(),
 	url: z.string().regex(/\/api\/swagger$/)
 })]);
-/**
-* Detect Forgejo's signature "route not handled" response shape -- empty body
-* or a JSON envelope with either an empty `message` or a `url` pointing at
-* `/api/swagger`. Forgejo returns this from a 500 (and sometimes 404) when no
-* route handles the request, even though the status code suggests a
-* server-side fault.
-*/
 function isForgejoGenericServerErrorBody(body) {
 	if (body === "") return true;
 	try {
@@ -1698,13 +1130,6 @@ function isForgejoGenericServerErrorBody(body) {
 	}
 }
 const DISPATCH_VERB_PATTERN = /\bdispatch\b/i;
-/**
-* Map a non-2xx Forgejo response to a human-readable hint.
-*
-* Returns the most-likely cause first; callers still surface the raw body so an
-* uncommon failure mode isn't masked. Returns "" for unmapped codes (2xx/3xx,
-* teapots) so the caller can decide whether to include a Hint line at all.
-*/
 function forgejoErrorHint(status, body, operation) {
 	const isDispatch = DISPATCH_VERB_PATTERN.test(operation.verb);
 	const resource = operation.resource ?? "the resource";
@@ -1726,36 +1151,11 @@ function forgejoErrorHint(status, body, operation) {
 	}
 	return "";
 }
-/**
-* Build a richer error message for a non-2xx Forgejo API response.
-*
-* Reads, truncates, and redacts the body via {@link responseBodyText}; appends
-* a `Hint:` line when {@link forgejoErrorHint} has one; appends the raw body as
-* a `Response:` block. Callers still pick the error class (Transient vs Fatal).
-*/
 async function forgejoErrorMessage(res, operation) {
 	const body = await responseBodyText(res);
 	const hint = forgejoErrorHint(res.status, body, operation);
 	return `Failed to ${operation.verb} on Forgejo: ${String(res.status)} ${res.statusText}` + (hint ? `\nHint: ${hint}` : "") + (body ? `\nResponse: ${body}` : "");
 }
-/**
-* Classify a non-2xx Forgejo response. 404 is bad input (the named resource
-* doesn't exist -- not retryable). 401/403 is a credentials/scope problem --
-* also not retryable, and the single most common failure mode here (a token
-* missing the required scope returns 403). 422 is a validation failure (e.g.
-* a nonexistent label on create) -- retrying with the same input can never
-* succeed. 410 means issues are disabled on the repository -- also permanent
-* until repo config changes, not something a retry fixes. Anything else is
-* presumed transient (server hiccups, rate limiting, etc.).
-*
-* `notFoundMessage` lets a caller supply a resource-specific 404 message
-* (e.g. "Issue #<n> not found in owner/repo"); when omitted, the 404 case
-* falls back to {@link forgejoErrorMessage}'s generic (but still hinted)
-* message, which is what every `pr.ts` call site gets.
-*
-* The 404 and 401/403 cases throw {@link ForgeAccessError} -- a `FatalError` subclass with the
-* same message, so nothing here changes for a caller that only distinguishes fatal from transient.
-*/
 async function throwForgejoFailure(res, operation, notFoundMessage) {
 	if (res.status === 404) throw new ForgeAccessError(notFoundMessage ?? await forgejoErrorMessage(res, operation));
 	const message = await forgejoErrorMessage(res, operation);
@@ -1766,21 +1166,6 @@ async function throwForgejoFailure(res, operation, notFoundMessage) {
 }
 //#endregion
 //#region ../forgejo/src/commit-status.ts
-/**
-* The combined commit status, read as the per-job report the response already carries rather than
-* reduced to a single boolean. `CommitChecks.green` alone is a real consumer's whole need -- a
-* merge gate only ever asks "is it green" -- but a caller that reports on a PR's CI wants the
-* per-job list too, and the endpoint already returns it.
-*
-* The parse is deliberately two layers, and the layering is the whole point. The top-level schema
-* is byte-for-byte what `pr-merge.ts` has always required (`{ state, statuses }`), and `green` is
-* computed from it *before any entry is inspected*. Entries are then projected through a second,
-* all-nullish schema, so an entry shape this build cannot read degrades that one row of the report
-* and can never move the verdict. `pr-merge.ts`'s doc comment records the lesson this shape
-* encodes in prose: a schema that required a field the forge never sent (`state` on an entry, where
-* Forgejo sends `status`) once withheld every merge, silently, because the whole response
-* failed to parse over one field the verdict never reads.
-*/
 const CombinedStatusSchema = z.object({
 	state: z.string(),
 	statuses: z.array(z.unknown())
@@ -1793,7 +1178,6 @@ const CheckEntrySchema = z.object({
 	updated_at: z.string().nullish(),
 	id: z.number().nullish()
 });
-/** A single trailing ` (<word>)` parenthetical, stripped from a context to get its `name`. */
 const TRAILING_EVENT = / \([^()]+\)$/;
 function classifyVerdict(state) {
 	if (state === "success") return "good";
@@ -1810,11 +1194,6 @@ function updatedAtMillis(value) {
 	const parsed = Date.parse(value);
 	return Number.isNaN(parsed) ? 0 : parsed;
 }
-/**
-* Deduplicate entries by `context`, newest `updated_at` winning, falling back to `id`, then to
-* array order. An entry with no (or empty) `context` is keyed by its own index instead, so two
-* context-less entries never collapse into one row.
-*/
 function dedupeEntries(entries) {
 	const byKey = /* @__PURE__ */ new Map();
 	entries.forEach((entry, index) => {
@@ -1848,11 +1227,6 @@ function dedupeEntries(entries) {
 	sorted.sort((a, b) => a.index - b.index);
 	return sorted;
 }
-/**
-* Read a commit's combined status as a per-job report, scoped to `sha`. An unparseable response
-* returns `parsed: false` rather than throwing: a broken read must never look like a decision a
-* caller is entitled to make.
-*/
 async function readCommitChecks(executor, conn, sha) {
 	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/commits/${sha}/status`;
 	const res = await executor.fetch(url, { headers: { Authorization: `token ${conn.token}` } });
@@ -1917,14 +1291,9 @@ function repoBase$1(conn) {
 function authHeaders$1(conn) {
 	return { Authorization: `token ${conn.token}` };
 }
-/** A branch's own "not found" wording -- distinct from {@link repoNotFoundMessage} so a stale
-* cached branch name (e.g. after a default-branch rename) reports the resource that is actually
-* missing, not the repo it lives in. */
 function branchNotFoundMessage(conn, branch) {
 	return `Branch ${branch} not found in ${conn.repository}`;
 }
-/** A branch's head commit SHA -- the cheap "has anything landed?" probe a caller uses to decide
-* whether a clone is worth doing at all. */
 async function getBranchHeadSha(executor, conn, branch) {
 	const url = `${repoBase$1(conn)}/branches/${encodeURIComponent(branch)}`;
 	const res = await executor.fetch(url, { headers: authHeaders$1(conn) });
@@ -1936,16 +1305,6 @@ async function getBranchHeadSha(executor, conn, branch) {
 	if (!parsed.success) throw new UnexpectedError(`Unexpected branch response: ${parsed.error.message}`);
 	return parsed.data.commit.id;
 }
-/**
-* Whether the forge knows this branch at all -- the probe a caller runs before it asks the forge
-* to point a pull request at a branch.
-*
-* {@link getBranchHeadSha} cannot serve as this probe: its 404 goes through `throwForgejoFailure`
-* and throws `ForgeAccessError`, the same class a 403 throws, so a caller catching it would read a
-* token that cannot see the repository as a branch that was never pushed. Only a 404 answers
-* `false` here; every other non-ok status throws, because "I cannot tell" is never "it is
-* missing".
-*/
 async function branchExists(executor, conn, branch) {
 	const url = `${repoBase$1(conn)}/branches/${encodeURIComponent(branch)}`;
 	const res = await executor.fetch(url, { headers: authHeaders$1(conn) });
@@ -1959,7 +1318,6 @@ async function branchExists(executor, conn, branch) {
 //#endregion
 //#region ../cli-kit/src/git.ts
 const BRANCH_REF_PREFIX = "refs/heads/";
-/** The origin read gives up after this long, so a wedged remote lookup cannot hang a command. */
 const ORIGIN_READ_TIMEOUT_MS = 5e3;
 function defaultGitRunner(args, cwd, options) {
 	try {
@@ -1977,18 +1335,6 @@ function defaultGitRunner(args, cwd, options) {
 		return;
 	}
 }
-/**
-* Resolve the branch the current run is on.
-*
-* CI env wins: `GITHUB_REF` (also set by Forgejo Actions) is the source of truth
-* for whether this is a branch event -- tag and pull-request refs are deliberately
-* reported as `undefined` since they have no meaningful branch. On a branch event
-* the short name comes from `GITHUB_REF_NAME` (falling back to stripping the
-* prefix off `GITHUB_REF`). Without `GITHUB_REF`, falls back to local git.
-*
-* Returns `undefined` when the branch cannot be determined or the ref is not a
-* branch (tag, PR merge ref, detached HEAD).
-*/
 function resolveCurrentBranch(options) {
 	const env = options.env ?? process.env;
 	const ref = env["GITHUB_REF"];
@@ -2005,10 +1351,6 @@ function resolveCurrentBranch(options) {
 	if (branch === void 0 || branch === "HEAD") return void 0;
 	return branch;
 }
-/**
-* The raw output of `git remote get-url origin`, or `null` when there is no origin or `cwd` is not
-* a repository. Not normalized: an SSH remote comes back as written.
-*/
 function readOriginUrl(cwd, git = defaultGitRunner) {
 	return git([
 		"remote",
@@ -2017,7 +1359,6 @@ function readOriginUrl(cwd, git = defaultGitRunner) {
 	], cwd, { timeoutMs: ORIGIN_READ_TIMEOUT_MS }) ?? null;
 }
 const RepositorySchema = z.union([z.string(), z.object({ url: z.string() })]);
-/** The `repository` field of `cwd`'s `package.json` as a URL string, or `null` when absent. */
 function readPackageRepositoryUrl(cwd) {
 	const pkgPath = path.join(cwd, "package.json");
 	let raw;
@@ -2040,29 +1381,12 @@ function readPackageRepositoryUrl(cwd) {
 }
 //#endregion
 //#region src/connection.ts
-/**
-* The repository URL for `cwd`: the `origin` remote first, since `package.json` may advertise a
-* public mirror rather than the host the commands act on; `package.json#repository` only as a
-* last resort. `null` when neither parses.
-*/
 function resolveRepoUrl(cwd) {
 	return resolveRepoUrlFrom(() => readOriginUrl(cwd), () => readPackageRepositoryUrl(cwd));
 }
-/**
-* The connection a `--repo` value names. Every command in this bin needs both halves -- parse the
-* value, then resolve it against the working directory -- and this module already owns the second
-* and already imports the module the first lives in, so the pair is composed once here rather than
-* repeated per command.
-*/
 function requireForgejoTargetFromRepo(cwd, repo, githubRefusal, env = process.env) {
 	return requireForgejoTarget(cwd, parseRepoTarget(repo), githubRefusal, env);
 }
-/**
-* The Forgejo connection a command acts on. An explicit target (from an issue URL or `--repo`)
-* wins over the working directory. `githubRefusal` is the command's own sentence for a github.com
-* repository, which owes the reader the `gh` alternative. The environment settles the connection
-* before any git or `package.json` read, so CI with only the environment needs neither.
-*/
 function requireForgejoTarget(cwd, target, githubRefusal, env = process.env) {
 	if (target !== void 0) {
 		if (target.hostname === "github.com") throw new FatalError(githubRefusal);
@@ -2080,11 +1404,6 @@ function requireForgejoTarget(cwd, target, githubRefusal, env = process.env) {
 }
 //#endregion
 //#region ../forgejo/src/check-poll.ts
-/**
-* Commit-check classification and poll-read helpers shared by the forge-side check readers -- a PR's
-* checks and an arbitrary ref's status read the same `commit-status` primitive and poll it the same
-* way; only what each does with a settled result differs. The poll cadence is the caller's.
-*/
 function classifyBaseStatus(checks) {
 	if (!checks.parsed) return "unparseable";
 	if (checks.contexts.length === 0) return "no-status";
@@ -2092,20 +1411,10 @@ function classifyBaseStatus(checks) {
 	if (checks.contexts.some((check) => check.verdict === "pending")) return "pending";
 	return "red";
 }
-/** At least one status, and no entry still pending -- the same definition a wait loop polls toward. */
 function isSettled(checks) {
 	if (!checks.parsed || checks.contexts.length === 0) return false;
 	return !checks.contexts.some((check) => check.verdict === "pending");
 }
-/**
-* Whether the per-entry classification disagrees with the forge's own combined reduction --
-* either direction: every entry reads `good` or `skipped` but the combined state is not
-* `success`, or the combined state is `success` while some entry reads neither. A skipped entry
-* is not a divergence -- it is a job that did not run, which carries no information about the
-* code -- so it is folded into "settled good" here the same way it is everywhere else. The
-* combined state always wins the verdict (`classifyBaseStatus` never looks at this); a caller
-* only needs to know whether to surface a notice about a genuine one.
-*/
 function disagreesWithCombinedState(checks) {
 	if (!checks.parsed || checks.contexts.length === 0) return false;
 	const allSettledGood = checks.contexts.every((check) => check.verdict === "good" || check.verdict === "skipped");
@@ -2116,15 +1425,12 @@ function pushDisagreementNotice(notices, sha, checks) {
 	const notice = `The combined status ("${checks.state}") for ${sha} disagrees with this build's per-check classification -- the combined status wins the verdict.`;
 	if (!notices.includes(notice)) notices.push(notice);
 }
-/** No commit status was read -- the sentinel a `head-moved` report (which never reads the new
-* head's checks) or an exhausted retry budget (which has no trustworthy checks left) carries. */
 const EMPTY_CHECKS = {
 	parsed: false,
 	state: "",
 	green: false,
 	contexts: []
 };
-/** One poll's commit-status read, reduced to a {@link PollRead} a retry budget can count. */
 async function readPollChecks(fetcher, conn, sha) {
 	try {
 		const result = await readCommitChecks(fetcher, conn, sha);
@@ -2139,15 +1445,12 @@ async function readPollChecks(fetcher, conn, sha) {
 const DEFAULT_TIMEOUT_MS = 12e5;
 const DEFAULT_INTERVAL_MS = 15e3;
 const MIN_INTERVAL_MS = 5e3;
-/** The test-only override, ignored unless it is a positive integer, and never above production. */
 function envMsOverride(raw, productionMs) {
 	if (raw === void 0) return productionMs;
 	const parsed = Number(raw.trim());
 	if (!Number.isSafeInteger(parsed) || parsed <= 0) return productionMs;
 	return Math.min(parsed, productionMs);
 }
-/** `--timeout`/`--interval` in milliseconds, defaulted and floored. Separated from the wait loop
-* so a command can refuse an unparseable duration before it makes a single request. */
 function resolvePollTimings(options) {
 	const timeoutMs = options.timeout !== void 0 ? parseDuration(options.timeout, "--timeout") : DEFAULT_TIMEOUT_MS;
 	const requestedIntervalMs = options.interval !== void 0 ? parseDuration(options.interval, "--interval") : DEFAULT_INTERVAL_MS;
@@ -2158,7 +1461,6 @@ function resolvePollTimings(options) {
 }
 //#endregion
 //#region src/sleep.ts
-/** The production delay between `--wait` polls. Tests inject their own through the runners' `sleep` option. */
 function sleep(ms) {
 	return new Promise((resolve) => {
 		setTimeout(resolve, ms);
@@ -2166,16 +1468,6 @@ function sleep(ms) {
 }
 //#endregion
 //#region src/commit-status.ts
-/**
-* `bst-fj commit:status` -- query and report Forgejo commit status checks for an arbitrary commit
-* SHA, branch name, tag, or local git ref over `@bensandee/forgejo`'s `readCommitChecks`.
-*
-* Unlike `pr:checks` which requires an open pull request, this command queries commit check
-* contexts and the combined status reduction directly for any ref.
-*/
-/**
-* Resolve `--repo`, cwd connection, and the commit ref into a `CommitStatusTarget`.
-*/
 async function resolveCommitStatusTarget(fetcher, options) {
 	const targetRepo = parseRepoTarget(options.repo);
 	const conn = requireForgejoTarget(options.cwd, targetRepo, "commit:status is Forgejo-only: GitHub Actions publishes check runs, not commit statuses. Use `gh run list` / `gh run view` instead.");
@@ -2205,15 +1497,7 @@ async function resolveCommitStatusTarget(fetcher, options) {
 		url
 	};
 }
-/** A ref that is already a full commit SHA needs no resolution at all. */
 const FULL_SHA = /^[0-9a-f]{40}$/;
-/**
-* The forge's head SHA for `ref` as a branch, or `undefined` when the forge has no such branch --
-* a tag, or any other ref the commit-status API can read directly, which then passes through
-* verbatim. A server error still throws: passing through on a 5xx would silently answer about the
-* wrong commit. `ForgeAccessError` also covers 401/403, where pass-through costs nothing extra --
-* the status read that follows fails on the same credential.
-*/
 async function forgeBranchHeadSha(fetcher, conn, ref) {
 	try {
 		return await getBranchHeadSha(fetcher, conn, ref);
@@ -2285,9 +1569,6 @@ async function waitForSettledChecks$1(fetcher, target, notices, poll) {
 		await sleep(intervalMs);
 	}
 }
-/**
-* Query commit checks for the resolved target ref/SHA and produce a `CommitStatusReport`.
-*/
 async function runCommitStatus(fetcher, options) {
 	const timings = options.wait === true ? resolvePollTimings(options) : void 0;
 	const target = await resolveCommitStatusTarget(fetcher, options);
@@ -2305,9 +1586,6 @@ async function runCommitStatus(fetcher, options) {
 		elapsedMs: 0
 	});
 }
-/**
-* Render a `commit:status` report as human-readable text.
-*/
 function renderCommitStatus(report) {
 	const lines = report.checks.map((check) => {
 		const parts = [check.state, check.context];
@@ -2394,16 +1672,8 @@ const LabelSchema = z.object({
 	exclusive: z.boolean().optional()
 });
 const LabelListSchema = z.array(LabelSchema);
-/** Page size for `GET .../labels`. Also the signal that another page may exist. */
 const LABELS_PAGE_SIZE = 100;
-/** Hard cap on pages fetched, so a misbehaving server can't spin this forever. */
 const LABELS_MAX_PAGES = 20;
-/**
-* Fetch every repository label, paginating until a short page (or the page
-* cap) is hit. Without pagination, a repo with more labels than one page
-* holds would silently see only the first page -- turning a real label into a
-* false "no label named X" failure (see {@link resolveLabelIds}).
-*/
 async function fetchAllForgejoLabels(executor, conn) {
 	const labels = [];
 	for (let page = 1; page <= LABELS_MAX_PAGES; page++) {
@@ -2419,11 +1689,6 @@ async function fetchAllForgejoLabels(executor, conn) {
 	}
 	return labels;
 }
-/**
-* Forgejo's create-issue API takes label IDs, not names, so names must be
-* resolved first. A name with no match is a hard failure -- silently dropping
-* a requested label would be quiet data loss, not a graceful degradation.
-*/
 async function resolveLabelIds(executor, conn, names) {
 	if (names.length === 0) return [];
 	const labels = await fetchAllForgejoLabels(executor, conn);
@@ -2436,46 +1701,25 @@ async function resolveLabelIds(executor, conn, names) {
 		return match.id;
 	});
 }
-/** {@link LabelSpec} as a zod schema, so a hand-written spec fails at load rather than at the
-* first API call. Strict: an unknown field is a typo, not an extension point. */
 const LabelSpecSchema = z.strictObject({
 	name: z.string().min(1),
 	color: z.string().regex(/^#[0-9a-fA-F]{6}$/),
 	description: z.string(),
 	exclusive: z.boolean().optional()
 });
-/** Named label sets: each set name maps to the specs it provisions. */
 const LabelSetsSchema = z.record(z.string(), z.array(LabelSpecSchema));
-/** Forgejo echoes label color without a leading '#'; the spec writes one. Normalize before comparing. */
 function normalizeColor(color) {
 	return color.replace(/^#/, "").toLowerCase();
 }
-/** True when an existing label's color or description differs from what the spec asks for. Exclusivity is judged separately (see {@link auditForgejoLabels}) because it is a gate condition, not cosmetic. */
 function hasCosmeticDrift(existing, spec) {
 	return normalizeColor(existing.color ?? "") !== normalizeColor(spec.color) || (existing.description ?? "") !== spec.description;
 }
-/** True when a spec asks for `exclusive: true` and the live label does not carry it -- the one direction
-* that produces the silent wrong answer `labelDrifted` used to repair as a side effect (two labels
-* of one scope can coexist, and a reader sees whichever the forge lists first). */
 function isNonExclusive(existing, spec) {
 	return (spec.exclusive ?? false) && !(existing.exclusive ?? false);
 }
-/** True when the live label's exclusivity differs from the spec's in either direction -- what
-* `ensureForgejoLabels` reconciles. `isNonExclusive` stays one-directional: it is the gate
-* condition `auditRepoLabels` reads, and a spec asking for `exclusive: false` was never a gate
-* failure. */
 function isExclusivityDrifted(existing, spec) {
 	return (existing.exclusive ?? false) !== (spec.exclusive ?? false);
 }
-/**
-* Audit a repo's labels against `specs` with a single list fetch and no write -- the read half of
-* what `ensureForgejoLabels` used to do in one pass. Returns the name->id map for every existing
-* label (so a caller keeps the fetch-avoidance `ensureForgejoLabels` callers relied on) plus four
-* name lists: labels missing entirely, labels present but not exclusive when the spec asks for it,
-* labels whose exclusivity drifted in either direction, and labels with cosmetic (color/description)
-* drift alone. A missing label and a non-exclusive one are both gate conditions; exclusivity drift
-* and cosmetic drift are reported but never block.
-*/
 async function auditForgejoLabels(executor, conn, specs) {
 	const existing = await fetchAllForgejoLabels(executor, conn);
 	const byName = new Map(existing.map((label) => [label.name, label]));
@@ -2502,26 +1746,10 @@ async function auditForgejoLabels(executor, conn, specs) {
 		cosmeticDrift
 	};
 }
-/** The `<scope>/` portion of a label name, or `null` for a leaf-only name like `bug`. */
 function labelScope(name) {
 	const slash = name.indexOf("/");
 	return slash === -1 ? null : name.slice(0, slash + 1);
 }
-/**
-* The live labels a set has left behind: present on the repo, carrying a scope the set owns, and
-* not a member of the set. This is the drift {@link auditForgejoLabels} structurally cannot report
-* -- the audit is a fact about exactly the specs it is given, so a name deleted from a set is
-* absent from both the specs and the audit, and nothing notices it is still on the repo.
-*
-* Ownership is derived from the specs rather than declared, so a label set needs no new key: a set
-* owns a scope when one of its own members carries it. A leaf-only name (`bug`) owns nothing and
-* falls under nothing, which is what keeps a repo's ordinary labels out of the report in both
-* directions.
-*
-* Deliberately not a field on {@link LabelAudit}: a caller may audit against a *required* subset,
-* so a staleness computed from the audit's own specs would report every ensured-but-not-required
-* label as a stray. A caller passes the full set it provisions from.
-*/
 function staleLabelNames(specs, live) {
 	const owned = /* @__PURE__ */ new Set();
 	for (const spec of specs) {
@@ -2538,23 +1766,6 @@ function staleLabelNames(specs, live) {
 	stale.sort((a, b) => a.localeCompare(b));
 	return stale;
 }
-/**
-* Ensure every label in `specs` exists on the repo with the spec's color and description,
-* creating any that are missing and PATCHing any that {@link auditForgejoLabels} reports as
-* non-exclusive or cosmetically drifted. An ensure-loop like `ensureRelease`: instance label
-* templates only apply at repo creation, so a fresh repo has none of these.
-* Implemented over the audit so the two can never disagree about what "drifted" means.
-*
-* Reconciling existing labels (not just creating missing ones) is what backfills descriptions
-* onto labels created before they carried one -- the create-only version left every already-present
-* label with whatever description it happened to have, so an existing repo never
-* gained the self-documenting text.
-*
-* Returns the name->id map the audit already computed (existing labels plus any just created), so a
-* caller that goes on to mutate labels for the same repo can thread it
-* through `addForgejoIssueLabel` / `removeForgejoIssueLabel` and skip their own redundant list
-* fetch.
-*/
 async function ensureForgejoLabels(executor, conn, specs) {
 	const audit = await auditForgejoLabels(executor, conn, specs);
 	const labelIds = new Map(audit.labelIds);
@@ -2603,12 +1814,6 @@ async function ensureForgejoLabels(executor, conn, specs) {
 	}
 	return labelIds;
 }
-/**
-* Delete a repository label definition by id -- the write half of pruning: a label the
-* caller has already determined no longer belongs to a set's declared universe. Idempotent, like
-* `removeForgejoIssueLabel`: Forgejo returns 204 whether or not the label still exists, so a
-* retry after a transient blip is safe.
-*/
 async function deleteForgejoLabel(executor, conn, id) {
 	const res = await executor.fetch(`${conn.serverUrl}/api/v1/repos/${conn.repository}/labels/${String(id)}`, {
 		method: "DELETE",
@@ -2621,12 +1826,6 @@ async function deleteForgejoLabel(executor, conn, id) {
 }
 //#endregion
 //#region ../forgejo/src/issues.ts
-/**
-* Timestamps are plain strings on purpose: Forgejo returns offset-form
-* (`2026-07-13T09:23:13-05:00`), which `z.string().datetime()` rejects.
-* Unknown keys are stripped rather than rejected, so upstream additions
-* cannot break parsing.
-*/
 const IssueResponseSchema = z.object({
 	number: z.number(),
 	title: z.string(),
@@ -2640,11 +1839,6 @@ const IssueResponseSchema = z.object({
 	updated_at: z.string(),
 	closed_at: z.string().nullish(),
 	pull_request: z.unknown().nullish(),
-	/**
-	* Already inline on the issue response -- no separate fetch is needed to
-	* surface attachments. `nullish()` because the field may be absent or
-	* explicitly `null` depending on the endpoint.
-	*/
 	assets: z.array(AttachmentSchema).nullish()
 });
 const IssueListSchema = z.array(IssueResponseSchema);
@@ -2675,7 +1869,6 @@ function normalizeIssue(raw) {
 		assignees: (raw.assignees ?? []).map((assignee) => assignee.login)
 	};
 }
-/** Fetch a single issue by number. */
 async function getForgejoIssue(executor, conn, number) {
 	const res = await executor.fetch(`${issuesBase(conn)}/${String(number)}`, { headers: authHeaders$2(conn) });
 	if (!res.ok) await throwForgejoFailure(res, {
@@ -2690,15 +1883,6 @@ const DependencyResponseSchema = z.object({
 	repository: z.object({ full_name: z.string() }).nullish()
 });
 z.array(DependencyResponseSchema);
-/**
-* `type` is built first and only when present, so every pre-existing caller's URL stays
-* byte-identical to what it was before `since`/`sort`/`"all"` existed: a consumer may key a
-* fetch mock on a URL substring that has `type=issues` before the other params, and a caller
-* asking the same question as before has no reason to see a different query string.
-*
-* No `type` means both kinds interleaved -- verified against a live instance, where an untyped
-* `state=all&sort=leastupdate` page carries issues and pull requests together.
-*/
 function issueListParams(type, query) {
 	const params = new URLSearchParams(type === "all" ? {} : { type });
 	params.set("state", query.state);
@@ -2717,46 +1901,12 @@ async function fetchIssueListPage(executor, conn, params) {
 	}, repoNotFoundMessage(conn));
 	return parseIssueListOrThrow(await res.json());
 }
-/**
-* Normalize a raw detailed-list page and, for `type: "issues"`, drop pull requests -- the same
-* portable belt-and-braces filter {@link toIssueSummaries} applies for {@link listForgejoIssues},
-* because the live API really does still serve PRs on this path.
-*/
 function normalizeDetailedIssues(raw, type) {
 	const normalized = raw.map(normalizeIssue);
 	return type === "issues" ? normalized.filter((issue) => !issue.isPullRequest) : normalized;
 }
-/** Page size for {@link listForgejoIssuesDetailedPaged}. Also the "another page may exist"
-* signal, for the same reason {@link SEARCH_PAGE_SIZE} is: Forgejo clamps `limit` to its own
-* `api.MAX_RESPONSE_ITEMS` (`ToCorrectPageSize`), so a page shorter than this may just be the
-* clamp, not the end. */
 const DETAILED_LIST_PAGE_SIZE = 50;
-/** Hard cap on pages, so a misbehaving server cannot spin the read forever. */
 const DETAILED_LIST_MAX_PAGES = 20;
-/**
-* Body-preserving counterpart to {@link listForgejoIssues}, for a caller that summarizes bodies
-* (the repo snapshot) rather than just listing titles. `type=pulls` reads through this same
-* issues endpoint rather than the dedicated pulls endpoint: this listing carries no head branch
-* by design, and the pulls endpoint's own lister ({@link listPulls} conceptually, in `pr.ts`)
-* pages `state=all` to completion, which this caller does not want.
-*
-* Paginates because a caller's desired count (`query.limit`) may exceed what one request can
-* return -- Forgejo clamps `limit` to its own `api.MAX_RESPONSE_ITEMS`, so a single unpaginated
-* read at `limit: query.limit` can silently come back short of what was asked for (see
-* {@link DETAILED_LIST_PAGE_SIZE}). Pages at `DETAILED_LIST_PAGE_SIZE`, accumulating until an
-* empty raw page, the page cap, or until `query.limit` entries are in hand, whichever comes
-* first -- stopping early keeps a caller's own "> cap" truncation check meaningful without
-* reading further pages than it needs.
-*
-* The raw (pre-filter) page length is what decides "another page may exist", not the
-* post-PR-filter count: a full raw page of issues that happens to include several PRs would
-* otherwise filter down below `DETAILED_LIST_PAGE_SIZE` and end pagination early, silently
-* dropping the issues on the pages after it.
-*
-* `options.onPageCap` fires only when the cap ended the read short of `query.limit`: the limit
-* check above runs before the cap check, so a walk that reaches the last allowed page with the
-* limit already satisfied never gets here, and a caller can read the callback as plain truncation.
-*/
 async function listForgejoIssuesDetailedPaged(executor, conn, query, options) {
 	const issues = [];
 	for (let page = 1; page <= DETAILED_LIST_MAX_PAGES; page++) {
@@ -2775,9 +1925,7 @@ async function listForgejoIssuesDetailedPaged(executor, conn, query, options) {
 	}
 	return issues;
 }
-/** Page size for `GET /user/repos`. Also the "another page may exist" signal. */
 const USER_REPOS_PAGE_SIZE = 50;
-/** Hard cap on pages, so a misbehaving server cannot spin startup forever. */
 const USER_REPOS_MAX_PAGES = 20;
 const UserRepoSchema = z.object({
 	full_name: z.string(),
@@ -2789,14 +1937,6 @@ const UserRepoSchema = z.object({
 	}).nullish()
 });
 const UserRepoListSchema = z.array(UserRepoSchema);
-/**
-* Every repo the token can access, via Forgejo's `/user/repos`, each tagged with whether it has
-* write (push or admin) access. Inviting the account as a collaborator is the grant, and
-* membership exists the moment it is invited. `canWrite` is false for a read-only repo; the
-* caller enumerates it but should write nothing there. Paginates until an empty page: Forgejo clamps
-* `limit` (ToCorrectPageSize), so a short page is not a reliable end signal -- same reason as
-* {@link searchForgejoIssues}.
-*/
 async function fetchAccessibleRepos(executor, serverUrl, token) {
 	const headers = { Authorization: `token ${token}` };
 	const repos = [];
@@ -2823,12 +1963,6 @@ async function fetchAccessibleRepos(executor, serverUrl, token) {
 	}
 	return repos;
 }
-/**
-* Create an issue. Label names are resolved to IDs first (see `resolveLabelIds` in
-* `label-provisioning.ts`), using `input.labelIds` where it already has a name and falling back
-* to a list fetch only for the names it lacks -- the same split `replaceForgejoIssueLabelsByName`
-* (`issue-labels.ts`) uses.
-*/
 async function createForgejoIssue(executor, conn, input) {
 	const labels = [];
 	const missing = [];
@@ -2855,18 +1989,6 @@ async function createForgejoIssue(executor, conn, input) {
 	}, repoNotFoundMessage(conn));
 	return normalizeIssue(parseIssueOrThrow(await res.json()));
 }
-/**
-* Edit an issue's title and/or body. A field absent from `patch` is absent from the request --
-* `JSON.stringify` drops an `undefined` value, so an omitted field reaches Forgejo as "leave it
-* alone" rather than as an explicit null that would blank the authored text.
-*
-* That distinction is the function's entire contract, not an implementation detail: resolving an
-* omitted body to a *derived* one and PATCHing it over whatever an author had written is how
-* several PRs lost their descriptions. This function cannot repeat that, because there is
-* nothing here to derive from and nothing is sent for a field not given.
-*
-* Idempotent -- a PATCH to fixed values converges, so a transient network blip is safe to retry.
-*/
 async function updateForgejoIssue(executor, conn, number, patch) {
 	const res = await executor.fetch(`${issuesBase(conn)}/${String(number)}`, {
 		method: "PATCH",
@@ -2882,15 +2004,6 @@ async function updateForgejoIssue(executor, conn, number, patch) {
 	}, issueNotFoundMessage(conn, number));
 	return normalizeIssue(parseIssueOrThrow(await res.json()));
 }
-/**
-* Set an issue's open/closed state. Writes issue state and nothing else -- title and body are
-* untouched, unlike {@link updateForgejoIssue}'s patch, which deliberately carries neither state
-* nor any other field a caller might be tempted to widen it with (see that function's doc comment
-* for the data-loss bug that narrowness fixes). A third field on that patch would invite the same
-* accident; state gets its own function instead.
-*
-* Idempotent -- Forgejo converges to the given state, so a transient blip is safe to retry.
-*/
 async function setForgejoIssueState(executor, conn, number, state) {
 	const res = await executor.fetch(`${issuesBase(conn)}/${String(number)}`, {
 		method: "PATCH",
@@ -2905,14 +2018,11 @@ async function setForgejoIssueState(executor, conn, number, state) {
 }
 //#endregion
 //#region ../forgejo/src/label-sync.ts
-/** `check` wins over `dryRun`; neither means apply. */
 function resolveSyncMode(check, dryRun) {
 	if (check) return "check";
 	if (dryRun) return "dry-run";
 	return "apply";
 }
-/** An explicit `owner/repo` target shares the base connection's server and token -- only the
-* repository portion changes, the same convention `resolveFleetTargets` uses. */
 function targetConnection(base, repo) {
 	if (repo === void 0) return base;
 	return {
@@ -2920,9 +2030,6 @@ function targetConnection(base, repo) {
 		repository: repo
 	};
 }
-/** Every repo the token can write to, discovered live -- no configured repo list.
-* The server URL and token come from the base connection; only the repository portion varies per
-* target, the same convention `targetConnection` uses. */
 async function resolveFleetTargets(fetcher, base) {
 	return (await fetchAccessibleRepos(fetcher, base.serverUrl, base.token)).filter((repo) => repo.canWrite).map((repo) => targetConnection(base, repo.fullName));
 }
@@ -2963,17 +2070,6 @@ async function syncOneRepo(params) {
 	}
 	return outcome;
 }
-/**
-* Ensure (or, under `check`/`dry-run`, only report) that every target repo carries `specs`.
-* Never touches a label outside `specs` -- both `auditForgejoLabels` and `ensureForgejoLabels`
-* only ever look at the names they are given. `apply` re-audits inside `ensureForgejoLabels`
-* rather than threading the first audit's label-id map through: one extra idempotent GET per
-* repo, traded for not reaching into `ensureForgejoLabels`'s internals from the caller.
-*
-* `contained` governs failure handling only: by default a throw from one repo's sync propagates
-* and stops the run. With `contained: true` one repo's failure is recorded in `failures` and the
-* run continues over the rest.
-*/
 async function syncLabelSet(params) {
 	const { fetcher, targets, specs, setName, mode, contained, prune, pruneAllowlist } = params;
 	const specList = [...specs];
@@ -3034,11 +2130,6 @@ function syncSummaryLines(result) {
 }
 //#endregion
 //#region src/label-sets-file.ts
-/**
-* The specs of one named set in a label-sets file: a JSON object whose keys are set names and
-* whose values are arrays of label specs. Every failure names the file, and all of them happen
-* before any request, so a bad file never leaves a repo half-synced.
-*/
 function readLabelSet(path, setName) {
 	let raw;
 	try {
@@ -3131,10 +2222,6 @@ const listCommand$1 = defineCommand({
 		renderList(result);
 	}
 });
-/**
-* `sync` has no `--prune`. Deleting a label inside a scope is defensible only where the tool owns
-* that scope, and this command owns none: a stale label is reported and left in place.
-*/
 const syncCommand = defineCommand({
 	meta: {
 		name: "sync",
@@ -3198,10 +2285,6 @@ const syncCommand = defineCommand({
 		if (mode === "check" && result.drifted || result.failures.length > 0) process.exitCode = 1;
 	}
 });
-/**
-* `labels` is the generic label writer: it provisions whatever set a file names. The agent's own
-* label set is written by `bst-agent agent:labels`, not here.
-*/
 const labelsCommand = defineCommand({
 	meta: {
 		name: "labels",
@@ -3218,20 +2301,11 @@ const labelsCommand = defineCommand({
 });
 //#endregion
 //#region ../forgejo/src/fetcher.ts
-/**
-* A far larger cap for the two calls that legitimately transfer a whole file -- a release-asset
-* upload and an attachment download. Still finite, so "no forge request hangs forever" stays a
-* true invariant, but generous enough that a slow-but-live transfer is never aborted mid-stream.
-* Threaded via `RetryHint.timeoutMs` at those call sites.
-*/
 const LONG_FETCH_TIMEOUT_MS = 6e5;
 //#endregion
 //#region ../forgejo/src/releases.ts
-/** Patient-repair attempts (delete frozen release, wait, retry) before escalating. */
 const SETTLE_ATTEMPTS = 4;
-/** Base backoff between patient-repair attempts; doubles each attempt. */
 const SETTLE_BASE_DELAY_MS = 2e3;
-/** Cap on a single patient-repair backoff. */
 const SETTLE_MAX_DELAY_MS = 16e3;
 const ReleaseSchema = z.object({
 	id: z.number(),
@@ -3241,31 +2315,11 @@ const ReleaseSchema = z.object({
 	html_url: z.string().nullish(),
 	prerelease: z.boolean().optional()
 });
-/**
-* Detect the signature of a broken Forgejo release: a `created_at` that maps to
-* the Unix epoch (`created_unix = 0`).
-*
-* Forgejo auto-creates a "tag placeholder" release row when a tag is pushed.
-* If our `POST /releases` races that placeholder, Forgejo promotes the
-* placeholder in place (flipping `is_tag` to false) **without** resetting
-* `created_unix`, leaving a published release stuck at the epoch. Such a
-* release sorts as the oldest, so `/releases/latest` never returns it.
-*
-* The epoch renders as `1969-12-31T18:00:00-06:00` or `1970-01-01T00:00:00Z`
-* depending on the server timezone; both parse to `<= 0` ms. A missing or
-* unparseable date is treated as broken too, so the caller repairs rather than
-* ships it.
-*/
 function isEpochReleaseDate(date) {
 	if (!date) return true;
 	const ms = new Date(date).getTime();
 	return Number.isNaN(ms) || ms <= 0;
 }
-/**
-* Fetch the Forgejo release for a tag, returning the parsed object or `null`
-* when no release exists (404). Unlike {@link findRelease}, this exposes the
-* release `id` and dates so callers can inspect/repair an epoch-dated release.
-*/
 async function getReleaseByTag(executor, conn, tag) {
 	const encodedTag = encodeURIComponent(tag);
 	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/releases/tags/${encodedTag}`;
@@ -3279,14 +2333,6 @@ async function getReleaseByTag(executor, conn, tag) {
 	if (!parsed.success) throw new UnexpectedError(`Unexpected release response: ${parsed.error.message}`);
 	return parsed.data;
 }
-/**
-* Create a Forgejo release for a given tag.
-*
-* When `options.target` (a commit SHA or branch) is provided and the tag does
-* not yet exist, Forgejo **creates the tag itself** from that commitish and
-* stamps `created_unix = now` synchronously -- sidestepping the buggy async
-* stamping of a pushed tag. The created tag is lightweight.
-*/
 async function createRelease(executor, conn, tag, options = {}) {
 	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/releases`;
 	const payload = {
@@ -3309,14 +2355,6 @@ async function createRelease(executor, conn, tag, options = {}) {
 		resource: tag
 	}));
 }
-/**
-* Delete a git tag from the repository (`DELETE /repos/{repo}/tags/{tag}`).
-*
-* Used by {@link ensureRelease} to take tag ownership away from the buggy
-* push-ingestion path: once the tag is gone, recreating the release with a
-* `target_commitish` makes Forgejo create the tag fresh with a real date. A 404
-* (already gone) is treated as success.
-*/
 async function deleteTag(executor, conn, tag) {
 	const encodedTag = encodeURIComponent(tag);
 	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/tags/${encodedTag}`;
@@ -3334,11 +2372,6 @@ const TagSchema = z.looseObject({
 	id: z.string(),
 	commit: z.object({ sha: z.string().regex(/^[0-9a-f]{40}$/) })
 });
-/**
-* The commit a tag points at (`GET /repos/{repo}/tags/{tag}`), or `null` when the forge has no
-* such tag. For an annotated tag, `id` and `commit.url` hold the tag object's SHA; only
-* `commit.sha` is the commit, so that is the field read.
-*/
 async function getTagCommit(executor, conn, tag) {
 	const encodedTag = encodeURIComponent(tag);
 	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/tags/${encodedTag}`;
@@ -3352,12 +2385,6 @@ async function getTagCommit(executor, conn, tag) {
 	if (!parsed.success) throw new UnexpectedError(`Unexpected tag response: ${parsed.error.message}`);
 	return parsed.data.commit.sha;
 }
-/**
-* Delete a Forgejo release by id. Does **not** delete the underlying git tag
-* (no `delete_tag` query param) -- the tag is the source of truth, and a
-* subsequent `POST /releases` relies on it still existing to insert a fresh
-* row with `created_unix = now`. A 404 (already gone) is treated as success.
-*/
 async function deleteRelease(executor, conn, releaseId) {
 	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/releases/${String(releaseId)}`;
 	const res = await executor.fetch(url, {
@@ -3369,21 +2396,6 @@ async function deleteRelease(executor, conn, releaseId) {
 		resource: String(releaseId)
 	}));
 }
-/**
-* Flag an existing Forgejo release as a prerelease (`PATCH /repos/{repo}/releases/{id}`).
-*
-* {@link ensureRelease} uses this on the path where the release was already there, and so does a
-* rerun, so a rerun over a release an earlier unflagged run created can still
-* keep the forge's Latest pointer off a prerelease. It sets the flag and never clears it, which is
-* why the body is fixed at
-* `{ prerelease: true }` and why the write is a fixed-field PATCH: `{ idempotent: true }`, the
-* convention every other fixed-field PATCH in this package passes (see `updateForgejoComment` in
-* `issue-comments.ts`), because a re-sent convergent PATCH is a no-op.
-*
-* The JSON body is {@link createRelease}'s shape (one `Authorization` header plus a content type),
-* but unlike {@link deleteRelease} against the same URL a 404 is **not** tolerated here: a row that
-* vanished mid-run means the flag was not applied, and the caller must know.
-*/
 async function markReleasePrerelease(executor, conn, releaseId, tag) {
 	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/releases/${String(releaseId)}`;
 	const res = await executor.fetch(url, {
@@ -3399,27 +2411,6 @@ async function markReleasePrerelease(executor, conn, releaseId, tag) {
 		resource: tag
 	}));
 }
-/**
-* Ensure a Forgejo release exists for a tag **with a real created date**.
-*
-* Forgejo stamps a pushed annotated tag's date *asynchronously*; a release
-* creation that races that stamp freezes the row at the Unix epoch (see
-* {@link isEpochReleaseDate}) -- a published-but-invisible release, because
-* `/releases/latest` sorts by date. The failure is intermittent. The repair:
-*
-* 1. A real-dated release already exists -> `"exists"`.
-* 2. Otherwise create the release and read it back. On epoch, delete the frozen
-*    release and wait (increasing backoff) for Forgejo to settle the tag's date,
-*    then retry -- **preserving the pushed (annotated) tag**. The frozen release
-*    is never deleted-and-left-empty.
-* 3. If the date still never settles and a `target` commit is known, delete the
-*    tag and recreate the release with `target_commitish` so **Forgejo creates
-*    the tag itself**, stamped `now`. The tag becomes lightweight. -> `"repaired"`.
-* 4. If nothing yields a real date, leave a visible release row (rather than only
-*    an invisible tag) and throw loudly.
-*
-* Returns `{ status, release }` -- see {@link EnsureReleaseOutcome}.
-*/
 async function ensureRelease(executor, conn, tag, options = {}) {
 	const attempts = options.attempts ?? SETTLE_ATTEMPTS;
 	const baseDelayMs = options.baseDelayMs ?? SETTLE_BASE_DELAY_MS;
@@ -3499,17 +2490,12 @@ async function recreateTagViaApi(executor, conn, tag, opts) {
 	}
 	return null;
 }
-/**
-* The `{ id, url }` projection of a release row carried back to a caller. A server that omits
-* `html_url` yields `url: null` -- the id is still the row's identity.
-*/
 function releaseRef(release) {
 	return {
 		id: release.id,
 		url: release.html_url ?? null
 	};
 }
-/** Exponential backoff (capped) between patient-repair attempts; a non-positive base is a no-op. */
 async function settleBackoff(attempt, baseDelayMs) {
 	if (baseDelayMs <= 0) return;
 	const delay = Math.min(baseDelayMs * 2 ** (attempt - 1), SETTLE_MAX_DELAY_MS);
@@ -3572,25 +2558,11 @@ const ActionSecretListSchema = z.object({
 	total_count: z.number()
 });
 z.object({ sha1: z.string() });
-/**
-* The forge's own rules for an Actions secret name, mirrored from Forgejo's
-* `models/secret/secret.go` (`ValidateName`). GitHub reserves `GITHUB_` and a
-* leading digit as well, so a name this accepts is usable on both forges.
-*
-* A rejected name is not a soft failure: the API answers `invalid secret name`,
-* so the secret can never be created, and every workflow referencing it
-* resolves `${{ secrets.X }}` to the empty string instead.
-*/
 const NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const FORBIDDEN_PREFIX_PATTERN = /^(FORGEJO_|GITEA_|GITHUB_|[0-9])/i;
 function isValidSecretName(name) {
 	return NAME_PATTERN.test(name) && !FORBIDDEN_PREFIX_PATTERN.test(name);
 }
-/**
-* Set (or overwrite) a Forgejo Actions secret on a repository.
-*
-* Uses PUT which is idempotent -- creates or overwrites.
-*/
 async function setActionSecret(executor, conn, secretName, secretValue) {
 	const [owner, repo] = conn.repository.split("/");
 	const url = `${conn.serverUrl}/api/v1/repos/${owner}/${repo}/actions/secrets/${encodeURIComponent(secretName)}`;
@@ -3607,12 +2579,6 @@ async function setActionSecret(executor, conn, secretName, secretValue) {
 		resource: secretName
 	}));
 }
-/**
-* List Forgejo Actions secret names for a repository.
-*
-* Returns only names -- Forgejo never exposes secret values.
-* Paginates automatically to collect all secrets.
-*/
 async function listActionSecrets(executor, conn) {
 	const [owner, repo] = conn.repository.split("/");
 	const names = [];
@@ -3633,11 +2599,6 @@ async function listActionSecrets(executor, conn) {
 	}
 	return names;
 }
-/**
-* Delete a Forgejo Actions secret from a repository.
-*
-* Returns silently on success. Throws on failure (including 404 if the secret doesn't exist).
-*/
 async function deleteActionSecret(executor, conn, secretName) {
 	const [owner, repo] = conn.repository.split("/");
 	const url = `${conn.serverUrl}/api/v1/repos/${owner}/${repo}/actions/secrets/${encodeURIComponent(secretName)}`;
@@ -3695,7 +2656,6 @@ async function runSecretsDelete(fetcher, config) {
 }
 //#endregion
 //#region src/commands/secrets.ts
-/** Read secret value from --body flag or stdin. */
 function readSecretValue(body) {
 	if (body) return body;
 	try {
@@ -3826,15 +2786,10 @@ const secretsCommand = defineCommand({
 });
 //#endregion
 //#region ../forgejo/src/user.ts
-/** The user a token belongs to, and the noreply address a commit uses when that user hides theirs. */
 const AuthenticatedUserSchema = z.object({
 	login: z.string(),
 	email: z.string().nullish()
 });
-/**
-* Read `GET /user`. A non-ok response is a value, not a throw: a token missing `read:user` is an
-* ordinary answer the caller words itself. An empty `email` (a private address) is `null`.
-*/
 async function getAuthenticatedUser(executor, conn, signal = null) {
 	const res = await executor.fetch(`${conn.serverUrl}/api/v1/user`, {
 		headers: authHeaders$2(conn),
@@ -3862,11 +2817,6 @@ const WebhookSchema = z.object({
 	config: z.record(z.string(), z.string()).optional()
 });
 const WebhookListSchema = z.array(WebhookSchema);
-/**
-* Returns a status struct instead of throwing, so it deliberately does not use
-* {@link forgejoErrorMessage} -- the caller branches on `status` rather than
-* catching an error.
-*/
 async function fetchHooks(executor, conn, endpoint) {
 	const res = await executor.fetch(`${conn.serverUrl}/api/v1${endpoint}`, { headers: { Authorization: `token ${conn.token}` } });
 	if (res.status === 401 || res.status === 403) return {
@@ -3888,28 +2838,18 @@ async function fetchHooks(executor, conn, endpoint) {
 		hooks: parsed.data
 	};
 }
-/** List system-level webhooks. Requires admin token (read:admin scope). */
 async function listSystemHooks(executor, conn) {
 	return fetchHooks(executor, conn, "/admin/hooks");
 }
-/** List webhooks owned by the authenticated user. Requires read:user scope. */
 async function listUserHooks(executor, conn) {
 	return fetchHooks(executor, conn, "/user/hooks");
 }
-/** List webhooks for an organization. Requires read:organization scope. */
 async function listOrgHooks(executor, conn, org) {
 	return fetchHooks(executor, conn, `/orgs/${encodeURIComponent(org)}/hooks`);
 }
-/** List webhooks for a repository. Requires read:repository + repo admin. */
 async function listRepoHooks(executor, conn, repository) {
 	return fetchHooks(executor, conn, `/repos/${repository}/hooks`);
 }
-/**
-* Probe whether the token has admin access by requesting `/admin/users?limit=1`.
-*
-* Returns true on 2xx, false on 401/403. Any other status is treated as not-admin
-* to keep enumeration conservative.
-*/
 async function hasAdminAccess(executor, conn) {
 	return (await executor.fetch(`${conn.serverUrl}/api/v1/admin/users?limit=1`, { headers: { Authorization: `token ${conn.token}` } })).ok;
 }
@@ -3934,10 +2874,6 @@ async function paginate(executor, conn, endpoint, verb, extract) {
 	}
 	return all;
 }
-/**
-* List organizations. When `mode` is "admin", uses `/admin/orgs` (all orgs on
-* the instance). When "user", uses `/user/orgs` (only the token user's orgs).
-*/
 async function listOrgs(executor, conn, mode) {
 	const endpoint = mode === "admin" ? "/admin/orgs" : "/user/orgs";
 	return (await paginate(executor, conn, endpoint, "list orgs", (raw) => {
@@ -3947,7 +2883,6 @@ async function listOrgs(executor, conn, mode) {
 	})).map((o) => o.username);
 }
 const RepoSearchSchema = z.object({ data: z.array(z.object({ full_name: z.string() })) });
-/** List repositories visible to the token via `/repos/search`. */
 async function searchRepos(executor, conn) {
 	return (await paginate(executor, conn, "/repos/search", "list repos", (raw) => {
 		const parsed = RepoSearchSchema.safeParse(raw);
@@ -3957,7 +2892,6 @@ async function searchRepos(executor, conn) {
 }
 //#endregion
 //#region src/commands/webhooks.ts
-/** Render a WebhookFetchStatus, logging warnings for unauthorized/error cases. */
 function collectGroup(label, scopeHint, status) {
 	if (status.status === "ok") return status.hooks.length > 0 ? {
 		label,
@@ -4035,30 +2969,6 @@ const webhooksCommand = defineCommand({
 });
 //#endregion
 //#region ../forgejo/src/actions.ts
-/**
-* The Actions reads: the one place in this package that talks to Forgejo's Actions surface, beside
-* `secrets.ts` which already speaks to `/actions/`. What used to be one composed read is now the
-* pieces that compose it -- {@link getActionsRunByNumber}, {@link listActionsRunJobs},
-* {@link fetchActionsJobLogById} -- with {@link fetchActionsJobLog} kept as the composed read its
-* existing callers use, and {@link listActionsRuns} beside them as the paged listing.
-*
-* **Checked against a live instance (2026-09-29).** A status entry's `targetUrl` carries
-* `{run, index}` and `run` there is the repo's
-* run **number**, not the run id the API's `/actions/runs/{id}` paths take -- passing the number
-* as an id silently reads an unrelated, older run. So the resolution is three reads: the run by
-* `?run_number=`, its jobs (a bare array, in the web UI's `/jobs/<index>` order), then the job's
-* log. It is **not** derived from `GET .../actions/tasks`, which was measured returning an
-* unrelated job's log for the same input. Every caller of {@link fetchActionsJobLog} must fail open on any error --
-* this module throws on one rather than swallowing it, exactly like every other read in this
-* package, so the caller's fail-open decision is made once, in one place, rather than half-hidden
-* in here.
-*/
-/**
-* A forge timestamp as the instance wrote it, or `null`. Nullish and empty are `null`, and so is
-* any time at or before the Unix epoch: the instance writes the epoch (in its own zone, such as
-* `1969-12-31T18:00:00-06:00`) for a run that has not started, and Go's zero time (`0001-...`)
-* elsewhere. Passing either through would make every duration derived from it meaningless.
-*/
 function forgeTimestamp(value) {
 	if (value === null || value === void 0 || value === "") return null;
 	const ms = Date.parse(value);
@@ -4076,7 +2986,6 @@ const ActionsRunRecordSchema = z.object({
 	status: z.string().nullish(),
 	started: z.string().nullish(),
 	stopped: z.string().nullish(),
-	/** Nanoseconds (a Go `time.Duration`); absent until the run finishes. */
 	duration: z.number().nullish(),
 	html_url: z.string().nullish()
 });
@@ -4104,19 +3013,7 @@ function toActionsRun(record) {
 		url: record.html_url ?? null
 	};
 }
-/** A ceiling for a reader of the whole log, passed as `{ head: MAX_WHOLE_LOG_CHARS }`: well over
-* the 5 MB logs measured on this repo, and low enough that no reader receives an unbounded body. */
 const MAX_WHOLE_LOG_CHARS = 67108864;
-/**
-* Look a run up by the number the web UI and every `targetUrl` use, and report the whole record
-* rather than only its id. Sends `page` and `limit` with the filter -- without them the instance
-* answers a `run_number` query with every run it holds.
-*
-* No run with that number is a {@link FatalError}: the caller named something that does not
-* exist. A record whose number is not the one asked for is an {@link UnexpectedError}, because
-* an instance that ignored the filter would otherwise hand back its newest run under the
-* caller's number. Also throws on a non-2xx or an unparseable response.
-*/
 async function getActionsRunByNumber(executor, conn, runNumber) {
 	const params = new URLSearchParams({
 		run_number: runNumber,
@@ -4137,11 +3034,6 @@ async function getActionsRunByNumber(executor, conn, runNumber) {
 	if (found.number !== null && String(found.number) !== runNumber) throw new UnexpectedError(`Asked ${conn.repository} for run ${runNumber} and got run ${String(found.number)}: the forge ignored the run_number filter`);
 	return found;
 }
-/**
-* A run's jobs, as a bare array, with `index` set to array position -- the same order the web UI's
-* `/jobs/<index>` links use. Throws on a non-2xx, an unparseable response, or a job record without
-* the three fields this module requires.
-*/
 async function listActionsRunJobs(executor, conn, runId) {
 	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/actions/runs/${String(runId)}/jobs`;
 	const res = await executor.fetch(url, { headers: { Authorization: `token ${conn.token}` } });
@@ -4160,11 +3052,6 @@ async function listActionsRunJobs(executor, conn, runId) {
 	});
 	return jobs;
 }
-/**
-* Read one job's log by the numeric id the log endpoint wants, bounded by `bound`. Never throws on
-* a long log: the bound is what keeps a 68 MB-class response from reaching a caller, and
-* {@link ActionsJobLogText.truncated} says when it cut something. Throws on a non-2xx.
-*/
 async function fetchActionsJobLogById(executor, conn, jobId, bound) {
 	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/actions/jobs/${String(jobId)}/logs`;
 	const res = await executor.fetch(url, { headers: { Authorization: `token ${conn.token}` } });
@@ -4188,17 +3075,6 @@ async function fetchActionsJobLogById(executor, conn, jobId, bound) {
 	};
 }
 const RunsListResponseSchema = z.object({ workflow_runs: z.array(ActionsRunRecordSchema) });
-/**
-* The repository's workflow runs, newest first, paged **always** (spec decision 9). Every request
-* carries `page` and `limit`: measured against a live instance (2026-09-30), a runs query without
-* `page` ignores `limit` and answers with the whole table -- 3443 runs, 68 MB -- so paging is
-* structural here rather than a caller's obligation.
-*
-* The walk stops on an empty page or once `limit` rows are in hand. A page **shorter** than asked
-* for does not stop it: the server may clamp `limit` to its own page size, and reading a short page
-* as the end of the table would silently answer about part of it. Hitting the page cap with rows
-* still arriving warns, because a truncated listing otherwise reads as absence.
-*/
 async function listActionsRuns(executor, conn, options) {
 	const headers = { Authorization: `token ${conn.token}` };
 	const pageSize = Math.min(options.limit, 50);
@@ -4231,21 +3107,7 @@ async function listActionsRuns(executor, conn, options) {
 	}
 	return runs.slice(0, options.limit);
 }
-/** A `targetUrl` path of the shape `/actions/runs/{run}/jobs/{index}`, tolerating a scheme and
-* host in front of it and a trailing path segment, query, or fragment after it. */
 const ACTIONS_JOB_TARGET_URL = /\/actions\/runs\/(\d+)\/jobs\/(\d+)(?:[/?#]|$)/u;
-/**
-* Parse a status entry's `targetUrl` into the `{run, index}` the job-log read needs. A `targetUrl`
-* of any other shape -- including `null` -- yields `null`, full stop: **the id is never derived
-* from the `/actions/tasks` listing**, which was measured (against a live instance, in an earlier
-* investigation) returning an unrelated job's log for the same input. This module's job-log read
-* accepts nothing but this parser's output for exactly that reason.
-*
-* The parser lives here rather than beside the incident sweep that first needed it (spec decision
-* 15) because a caller holding a pasted `targetUrl` must be able to read the same object, the URL
-* shape is this package's domain, and a second copy in a command-line tool would be a forked
-* declaration.
-*/
 function parseActionsJobTargetUrl(targetUrl) {
 	if (targetUrl === null) return null;
 	const match = ACTIONS_JOB_TARGET_URL.exec(targetUrl);
@@ -4255,13 +3117,6 @@ function parseActionsJobTargetUrl(targetUrl) {
 		index: Number(match[2])
 	};
 }
-/**
-* The repository half of the same URL: everything before the first `/actions/runs/` is a
-* repository URL when it carries a scheme, so a pasted `targetUrl` can name the repository it came
-* from instead of leaving that to a separate option. A bare path carries no repository and yields
-* `undefined`; a prefixed value that is not a repository URL is refused by
-* {@link parseRepoTarget}, which is the answer a caller who pasted the wrong thing needs.
-*/
 function parseActionsJobTargetRepo(targetUrl) {
 	const boundary = targetUrl.indexOf("/actions/runs/");
 	if (boundary === -1) return void 0;
@@ -4269,12 +3124,6 @@ function parseActionsJobTargetRepo(targetUrl) {
 	if (!prefix.startsWith("http://") && !prefix.startsWith("https://")) return void 0;
 	return parseRepoTarget(prefix);
 }
-/**
-* Trigger a `workflow_dispatch` event. Any 2xx is success (the instance's swagger lists 201 and
-* 204). A failure is a {@link FatalError} carrying {@link forgejoErrorMessage}'s text for every
-* status, a 5xx included: a stable wording for every status, so a 5xx stays fatal rather than
-* transient. It is not `throwForgejoFailure`, which would make a 5xx transient.
-*/
 async function dispatchWorkflow(executor, conn, options) {
 	const repository = options.repository ?? conn.repository;
 	const url = `${conn.serverUrl}/api/v1/repos/${repository}/actions/workflows/${encodeURIComponent(options.workflow)}/dispatches`;
@@ -4299,26 +3148,14 @@ async function dispatchWorkflow(executor, conn, options) {
 }
 //#endregion
 //#region ../forgejo/src/actions-log.ts
-/** A CSI sequence: `ESC [` , parameter bytes, intermediate bytes, one final byte. Removed whole --
-* dropping only the escape byte would leave the parameters behind as text. */
 const CSI_SEQUENCE = /\u001b\[[0-?]*[ -/]*[@-~]/gu;
-/** An OSC sequence: `ESC ]` up to a BEL or a string terminator (`ESC \`). */
 const OSC_SEQUENCE = /\u001b\][^\u0007]*(?:\u0007|\u001b\\)/gu;
-/** An escape byte that began neither of those. */
 const LONE_ESCAPE = /\u001b/gu;
-/** The C0 controls that may still be left, tab excepted, plus DEL. */
 const CONTROL_CHARS = /[\u0000-\u0008\u000a-\u001f\u007f]/gu;
-/** The first token of a line, when it is shaped like the timestamp the runner writes. */
 const LINE_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\S+$/u;
-/** Remove every control sequence and control character, whole. */
 function stripControlSequences(text) {
 	return text.replace(CSI_SEQUENCE, "").replace(OSC_SEQUENCE, "").replace(LONE_ESCAPE, "").replace(CONTROL_CHARS, "");
 }
-/**
-* Split one line into its timestamp and its text. The first whitespace-delimited token is the
-* timestamp only when it is shaped like one **and** a clock accepts it -- a job printing a
-* date-shaped word keeps it in its body rather than losing it to a `null`.
-*/
 function splitLogLine(line) {
 	const spaceAt = line.indexOf(" ");
 	const head = spaceAt === -1 ? line : line.slice(0, spaceAt);
@@ -4338,10 +3175,6 @@ function spanBetween(start, end) {
 	if (!Number.isFinite(startMs) || !Number.isFinite(endMs)) return null;
 	return endMs - startMs;
 }
-/**
-* Read a job log as lines. The carriage return of a CRLF pair and the empty line a trailing
-* newline leaves are both dropped.
-*/
 function readActionsJobLog(text) {
 	const raw = text.split("\n");
 	if (raw.length > 0 && raw[raw.length - 1] === "") raw.pop();
@@ -4358,33 +3191,7 @@ function readActionsJobLog(text) {
 }
 //#endregion
 //#region src/ci-log.ts
-/**
-* `bst-fj ci:log` -- one CI job's log, whole, or the lines of it a `--grep` matches. GitHub has
-* `gh run view --log` for this, so the command is Forgejo-only, like every other command in this
-* bin.
-*
-* The positional is a run number, a run URL (what `ci:runs` prints), or a status `target_url` (what
-* `pr:checks` and `commit:status` print beside a red check), so a caller pastes rather than
-* transcribes.
-*
-* The log is read **whole** up to the library's ceiling, not as the 2 MiB tail the incident body
-* keeps: a `--grep` over a tail would answer "not mentioned" about lines it never saw. A log cut
-* by the ceiling says so in `log.truncated` and in a notice.
-*
-* There is no step table. The runner on the instance this was built against writes a step marker
-* for its first main step only, so a step split read off the log text was wrong for every later
-* step (see `@bensandee/forgejo/actions-log`).
-*
-* Under `--json` the payload carries `lines` only with `--grep`: a whole log is megabytes, and a
-* reader that wants it all reads the text output.
-*/
-/** A run page URL: `/actions/runs/{run}`, with nothing after it but a slash, query or fragment. */
 const ACTIONS_RUN_URL = /\/actions\/runs\/(\d+)\/?(?:[?#]|$)/u;
-/**
-* The positional: all digits is a run number; a job URL gives the run and the job index; a run
-* URL gives the run alone. A URL carrying a host and `owner/repo` also names the repository,
-* which then stands in for `--repo`.
-*/
 function parseCiLogTarget(target) {
 	if (/^\d+$/.test(target)) return {
 		run: target,
@@ -4405,7 +3212,6 @@ function parseCiLogTarget(target) {
 	};
 	throw new FatalError(`Not a run number or an Actions run or job URL: "${target}" (expected e.g. 6693, https://host/owner/repo/actions/runs/6693 or .../actions/runs/6693/jobs/0).`);
 }
-/** What the run's jobs are, in the shape an error message lists them in for a caller to read. */
 function jobTable(jobs) {
 	return jobs.map((candidate) => `  ${String(candidate.index)} ${candidate.name} ${candidate.status}`).join("\n");
 }
@@ -4414,16 +3220,6 @@ function jobAtIndex(jobs, index, label) {
 	if (found === void 0) throw new FatalError(`${label} ${String(index)} is not one of this run's jobs. Jobs in this run:\n${jobTable(jobs)}`);
 	return found;
 }
-/**
-* Which job's log to read.
-*
-* A `--job` of all digits is an index -- the same index a `target_url` carries -- and anything else
-* is an exact, case-insensitive job name. When the URL already named an index, a `--job` that
-* disagrees with it is a refusal naming both, because either could be what the caller meant.
-*
-* With neither and several jobs, this refuses rather than defaulting to index 0: the answer would
-* be about the wrong job, confidently, with nothing said.
-*/
 function chooseJob(jobs, job, urlIndex) {
 	if (job !== void 0) {
 		const chosen = /^\d+$/.test(job) ? jobAtIndex(jobs, Number(job), `--job ${job}`) : jobs.find((candidate) => candidate.name.toLowerCase() === job.toLowerCase());
@@ -4436,11 +3232,6 @@ function chooseJob(jobs, job, urlIndex) {
 	if (only !== void 0) return only;
 	throw new FatalError(`This run has ${String(jobs.length)} jobs, so --job must say which one (a name or the index).\nJobs in this run:\n${jobTable(jobs)}`);
 }
-/**
-* Read one job's log: run by number, its jobs, the chosen job, the whole log. A refused target, a
-* missing run or job, and a non-2xx from the forge all throw; a successful read of a failed job
-* does not, because this is a readout and not a verdict.
-*/
 async function runCiLog(fetcher, options) {
 	const target = parseCiLogTarget(options.target);
 	let grep;
@@ -4485,7 +3276,6 @@ async function runCiLog(fetcher, options) {
 		notices
 	};
 }
-/** A two-line header naming the run and job, then each line kept with its timestamp. */
 function renderCiLog(result) {
 	const lines = [`run ${String(result.run.number)} ${result.run.status ?? "?"} ${result.run.workflow ?? "?"}`, `job ${String(result.job.index)} ${result.job.name} (${result.job.status})`];
 	for (const line of result.lines) lines.push(line.at === null ? line.text : `${line.at} ${line.text}`);
@@ -4548,31 +3338,11 @@ const ciLogCommand = defineCommand({
 });
 //#endregion
 //#region src/ci-runs.ts
-/**
-* `bst-fj ci:runs` -- a read-only, Forgejo-only listing of a repository's workflow runs and their
-* jobs, over the shared paged read in `@bensandee/forgejo/actions`. GitHub run listing already has
-* a first-class tool (`gh run list`), the same precedent `pr:list` follows for the same structural
-* reason (spec decision 2 and 13's target form: `--repo` is a repository URL, like every `pr:*`
-* and `issue:*` read).
-*
-* `--ref` and `--pr` are one filter spelled two ways (spec decision 6): a pull-request run carries
-* `refs/pull/<n>/head`, which no caller should have to know, and the branch's own push runs stay
-* one `--ref <branch>` away.
-*/
 function parseLimit$2(raw) {
 	const limit = Number(raw);
 	if (!Number.isInteger(limit) || limit < 1) throw new FatalError(`Invalid --limit "${raw}" (expected a positive integer).`);
 	return limit;
 }
-/**
-* The `ref` filter, from whichever of `--ref` and `--pr` was given. A bare `--ref main` names a
-* branch, so it becomes `refs/heads/main`; a value that is already a full ref is sent as is;
-* `--pr` becomes `refs/pull/<n>/head` (spec decision 6) and carries the repository off a PR URL so
-* the URL can stand in for `--repo`.
-*
-* Both together is a refusal rather than a precedence: they are the same filter, and quietly
-* ignoring one answers about a different set of runs than the caller asked for.
-*/
 function resolveRunsRef(ref, pr) {
 	if (ref !== void 0 && pr !== void 0) throw new FatalError("--ref and --pr are the same filter -- give one of them (--pr 273 for a pull request's own runs, --ref main for a branch's).");
 	if (pr !== void 0) {
@@ -4596,11 +3366,6 @@ function resolveRunsRef(ref, pr) {
 		target: void 0
 	};
 }
-/**
-* List a repository's workflow runs, newest first, each with its jobs. Paging is never optional on
-* this read (spec decision 9): an unpaged runs query answers with the whole table. Refuses a
-* github.com target before any fetch.
-*/
 async function runCiRuns(fetcher, options) {
 	const limit = parseLimit$2(options.limit);
 	const resolved = resolveRunsRef(options.ref, options.pr);
@@ -4632,14 +3397,9 @@ async function runCiRuns(fetcher, options) {
 		notices
 	};
 }
-/** A duration, or the dash that says the forge reported none (the run has not finished). */
 function durationText(durationMs) {
 	return durationMs === null ? "-" : `${String(durationMs)}ms`;
 }
-/**
-* One line per run, then one indented line per job. The run number leads its line because it is
-* what `ci:log` takes as its positional.
-*/
 function renderCiRuns(result) {
 	if (result.runs.length === 0) return `No workflow runs in ${result.repository}.`;
 	const lines = [];
@@ -4728,15 +3488,6 @@ const ciRunsCommand = defineCommand({
 //#region ../cli-kit/src/workflow-inputs.ts
 const INPUT_FLAG = "--input";
 const INPUT_FLAG_EQ = "--input=";
-/**
-* Collect every `--input` value from a command's raw CLI args.
-*
-* citty@0.2.2 keeps only the LAST occurrence of a repeated named flag, so a
-* declared `input` arg cannot capture `--input a=1 --input b=2` -- it silently
-* yields just `b=2`. Scanning the raw argv directly recovers all occurrences.
-* Both `--input k=v` (two tokens) and `--input=k=v` (one token) forms are
-* supported. Throws {@link FatalError} when `--input` has no following value.
-*/
 function collectInputArgs(rawArgs) {
 	const values = [];
 	for (let i = 0; i < rawArgs.length; i += 1) {
@@ -4751,11 +3502,6 @@ function collectInputArgs(rawArgs) {
 	}
 	return values;
 }
-/**
-* Parse `key=value` workflow-input strings (as collected by
-* {@link collectInputArgs}) into an inputs object. Throws {@link FatalError} on
-* a malformed entry -- no `=`, or an empty key.
-*/
 function parseInputs(raw) {
 	const inputs = {};
 	for (const value of raw) {
@@ -4767,11 +3513,6 @@ function parseInputs(raw) {
 }
 //#endregion
 //#region src/workflow-dispatch.ts
-/**
-* `bst-fj workflow:dispatch`: a thin command over `@bensandee/forgejo/actions`. Forgejo-only;
-* `gh workflow run` already serves GitHub.
-*/
-/** Dispatch a `workflow_dispatch` event on the current repository or on `options.repo`. */
 async function runWorkflowDispatch(fetcher, options) {
 	const dispatched = await dispatchWorkflow(fetcher, requireForgejoTarget(options.cwd, void 0, "workflow:dispatch is Forgejo-only -- use gh workflow run on GitHub."), {
 		...options.repo === void 0 ? {} : { repository: options.repo },
@@ -4847,31 +3588,11 @@ z.object({
 	content: z.string(),
 	encoding: z.literal("base64")
 });
-/**
-* Encode a repository path for the segment of an API URL it occupies, rejecting any segment that
-* addresses something other than a name.
-*
-* **Segment-wise, never over the whole string.** `encodeURIComponent` applied to the path entire
-* escapes `/` as `%2F` and breaks every nested path; applied per segment it leaves the separators
-* that address a directory and escapes the reserved characters inside a name.
-*
-* **Encoding alone is not enough, which is why the rejection is here too.**
-* `encodeURIComponent("..")` is `".."` -- a literal dot segment survives untouched and the URL
-* parser still resolves it, walking the request out of the repository it names. Only the
-* percent-encoded `%2e%2e` spelling is neutralised by escaping. So `.`, `..` and the empty segment
-* are refused outright rather than passed through: a repository path addresses a file by name, and
-* a caller with a relative path to resolve has a bug that a 200 from another repository hides.
-*/
 function encodeRepoPath(filePath) {
 	const segments = filePath.split("/");
 	if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) throw new UnexpectedError(`Refusing a repository path with a relative segment: ${filePath}`);
 	return segments.map(encodeURIComponent).join("/");
 }
-/**
-* One entry of a directory listing, as {@link getPathEntry} and {@link listDirEntries} need it:
-* the name, id and kind, nothing else. Loose, so fields this module does not read (size,
-* download_url, ...) do not need declaring here just to survive `safeParse`.
-*/
 const DirEntrySchema = z.looseObject({
 	name: z.string(),
 	sha: z.string(),
@@ -4880,10 +3601,6 @@ const DirEntrySchema = z.looseObject({
 z.array(DirEntrySchema);
 //#endregion
 //#region ../forgejo/src/branches.ts
-/**
-* Branch operations on a repository. One API domain: the branch endpoints under
-* `/repos/{o}/{r}/branches`.
-*/
 const BranchEntrySchema = z.object({
 	name: z.string(),
 	protected: z.boolean().optional(),
@@ -4892,10 +3609,7 @@ const BranchEntrySchema = z.object({
 		timestamp: z.string().optional()
 	}).optional()
 });
-/** Requested page size. Forgejo clamps it, so a short page is NOT an end signal -- only an empty
-* one is. */
 const BRANCHES_PAGE_SIZE = 50;
-/** Default cap on pages, so a misbehaving server cannot spin a caller forever. */
 const DEFAULT_MAX_PAGES = 20;
 function repoBase(conn) {
 	return `${conn.serverUrl}/api/v1/repos/${conn.repository}`;
@@ -4903,7 +3617,6 @@ function repoBase(conn) {
 function authHeaders(conn) {
 	return { Authorization: `token ${conn.token}` };
 }
-/** List a repository's branches, paging until an empty page or `maxPages`. */
 async function listBranches(executor, conn, options = {}) {
 	const signal = options.signal;
 	const maxPages = options.maxPages ?? DEFAULT_MAX_PAGES;
@@ -4946,7 +3659,6 @@ const DELETE_REFUSALS = {
 	404: "not-found"
 };
 const ErrorBodySchema = z.object({ message: z.string() });
-/** The `message` field of a JSON error body, else the body text itself. */
 async function refusalMessage(res) {
 	const text = await responseBodyText(res);
 	try {
@@ -4955,7 +3667,6 @@ async function refusalMessage(res) {
 	} catch (_error) {}
 	return text;
 }
-/** Delete one branch. The name is encoded per segment so `feat/a/b` keeps its slashes. */
 async function deleteBranch(executor, conn, branch) {
 	const res = await executor.fetch(`${repoBase(conn)}/branches/${encodeRepoPath(branch)}`, {
 		method: "DELETE",
@@ -4976,20 +3687,14 @@ async function deleteBranch(executor, conn, branch) {
 }
 //#endregion
 //#region src/branch.ts
-/**
-* `bst-fj branch:list` and `branch:delete`: thin commands over `@bensandee/forgejo/branches`.
-* Forgejo-only; git already serves every other host.
-*/
 const REFUSAL_WORDS = {
 	forbidden: "forbidden",
 	locked: "locked",
 	"not-found": "not found"
 };
-/** List a repository's branches. */
 function runBranchList(fetcher, options) {
 	return listBranches(fetcher, requireForgejoTarget(options.cwd, parseRepoTarget(options.repo), "branch:list is Forgejo-only -- use git branch -r on GitHub."));
 }
-/** Delete one branch; a refusal is a runtime error naming the reason. */
 async function runBranchDelete(fetcher, options) {
 	const result = await deleteBranch(fetcher, requireForgejoTarget(options.cwd, parseRepoTarget(options.repo), "branch:delete is Forgejo-only -- use git push --delete on GitHub."), options.name);
 	if (!result.ok) throw new FatalError(`Cannot delete branch "${options.name}": ${REFUSAL_WORDS[result.reason]} (HTTP ${String(result.status)})${result.message === "" ? "" : `: ${result.message}`}.`);
@@ -5001,7 +3706,6 @@ function renderBranch(branch) {
 	if (branch.commitSha !== null) parts.push(branch.commitSha.slice(0, 7));
 	return parts.join(" ");
 }
-/** Human-readable rendering: one line per branch, then a note when the walk was cut short. */
 function renderBranchList(listing) {
 	const lines = listing.branches.map(renderBranch);
 	if (lines.length === 0) lines.push("No branches.");
@@ -5081,7 +3785,6 @@ const branchSubCommands = {
 };
 //#endregion
 //#region ../cli-kit/src/body-source.ts
-/** Run `read`, converting any raw fs error (ENOENT, EISDIR, EACCES, ...) into a FatalError. */
 function tryRead(read, label) {
 	try {
 		return read();
@@ -5089,20 +3792,6 @@ function tryRead(read, label) {
 		throw new FatalError(`Could not read ${label}: ${describeError(error)}`);
 	}
 }
-/**
-* Resolve a `--body` / `--body-file` pair shared by `pr:create`, `pr:update`, `issue:create`, and
-* `issue:comment`.
-*
-* - Both flags given -> FatalError (mutually exclusive).
-* - Neither flag given -> `undefined`. Whether that is acceptable is the caller's concern:
-*   `pr:create` falls back to a commit-derived body, `pr:update` deliberately does NOT (it leaves
-*   the PR's authored body alone -- the distinction `undefined` carries is the whole point of the
-*   command), `issue:create` falls back to `""`, and `issue:comment` throws its own FatalError
-*   requiring one of the two flags.
-* - `--body-file -` reads stdin, so a generated plan/body can be piped straight in.
-* - A missing file, a directory, or a permission error all surface as FatalError, never a raw
-*   Node error (ENOENT/EISDIR/EACCES).
-*/
 function readBodySource(body, bodyFile, options = {}) {
 	const flags = options.flags ?? {
 		text: "--body",
@@ -5148,33 +3837,8 @@ function normalizeComment(raw) {
 		attachments: (raw.assets ?? []).map(normalizeAttachment)
 	};
 }
-/**
-* Page size for `GET .../issues/<n>/comments`. Also the signal that another page may exist.
-* Deliberately 50: that is Forgejo's own default `api.MAX_RESPONSE_ITEMS`, the value
-* `ToCorrectPageSize` clamps `limit` down to, so a default instance returns exactly what is asked
-* for and a short page really is the last page.
-*/
 const COMMENTS_PAGE_SIZE = 50;
-/** Hard cap on pages fetched, so a misbehaving server can't spin this forever. */
 const COMMENTS_MAX_PAGES = 20;
-/**
-* Every comment on an issue (or a PR -- both forges serve PR conversation comments through this
-* same endpoint), oldest-first, paginating until a short page or the page cap.
-*
-* Pagination is load-bearing, not hygiene. Unpaginated, this returned whatever
-* `api.DEFAULT_PAGING_NUM` is (30 by default) -- the OLDEST 30 comments -- and every caller that
-* asks a "what is the newest X" question got a silently stale answer on any PR busy enough to
-* matter: a caller that picks the newest comment of one author, or keeps only the comments after
-* a watermark, picked a stale boundary and dropped every comment past the cut.
-*
-* A short page is the end signal, per `fetchAllForgejoLabels` (`label-provisioning.ts`), rather
-* than the empty page `searchForgejoIssues` (`issues.ts`) insists on. The residual risk is
-* bounded and stated: an instance that configures `api.MAX_RESPONSE_ITEMS` BELOW 50 clamps every
-* page to that size, and a full clamped page reads as short, so a thread longer than the clamp
-* can still truncate there. That is strictly better than the fixed 30 this replaced, and it costs
-* one GET per listing rather than the two an empty-page probe needs on the overwhelmingly common
-* single-page thread.
-*/
 async function listForgejoComments(executor, conn, number, options = {}) {
 	const comments = [];
 	for (let page = 1; page <= COMMENTS_MAX_PAGES; page++) {
@@ -5203,7 +3867,6 @@ const RepoCommentResponseSchema = CommentResponseSchema.extend({
 	updated_at: z.string().nullish()
 });
 z.array(RepoCommentResponseSchema);
-/** Post a new comment on an issue. */
 async function addForgejoComment(executor, conn, number, body) {
 	const res = await executor.fetch(`${issuesBase(conn)}/${String(number)}/comments`, {
 		method: "POST",
@@ -5218,18 +3881,7 @@ async function addForgejoComment(executor, conn, number, body) {
 }
 //#endregion
 //#region ../forgejo/src/pr-title.ts
-/**
-* The two WIP title spellings a Forgejo draft carries, and the predicates built on them. Its own
-* leaf so `pr.ts` (the draft/undraft PATCHes) and any other caller can import one definition
-* instead of drifting apart.
-*
-* An instance that configures a *different* prefix set is out of reach of any static list; that
-* case is caught by `undraftForgejoPr`'s draft-but-unrecognized guard rather than papered over
-* here.
-*/
 const WIP_PREFIXES = ["WIP:", "[WIP]"];
-/** Whether a title carries one of {@link WIP_PREFIXES}, checked case-insensitively against the
-* title exactly as given, with no trim. */
 function hasWipPrefix(title) {
 	return matchedWipPrefix(title) !== void 0;
 }
@@ -5237,13 +3889,6 @@ function matchedWipPrefix(title) {
 	const lower = title.toLowerCase();
 	return WIP_PREFIXES.find((prefix) => lower.startsWith(prefix.toLowerCase()));
 }
-/**
-* Strip a single leading WIP marker off a PR title and return the rest, or the input unchanged
-* when there is no such prefix. Idempotent -- stripping a non-WIP title, or a title already
-* stripped, is a no-op. A superset of the exact inverse of the `WIP: ` prepend
-* `withWipPrefix` (`pr-upsert.ts`) writes: it also clears the
-* hand-typed variants Forgejo itself honours (see {@link WIP_PREFIXES}).
-*/
 function stripWipPrefix(title) {
 	const prefix = matchedWipPrefix(title);
 	if (prefix === void 0) return title;
@@ -5255,32 +3900,11 @@ const CreatedPrSchema = z.object({
 	number: z.number(),
 	html_url: z.string().optional()
 });
-/** Compose a PR's web URL from the connection coordinates. */
 function prWebUrl(conn, prNumber) {
 	return `${conn.serverUrl}/${conn.repository}/pulls/${String(prNumber)}`;
 }
-/** Requested page size. Forgejo clamps it, so a short page is NOT an end signal -- only an empty
-* one is (same reasoning as `searchForgejoIssues`). */
 const PULLS_PAGE_SIZE = 50;
-/** Hard cap on pages, so a misbehaving server cannot spin a caller forever. */
 const PULLS_MAX_PAGES = 20;
-/**
-* Find the open PR with the given head branch -- its number and its base ref -- or null.
-*
-* Filters client-side by head.ref rather than relying on Forgejo's query parameter filtering,
-* which behaves inconsistently. `base` is required on the wire: the endpoint serves full
-* pull-request objects (the same shape {@link getPrRefs} reads off `/pulls/<n>`), and a caller
-* reporting a PR's base must fail loudly rather than fall back to a locally guessed one.
-*
-* Paged to an empty page or to {@link PULLS_MAX_PAGES}, sharing both constants with
-* {@link listPulls} rather than trusting the server's default page size. The walk ends on an
-* empty page rather than a short one because Forgejo clamps `limit`, so a short page may be the
-* clamp rather than the end (same reasoning `listPulls` and `searchForgejoIssues` already
-* record). Exhausting the cap throws rather than returning `null`: this function's answer is a
-* yes/no, so a truncated read does not degrade it, it inverts it into precisely the value that
-* makes a create-if-absent caller write a duplicate to the forge -- unlike `listPulls`, whose
-* caller reads a whole set and can tolerate a truncated tail.
-*/
 async function findOpenPrEntry(executor, conn, head, signal = null) {
 	let capped = false;
 	const match = (await listPulls(executor, conn, {
@@ -5301,10 +3925,6 @@ async function findOpenPrEntry(executor, conn, head, signal = null) {
 	if (capped) throw new FatalError(`Open PR lookup on ${conn.repository} for head "${head}" hit the ${String(PULLS_MAX_PAGES)}-page cap without finding it or reaching an empty page; a truncated read here reads as "no open PR" and makes a caller create a duplicate`);
 	return null;
 }
-/**
-* The open PR number for a head branch, or null. A wrapper over {@link findOpenPrEntry}: most
-* callers only ask whether a PR exists, and one fetch with one schema serves both questions.
-*/
 async function findOpenPr(executor, conn, head, signal = null) {
 	return (await findOpenPrEntry(executor, conn, head, signal))?.number ?? null;
 }
@@ -5325,23 +3945,6 @@ const PullListItemSchema = z.object({
 function updatedBefore(since) {
 	return (pr) => pr.updatedAt !== null && Date.parse(pr.updatedAt) < since;
 }
-/**
-* Every pull request -- open, merged, and closed-unmerged -- by default, via `state=all`; a caller
-* may narrow the read with {@link ListPullsOptions.state}. Paged to an empty page or to
-* {@link PULLS_MAX_PAGES}, whichever comes first.
-*
-* The one paged PR listing: a caller that decides over the whole set reads it to completion, and
-* a caller passes `stopWhen` to answer "does a pull request already exist on this
-* head, in any state" at the cost of one page in the common case (Forgejo lists recently touched
-* pull requests first). That existence question is the reason this exists alongside
-* {@link findOpenPr}: a caller deciding whether to CREATE must not ask an open-only question, since
-* a closed pull request is still one that exists and creating over it mints a fresh one on every
-* re-entry.
-*
-* Hitting the page cap **warns** rather than returning quietly. A silently truncated read is
-* indistinguishable from "no such pull request", which is precisely the answer that makes a caller
-* create a duplicate.
-*/
 async function listPulls(executor, conn, options = {}) {
 	const headers = { Authorization: `token ${conn.token}` };
 	const pulls = [];
@@ -5392,7 +3995,6 @@ async function listPulls(executor, conn, options = {}) {
 	}
 	return pulls;
 }
-/** Create a new pull request. */
 async function createPr(executor, conn, options) {
 	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/pulls`;
 	const payload = {
@@ -5421,20 +4023,6 @@ async function createPr(executor, conn, options) {
 	};
 }
 z.object({ body: z.string().nullish() });
-/**
-* Read one projection of `.../pulls/<n>` -- the shared body of every single-PR GET below.
-*
-* They all issue the identical request and differ only in which slice of the payload they need,
-* so the schema and a `what` noun are the parameters; `what` spells both the failure verb
-* ("read PR head") and the schema-mismatch message ("Unexpected PR head response"), which keeps
-* an error naming the field the caller actually asked for. Reading the whole payload and picking
-* fields off it in the caller is the tempting alternative and is worse: a narrow schema is what
-* makes a forge that stops serving a field fail loudly here, rather than surfacing `undefined`
-* somewhere further out.
-*
-* Note this is the *pulls* endpoint, which is not interchangeable with the issues endpoint
-* `getPrBody` uses -- only this one carries `head`, `base`, and `draft`.
-*/
 async function readPrField(executor, conn, prNumber, schema, what) {
 	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/pulls/${String(prNumber)}`;
 	const res = await executor.fetch(url, { headers: { Authorization: `token ${conn.token}` } });
@@ -5464,11 +4052,6 @@ const PrDetailSchema = z.object({
 	mergeable: z.boolean().nullish(),
 	state: z.string()
 });
-/**
-* Map a validated pulls-endpoint payload to {@link PrDetail}: an absent `repo` becomes `null`
-* rather than an invented repository name, and an absent `mergeable` becomes `null` rather than
-* `false` -- both forges can omit or null this field while still computing it.
-*/
 function normalizePrDetail(data) {
 	return {
 		head: {
@@ -5487,14 +4070,6 @@ function normalizePrDetail(data) {
 		state: data.state
 	};
 }
-/**
-* Fetch a PR's head and base branch details, draft/merged state, and tri-state mergeability in one
-* `/pulls/<n>` read -- so a workflow that starts from a PR number reaches its branch without
-* a `git ls-remote` reverse lookup. `ref`/`sha`/`draft`/`merged` are required on the wire: a
-* forge that stops serving one of them should fail loudly here rather than surface `undefined` further out (see `readPrField`'s
-* doc comment). `mergeable` and `repo` are nullish because absent and explicitly-null are both
-* real answers.
-*/
 async function getForgejoPrDetail(executor, conn, prNumber) {
 	return normalizePrDetail(await readPrField(executor, conn, prNumber, PrDetailSchema, "detail"));
 }
@@ -5508,15 +4083,6 @@ const PrEditStateSchema = z.object({
 	mergeable: z.boolean().nullish(),
 	html_url: z.string().optional()
 });
-/**
-* Read a pull request's edit state in one `/pulls/<n>` GET -- the read both editors run before
-* they write, and the one they run again to confirm the write took.
-*
-* `url` prefers the forge's own `html_url` because an instance that serves it knows its real web
-* route (a reverse-proxied path included), and falls back to {@link prWebUrl} when it does not.
-* `mergeable` stays tri-state for {@link PrDetail}'s reason: absent is "still computing", not
-* "conflicted".
-*/
 async function getPrEditState(executor, conn, prNumber) {
 	const parsed = await readPrField(executor, conn, prNumber, PrEditStateSchema, "edit state");
 	return {
@@ -5530,16 +4096,6 @@ async function getPrEditState(executor, conn, prNumber) {
 		url: parsed.html_url ?? prWebUrl(conn, prNumber)
 	};
 }
-/**
-* Repoint a pull request at a new base branch with a PATCH carrying `base` and nothing else.
-*
-* Its own function rather than another field on {@link UpdatePrOptions}: that interface is the
-* title-and-body pair whose whole contract is "an omitted key is left alone", and widening it to
-* carry a branch name would let a caller that only means to fix a title move a pull request's
-* base by accident. The caller confirms the write by re-reading -- Forgejo accepts an unknown
-* `EditPullRequestOption` field silently, so a PATCH that answered 200 is not proof the base
-* moved.
-*/
 async function retargetPr(executor, conn, prNumber, base) {
 	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/pulls/${String(prNumber)}`;
 	const res = await executor.fetch(url, {
@@ -5559,20 +4115,6 @@ const PrContentSchema = z.object({
 	title: z.string(),
 	body: z.string().nullish()
 });
-/**
-* Fetch a PR's live title and body in one read.
-*
-* Read by `runPrUpsert` (`pr-upsert.ts`, through `forgejoPrHost`) on the update path, for the
-* fields the caller did not explicitly supply: it PATCHes only what it was given, so the rest stays whatever the forge
-* already holds, and the result it reports has to say so rather than echoing content that was
-* never sent. (A dry-run preview is the load-bearing case -- its whole job is to be the last chance to
-* notice a missing closing keyword, which it cannot do while printing a body the PR will not
-* have.)
-*
-* The *pulls* endpoint, unlike {@link getPrBody}'s issues endpoint, because this read is paired
-* with the `/pulls/<n>` PATCH that consumes it -- one endpoint for the read-modify-write, so a
-* body this returns is a body {@link updatePr} could send back unchanged.
-*/
 async function getPrContent(executor, conn, prNumber) {
 	const parsed = await readPrField(executor, conn, prNumber, PrContentSchema, "content");
 	return {
@@ -5584,12 +4126,6 @@ z.object({
 	title: z.string(),
 	draft: z.boolean()
 });
-/**
-* Update an existing pull request's title and/or body. A field left out of `options` is left out
-* of the PATCH -- `JSON.stringify` drops an `undefined` value, so an omitted field never reaches
-* the forge as an explicit null that would blank the authored text. An `options` with neither
-* field sends nothing at all rather than an empty PATCH.
-*/
 async function updatePr(executor, conn, prNumber, options) {
 	if (options.title === void 0 && options.body === void 0) return;
 	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/pulls/${String(prNumber)}`;
@@ -5628,16 +4164,11 @@ const PullReviewCommentSchema = z.object({
 z.array(PullReviewCommentSchema);
 //#endregion
 //#region ../forgejo/src/issue-api.ts
-/**
-* Raised when a call needs an issue number and the reference carries none. The library states the
-* fact and names no command; the caller words the refusal with its own example.
-*/
 var IssueNumberRequiredError = class extends FatalError {
 	constructor() {
 		super("An issue number or issue URL is required.");
 	}
 };
-/** The issue number of `ref`, or an {@link IssueNumberRequiredError} when it has none. */
 function requireIssueNumber(ref) {
 	if (ref.number === void 0) throw new IssueNumberRequiredError();
 	return ref.number;
@@ -5661,10 +4192,6 @@ function forgejoIssueApi(fetcher, conn) {
 }
 //#endregion
 //#region ../forgejo/src/issue-messages.ts
-/**
-* The `--json` help for the issue commands, one string per payload, shared so both bins
-* word it byte for byte alike. Each names the keys of the result its runner returns.
-*/
 const ISSUE_LIST_JSON_HELP = "Emit one JSON document: issues ([{number, title, state, url, author, labels, createdAt, updatedAt, closedAt (null while open), isPullRequest, assignees, attachments ([{id, name, size, createdAt, downloadUrl}])}]), truncated.";
 const ISSUE_CREATE_JSON_HELP = "Emit one JSON document: number, url, assignees. A dry run reports number 0 and an empty url.";
 const ISSUE_STATE_JSON_HELP = "Emit one JSON document: number, url, action (close | reopen), state ({previous, current}), changed, comment? ({posted}; present only when a comment was given).";
@@ -5674,56 +4201,39 @@ const ISSUE_DOWNLOAD_JSON_HELP = "Emit one JSON document: dir, files ([{name, si
 const ISSUE_LABEL_JSON_HELP = "Emit one JSON document: number, label, action (add | remove), url.";
 const ISSUE_SET_LABELS_JSON_HELP = "Emit one JSON document: number, labels, previous, added, removed, url. A dry run reports the change it would make and writes nothing.";
 const ISSUE_VIEW_JSON_HELP = "Emit one JSON document: number, title, state, url, author, labels, createdAt, updatedAt, closedAt, body, isPullRequest, assignees, attachments, comments ([{id, author, createdAt, updatedAt?, body, url?}]), commentsTruncated, pr? ({head ({ref, sha, repo (or null)}), base ({ref, sha, repo (or null)}), draft, merged, mergeable (true | false | null), state}), prUnavailable? ({reason}). On a pull request exactly one of pr and prUnavailable is present, and neither is otherwise; repo is null for a deleted fork; commentsTruncated is true when the comment read hit its cap of about 1000.";
-/**
-* The refusal for an {@link IssueNumberRequiredError}. `example` is the program's own complete
-* invocation, for instance the program name, the command and a sample number, so every program
-* words the refusal the same way and names itself.
-*/
 function describeIssueNumberRequired(example) {
 	return `An issue number or issue URL is required, e.g. \`${example}\`.`;
 }
-/** The refusal for an {@link InvalidListQueryError}, naming the program's own options. */
 function describeInvalidListQuery(error, flags) {
 	return error.field === "state" ? `${flags.state} must be one of open, closed, all (got "${error.value}")` : `${flags.limit} must be a positive integer (got "${error.value}")`;
 }
-/** The refusal for a NothingToUpdateError: an update that names no field to change. */
 function describeNothingToUpdate(flags) {
 	return `Nothing to change -- pass ${flags.title} and/or ${flags.body}/${flags.bodyFile}. (Omitting them leaves the issue exactly as authored; this command never derives a replacement.)`;
 }
-/** The refusal for an EmptyCommentError, naming the program's own options. */
 function describeEmptyComment(flags) {
 	return `${flags.text} / ${flags.file} resolved to empty text -- pass a comment or omit the flag.`;
 }
-/** The refusal for a {@link PullRequestStateError}: a state write aimed at a pull request. */
 function describePullRequestState(error, names) {
 	return `#${String(error.number)} is a pull request, not an issue -- ${names.command} refuses to write pull-request state. ${names.advice}`;
 }
-/** The refusal for a {@link NoLabelsGivenError}, naming the program's own clear option. */
 function describeNoLabelsGiven(error, clearFlag) {
 	return `No labels given, which would strip every label off #${String(error.number)}. Pass ${clearFlag} if that is what you mean, or name the labels the issue should end up with.`;
 }
-/** The refusal for an {@link AttachmentExistsError}, naming the program's own force option. */
 function describeAttachmentExists(error, forceFlag) {
 	return `"${error.filePath}" already exists -- pass ${forceFlag} to overwrite it.`;
 }
 //#endregion
 //#region ../forgejo/src/issue-run.ts
-/** Raised when an update names neither a title nor a body, so there is nothing to change. */
 var NothingToUpdateError = class extends FatalError {
 	constructor() {
 		super("Nothing to change: neither a title nor a body was given.");
 	}
 };
-/** Raised when a create has an empty title. */
 var IssueTitleRequiredError = class extends FatalError {
 	constructor() {
 		super("An issue title is required.");
 	}
 };
-/**
-* Raised when a list query's state or limit is not usable. The library reports the field and the
-* raw value; the caller words the refusal with its own flag names.
-*/
 var InvalidListQueryError = class extends FatalError {
 	field;
 	value;
@@ -5733,10 +4243,6 @@ var InvalidListQueryError = class extends FatalError {
 		this.value = value;
 	}
 };
-/**
-* Read an issue with its comments. When the target is a pull request, also its pull detail, or the
-* reason that read was refused.
-*/
 async function viewIssue(resolve, request) {
 	const ref = parseIssueRef(request.ref);
 	const number = requireIssueNumber(ref);
@@ -5767,26 +4273,11 @@ async function viewIssue(resolve, request) {
 		};
 	}
 }
-/**
-* The head branch written for the `pr:` line: bare when the head lives in the repository the view
-* resolved against (compared to `base.repo`, since that repository *is* the one this view was read
-* from), repo-qualified (`someone/fork:their-branch`) otherwise so a fork is visible at a glance,
-* and marked rather than blank when the head repository is gone.
-*/
 function formatPrHead(pr) {
 	if (pr.head.repo === null) return `${pr.head.ref} (head repo gone)`;
 	if (pr.head.repo === pr.base.repo) return pr.head.ref;
 	return `${pr.head.repo}:${pr.head.ref}`;
 }
-/**
-* The tri-state mergeable text: `null` means "not computed yet" and is never collapsed into the
-* false case.
-*
-* False reads "not mergeable" rather than "conflicted" because a conflict is only one of the
-* things it means: Forgejo answers false for a work-in-progress PR whose merge is perfectly clean
-* (it folds the WIP flag into the same field), and for one it is still checking. "Not mergeable" is
-* true on both forges; "conflicted" is a diagnosis the field cannot support.
-*/
 function formatMergeable(mergeable) {
 	if (mergeable === null) return "mergeable: unknown";
 	return mergeable ? "mergeable" : "not mergeable";
@@ -5799,11 +4290,6 @@ function formatPrLine(pr) {
 	line += `  ${formatMergeable(pr.mergeable)}`;
 	return line;
 }
-/**
-* The refused-read counterpart of {@link formatPrLine}, in the same one-line slot. Only the first
-* line of the forge's message survives here -- the hint and the response body it carries are worth
-* keeping in structured output, but not worth turning one line of a human view into five.
-*/
 function formatPrUnavailableLine(unavailable) {
 	const breakAt = unavailable.reason.indexOf("\n");
 	return `pr: unavailable -- ${breakAt === -1 ? unavailable.reason : unavailable.reason.slice(0, breakAt)}`;
@@ -5843,24 +4329,15 @@ function parseState$1(state) {
 	if (state === "open" || state === "closed" || state === "all") return state;
 	throw new InvalidListQueryError("state", state);
 }
-/**
-* The limit is the accumulation target the paged `IssueApi.list` reads up to (page size is
-* the transport's own), so a non-positive or non-numeric value would either be rejected
-* confusingly by the upstream API or -- worse -- silently produce an unbounded/surprising
-* result set. A garbage value the caller explicitly typed is bad input, not something to clamp
-* into a guess: reject it.
-*/
 function parseLimit$1(raw) {
 	const limit = Number(raw);
 	if (!Number.isInteger(limit) || limit <= 0) throw new InvalidListQueryError("limit", raw);
 	return limit;
 }
-/** An absent or whitespace-only label means "no filter" -- never send `labels=`. */
 function normalizeLabel(label) {
 	if (label === void 0 || label.trim() === "") return void 0;
 	return label;
 }
-/** List issues, filtered by state and label, up to a limit. */
 async function listIssues(resolve, request) {
 	const label = normalizeLabel(request.label);
 	const query = {
@@ -5877,17 +4354,6 @@ async function listIssues(resolve, request) {
 		truncated
 	};
 }
-/**
-* Post a new comment on an issue. Always a POST, never a PATCH: an earlier
-* design searched the issue's comments for a marker tag and
-* edited the matching one, but that required the caller to hold comment-edit
-* power and to resolve the authenticated user (`read:user` scope) to scope
-* the search safely -- and even then, a substring match could still land on
-* the wrong self-authored comment (e.g. a plan document that happens to quote
-* the marker string). Append-only removes the entire vulnerability class:
-* the worst failure mode is an extra comment (noise), never an edited or
-* destroyed one.
-*/
 async function commentOnIssue(resolve, request) {
 	const ref = parseIssueRef(request.ref);
 	const number = requireIssueNumber(ref);
@@ -5903,30 +4369,9 @@ async function commentOnIssue(resolve, request) {
 		url: issueUrl
 	};
 }
-/** Human-readable summary of {@link commentOnIssue}'s result. */
 function formatIssueComment(result, dryRun) {
 	return `${dryRun ? "[dry-run] Would comment" : "Commented"} on issue #${String(result.number)}`;
 }
-/**
-* Edit an issue's title and/or body, sending **only** the fields explicitly supplied.
-*
-* This is a PATCH, unlike {@link commentOnIssue}, and the difference is worth stating because the
-* two look superficially alike. Commenting is append-only because an earlier design *searched*
-* an issue's comments for a marker and edited whichever matched -- a substring match could land on
-* the wrong self-authored comment, so nothing here holds comment-edit power at all. Nothing
-* here searches for anything: the caller names one issue by number or URL, and that exact object is
-* what changes. The vulnerability was in the targeting, not in the verb.
-*
-* Nothing is ever derived. An omitted title or body is not resolved to a default computed
-* from somewhere else, because that is precisely how a pull request create once replaced an
-* authored description with a humanized branch name and a bullet list of commit subjects. Here an
-* omitted field is simply not sent. With **neither** supplied there is nothing to do -- no
-* push to be the real work, as a pull request update has -- so it refuses
-* ({@link NothingToUpdateError}) rather than make a no-op API call that reports success.
-*
-* The issue is read first, so a dry run can show the text a new body is about to replace, and so
-* the result reports the true before-and-after rather than echoing back the arguments.
-*/
 async function updateIssue(resolve, request) {
 	const ref = parseIssueRef(request.ref);
 	const number = requireIssueNumber(ref);
@@ -5965,14 +4410,6 @@ async function updateIssue(resolve, request) {
 		changed
 	};
 }
-/**
-* Human-readable summary of an issue update.
-*
-* A field that was sent but matched what was already there is reported as unchanged rather than as
-* a change. The PATCH is harmless (it converges on the same value), but printing an arrow from a
-* string to itself is the same species of untruth as reporting content that was never sent -- and
-* this is usually a caller who pasted the current title back in and wants to know that.
-*/
 function formatIssueUpdate(result, dryRun) {
 	const lines = [`${dryRun ? "Would update" : "Updated"} issue #${String(result.number)} (${result.url})`];
 	const untouched = ["title", "body"].filter((f) => !result.changed.includes(f));
@@ -5994,26 +4431,10 @@ function formatIssueUpdate(result, dryRun) {
 	if (untouched.length > 0) lines.push(`  ${untouched.join(" and ")} left as authored`);
 	return lines.join("\n");
 }
-/** A requested assignee absent from the case-insensitive lowercased set of what the forge
-* actually returned. */
 function droppedAssignees(requested, returned) {
 	const returnedLower = new Set(returned.map((name) => name.toLowerCase()));
 	return requested.filter((name) => !returnedLower.has(name.toLowerCase()));
 }
-/**
-* Open a new issue. Unlike {@link commentOnIssue}, there is no pre-existing issue
-* number to build a URL from -- the issue doesn't exist until the POST
-* succeeds -- so a dry run reports a placeholder `{ number: 0, url: "" }`
-* rather than composing a guess.
-*
-* A non-empty `assignees` is verified against the created issue's own returned assignees
-* (case-insensitively -- both forges echo canonical casing, which need not match what was
-* typed). GitHub documents silently dropping an assignee the caller lacks push access to
-* grant; a name requested but absent from the response is not a partial success, so this
-* throws naming the dropped users **and** the issue's number and URL -- the issue was
-* created, and an error that hides that would send the caller into a duplicate-create loop.
-* See `docs/forge-issue-pr-linking.md` for the shape of bug a softer warning would repeat.
-*/
 async function createIssue(resolve, request) {
 	const title = request.title.trim();
 	if (title === "") throw new IssueTitleRequiredError();
@@ -6039,10 +4460,6 @@ async function createIssue(resolve, request) {
 		assignees: request.assignees
 	};
 }
-/**
-* Human-readable summary of {@link createIssue}'s result, one line per entry. `title` is the title
-* as the caller gave it, since a dry run's result carries none.
-*/
 function formatIssueCreate(result, title, dryRun) {
 	if (dryRun) return [`[dry-run] Would open an issue titled "${title}"${result.assignees.length > 0 ? ` assigned to ${result.assignees.join(", ")}` : ""}`];
 	const lines = [`Opened issue #${String(result.number)}`];
@@ -6064,15 +4481,9 @@ function formatIssueList(result) {
 }
 //#endregion
 //#region src/issue-transport.ts
-/** The sentence for a github.com repository, which owes the reader the alternatives. */
 function githubRefusal(command) {
 	return `bst-fj is Forgejo-only -- use \`gh\` or \`bst ${command}\` for a github.com repository.`;
 }
-/**
-* The fetcher, connection and resolved coordinates for a call only Forgejo can serve. `command`
-* is the command's own name (for example `issue:view`), so a refusal points at the command the
-* reader was running.
-*/
 function forgejoIssueTarget(cwd, target, command) {
 	const conn = requireForgejoTarget(cwd, target, githubRefusal(command));
 	return {
@@ -6085,7 +4496,6 @@ function forgejoIssueTarget(cwd, target, command) {
 		}
 	};
 }
-/** {@link forgejoIssueTarget}, with the issue API over its connection. */
 function forgejoIssueTransport(cwd, target, command) {
 	const resolved = forgejoIssueTarget(cwd, target, command);
 	return {
@@ -6228,10 +4638,6 @@ const issueCreateCommand = defineCommand({
 });
 //#endregion
 //#region ../forgejo/src/issue-run-download.ts
-/**
-* True only for a file that can be read. A directory or an unreadable path counts as absent, so
-* the later write fails with the real error instead of a misleading "already exists".
-*/
 function isReadableFile(filePath) {
 	try {
 		readFileSync(filePath);
@@ -6247,7 +4653,6 @@ const diskFiles = {
 		writeFileSync(filePath, content);
 	}
 };
-/** Raised when a download would overwrite a file and `force` is off. */
 var AttachmentExistsError = class extends FatalError {
 	filePath;
 	constructor(filePath) {
@@ -6255,13 +4660,6 @@ var AttachmentExistsError = class extends FatalError {
 		this.filePath = filePath;
 	}
 };
-/**
-* Attachment names are supplied by whoever uploaded the file: `../../.ssh/authorized_keys`
-* is a legal name. Reduce to a bare basename -- strip, do not merely reject -- so nothing can
-* escape the output directory. Control characters (0x00-0x1F, 0x7F) are stripped too: a NUL
-* or newline riding along in the name would otherwise reach `fs` (which throws a raw
-* `TypeError` for embedded NULs) or rendered output (fabricated lines, ANSI codes).
-*/
 function sanitizeAttachmentName(name) {
 	const stripped = Array.from(name).filter((ch) => {
 		const code = ch.codePointAt(0) ?? 0;
@@ -6271,7 +4669,6 @@ function sanitizeAttachmentName(name) {
 	if (base === "" || base === "." || base === "..") throw new FatalError(`Refusing to write an attachment with an unusable filename: "${name}"`);
 	return base;
 }
-/** Give same-named attachments distinct paths (`plan.md`, `plan-2.md`) instead of clobbering. */
 function resolveTargetPath(outDir, name, taken) {
 	const safe = sanitizeAttachmentName(name);
 	const ext = path.extname(safe);
@@ -6288,20 +4685,6 @@ function resolveTargetPath(outDir, name, taken) {
 	if (target !== root && !target.startsWith(root + path.sep)) throw new FatalError(`Refusing to write outside ${outDir}: "${name}"`);
 	return target;
 }
-/**
-* Fetch one attachment's bytes and verify them against the size the API declared.
-*
-* A `200` does not prove we got the file: unauthenticated, Forgejo serves an HTML
-* login page with a 200 status. Verifying the length is what stops that login page
-* from landing on disk named `plan.md`, where a reader would then act on it.
-* Nothing is written until the bytes check out.
-*
-* Exported because a caller that wants the bytes in memory rather than on disk -- one
-* collecting an issue's images for a container -- needs exactly this check and has no way
-* to write it without the same reasoning about the login page. It lives here, beside its
-* only other caller, rather than in a new module: `packages/forgejo/src` sits at its
-* crowding ceiling.
-*/
 async function downloadAttachment(fetcher, token, attachment) {
 	const res = await fetcher.fetch(attachment.downloadUrl, { headers: { Authorization: `token ${token}` } }, { timeoutMs: LONG_FETCH_TIMEOUT_MS });
 	if (res.status === 401 || res.status === 403 || res.status === 404) throw new FatalError(`Cannot download "${attachment.name}" (HTTP ${String(res.status)}) -- the token needs issue scope and access to this repository.`);
@@ -6311,12 +4694,6 @@ async function downloadAttachment(fetcher, token, attachment) {
 	if (body.byteLength !== attachment.size) throw new FatalError(`Refusing to write "${attachment.name}": expected ${String(attachment.size)} bytes but received ${String(body.byteLength)}. The server returned a 200 with the wrong content -- most likely a login page, meaning the token cannot see this attachment.`);
 	return body;
 }
-/**
-* Download every attachment on an issue: the ones inline on the issue itself, plus
-* any hanging off its comments. Forgejo-only -- GitHub has no issue-attachment API
-* (its attachments are Markdown links in the issue body), so the resolver is where a
-* caller refuses a GitHub target, before any request is made.
-*/
 async function downloadIssueAttachments(resolve, request) {
 	const ref = parseIssueRef(request.ref);
 	const number = requireIssueNumber(ref);
@@ -6346,7 +4723,6 @@ async function downloadIssueAttachments(resolve, request) {
 		files: downloaded
 	};
 }
-/** Human-readable summary of a download. */
 function formatDownload(result, dryRun) {
 	const lines = [];
 	const verb = dryRun ? "[dry-run] Would download" : "Downloaded";
@@ -6416,12 +4792,6 @@ const issueDownloadCommand = defineCommand({
 });
 //#endregion
 //#region ../forgejo/src/issue-labels.ts
-/**
-* Forgejo encodes a timeline label change in `body`, not a dedicated field: `"1"` marks an
-* addition, `""` marks a removal. This is Forgejo/Gitea's internal representation, not a
-* documented contract, and unverifiable against a live forge from a sandbox -- so any
-* other value is treated as unrecognised and the entry is dropped rather than guessed at.
-*/
 const TimelineEntrySchema = z.object({
 	id: z.number(),
 	type: z.string(),
@@ -6431,13 +4801,6 @@ const TimelineEntrySchema = z.object({
 	user: z.object({ login: z.string() }).nullish()
 });
 z.array(TimelineEntrySchema).nullable();
-/**
-* Resolve one label name to its numeric id (see `resolveLabelIds` in `label-provisioning.ts`).
-* When the caller already has a name->id map (e.g. from `ensureForgejoLabels`), this
-* short-circuits on it instead of re-fetching the full label list -- a caller otherwise pays
-* one identical fetch per mutation (ensure + add + up to 2 removes) for information already in
-* hand.
-*/
 async function resolveLabelId(executor, conn, name, labelIds) {
 	const cached = labelIds?.get(name);
 	if (cached !== void 0) return cached;
@@ -6445,10 +4808,6 @@ async function resolveLabelId(executor, conn, name, labelIds) {
 	if (id === void 0) throw new UnexpectedError(`Label id resolution returned nothing for "${name}"`);
 	return id;
 }
-/**
-* Attach a label (by name) to an issue. `labelIds`, when given, skips the name->id list
-* fetch (see {@link resolveLabelId}).
-*/
 async function addForgejoIssueLabel(executor, conn, number, name, labelIds) {
 	const id = await resolveLabelId(executor, conn, name, labelIds);
 	const res = await executor.fetch(`${issuesBase(conn)}/${String(number)}/labels`, {
@@ -6461,11 +4820,6 @@ async function addForgejoIssueLabel(executor, conn, number, name, labelIds) {
 		resource: `#${String(number)}`
 	}, issueNotFoundMessage(conn, number));
 }
-/**
-* Detach a label (by name) from an issue. Idempotent -- Forgejo returns 204 whether or
-* not the label was attached, so a double-drop is harmless.
-* `labelIds`, when given, skips the name->id list fetch (see {@link resolveLabelId}).
-*/
 async function removeForgejoIssueLabel(executor, conn, number, name, labelIds) {
 	const id = await resolveLabelId(executor, conn, name, labelIds);
 	const res = await executor.fetch(`${issuesBase(conn)}/${String(number)}/labels/${String(id)}`, {
@@ -6477,12 +4831,6 @@ async function removeForgejoIssueLabel(executor, conn, number, name, labelIds) {
 		resource: `#${String(number)}`
 	}, issueNotFoundMessage(conn, number));
 }
-/**
-* Replace an issue's entire label set in one atomic PUT (Forgejo "Replace an issue's labels").
-* Unlike add/remove, this is a single transition with no half-applied window -- the primitive
-* the label state machine's exactly-one invariant relies on. Idempotent: re-PUTting the same
-* set re-establishes the same state, so a transient blip is safe to retry.
-*/
 async function replaceForgejoIssueLabels(executor, conn, number, labelIds) {
 	const res = await executor.fetch(`${issuesBase(conn)}/${String(number)}/labels`, {
 		method: "PUT",
@@ -6496,12 +4844,6 @@ async function replaceForgejoIssueLabels(executor, conn, number, labelIds) {
 }
 //#endregion
 //#region ../forgejo/src/issue-run-labels.ts
-/**
-* Add or remove a single label on an issue. Forgejo-only: the label helpers take a raw
-* connection and no GitHub label transport is wired through `IssueApi`, so the resolver is where
-* a caller refuses a github.com target, before any request. `repo` names a repository other than
-* the working directory's; an issue URL carries its own coordinates.
-*/
 async function labelIssue(resolve, request) {
 	const ref = parseIssueRef(request.ref);
 	const number = requireIssueNumber(ref);
@@ -6522,7 +4864,6 @@ async function labelIssue(resolve, request) {
 		url
 	};
 }
-/** Human-readable summary of a label add or remove. */
 function formatIssueLabel(result, dryRun) {
 	const adding = result.action === "add";
 	let verb;
@@ -6531,7 +4872,6 @@ function formatIssueLabel(result, dryRun) {
 	const prep = adding ? "to" : "from";
 	return `${verb} label "${result.label}" ${prep} #${String(result.number)} (${result.url})`;
 }
-/** Raised when an empty label set arrives without `clear`. Carries the issue it would have stripped. */
 var NoLabelsGivenError = class extends FatalError {
 	number;
 	constructor(number) {
@@ -6539,22 +4879,6 @@ var NoLabelsGivenError = class extends FatalError {
 		this.number = number;
 	}
 };
-/**
-* Replace an issue's entire label set in one atomic call (Forgejo-only, like {@link labelIssue}).
-*
-* **The current set is read first, and the result reports the diff.** Replacement is the whole
-* point of the call, so a label the caller omitted is meant to go -- but "meant to go" and
-* "the caller knew it was there" are different things, and only the second is worth relying on.
-* Without the read, a dry run could only echo the arguments back: it told you what you had just
-* typed and nothing about what it would destroy, which is not a preview.
-*
-* **An empty set additionally requires `clear`.** Every other call is an explicit instruction --
-* you named the labels you want. An empty list is the one shape a caller can arrive at by
-* accident: a variable or glob that expanded to nothing produces exactly the request that strips
-* the issue bare, including a label a caller's own scheme says must never be absent.
-* Requiring `clear` costs the deliberate caller almost nothing and makes the accidental one
-* impossible. It is not a confirmation prompt -- this must stay scriptable.
-*/
 async function setIssueLabels(resolve, request) {
 	const ref = parseIssueRef(request.ref);
 	const number = requireIssueNumber(ref);
@@ -6572,7 +4896,6 @@ async function setIssueLabels(resolve, request) {
 		...diff
 	};
 }
-/** Set difference both ways, order-preserving so the report reads in the order the caller sees. */
 function diffLabels(previous, next) {
 	const before = new Set(previous);
 	const after = new Set(next);
@@ -6581,13 +4904,6 @@ function diffLabels(previous, next) {
 		removed: previous.filter((name) => !after.has(name))
 	};
 }
-/**
-* Human-readable summary of a label-set replacement.
-*
-* Leads with what is destroyed. The resulting set is the easy half to reconstruct (the caller
-* typed it); the removals are the half worth putting in front of someone, and on a dry run they
-* are the entire reason to have run it.
-*/
 function formatIssueSetLabels(result, dryRun) {
 	const head = `${dryRun ? "Would set" : "Set"} labels [${result.labels.length === 0 ? "(none)" : result.labels.join(", ")}] on #${String(result.number)} (${result.url})`;
 	if (result.added.length === 0 && result.removed.length === 0) return `${head}\n  no change (the issue already carries exactly these)`;
@@ -6719,13 +5035,11 @@ const issueSetLabelsCommand = defineCommand({
 });
 //#endregion
 //#region ../forgejo/src/issue-run-state.ts
-/** Raised when a comment was given but is empty or only whitespace. */
 var EmptyCommentError = class extends FatalError {
 	constructor() {
 		super("The comment resolved to empty text.");
 	}
 };
-/** Raised when a state write targets a pull request, whose state is not written here. */
 var PullRequestStateError = class extends FatalError {
 	number;
 	action;
@@ -6739,16 +5053,6 @@ const TARGET_STATE = {
 	close: "closed",
 	reopen: "open"
 };
-/**
-* Write an issue's open/closed state, and nothing else. The run is: read, refuse or converge,
-* comment, then write state -- see `IssueApi.setState`'s doc comment for why state never travels
-* through `update`'s patch.
-*
-* The comment (if any) is posted **before** the state write, deliberately: a comment-landed /
-* state-failed split leaves a still-open issue with an explanatory comment on it, which is
-* survivable and visible. The reverse order would leave a closed issue with nothing saying why,
-* and it would fail silently -- exactly the window this call exists to close.
-*/
 async function setIssueState(resolve, request) {
 	const ref = parseIssueRef(request.ref);
 	const number = requireIssueNumber(ref);
@@ -6785,7 +5089,6 @@ const PAST_TENSE = {
 	close: "Closed",
 	reopen: "Reopened"
 };
-/** Human-readable summary of a close or reopen. */
 function formatIssueState(result, dryRun) {
 	const lines = [];
 	if (!result.changed) lines.push(`#${String(result.number)} is already ${result.state.current} -- nothing to ${result.action}. (${result.url})`);
@@ -6932,11 +5235,6 @@ const issueListCommand = defineCommand({
 });
 //#endregion
 //#region src/commands/issue-update.ts
-/**
-* Edit an existing issue's title and/or body. It PATCHes exactly the issue named, and only the
-* fields passed: an omitted field is never replaced by a derived value, and passing neither is
-* an error, not a no-op.
-*/
 const issueUpdateCommand = defineCommand({
 	meta: {
 		name: "issue:update",
@@ -7063,31 +5361,6 @@ const issueSubCommands = {
 };
 //#endregion
 //#region src/pr-checks.ts
-/**
-* `bst-fj pr:checks` -- the PR CI verdict, read live off the PR's current head SHA over the same
-* `@bensandee/forgejo` primitive the automerge gate uses (`readCommitChecks`), so the agent and
-* the CLI cannot drift about what green means.
-*
-* This module owns the whole runner (`runPrChecks`); `commands/pr-checks.ts` is the thin citty
-* definition over it. Resolution -- turning `--pr`/`--branch`/`--repo`/the current checkout into a
-* PR number, a live `ForgejoConnection`, and that PR's detail -- is `resolvePrChecksTarget` below,
-* kept as its own function because it is where every refusal lives: no PR for a branch, a
-* `--repo` with neither `--pr` nor `--branch`, or a github.com target. Reads GET-only, at every
-* step, under every flag.
-*/
-/**
-* Resolve `--pr`/`--branch`/`--repo`/the current checkout into a PR number, a live
-* `ForgejoConnection`, and that PR's detail -- the whole set of ways this command can be told "no"
-* before it ever reads a check.
-*
-* Order: `--pr` (a number or URL, the URL carrying its own repository) wins; otherwise `--branch`
-* resolves through {@link findOpenPr}; otherwise the current checkout's branch does, through the
-* same lookup. `--repo` requires an explicit `--pr` or `--branch`: the current branch of this
-* checkout means nothing in another repository, and inferring it there would silently answer
-* about the wrong PR. A github.com target refuses before any request -- GitHub Actions publishes
-* check runs, not commit statuses, so a combined-status read against it would confidently report
-* `no-status` for a green PR.
-*/
 async function resolvePrChecksTarget(fetcher, options) {
 	const ref = parseIssueRef(options.pr);
 	if (options.repo !== void 0 && ref.number === void 0 && options.branch === void 0) throw new FatalError("--repo requires --pr or --branch -- the current branch of this checkout means nothing in another repository, and inferring it there would silently answer about the wrong PR.");
@@ -7113,22 +5386,6 @@ async function resolvePrChecksTarget(fetcher, options) {
 		detail
 	};
 }
-/**
-* Read the base branch's current head checks and report which normalized names read red there --
-* the baseline a PR head's own red checks are compared against. Matched by normalized `name`, not
-* raw `context`: Forgejo folds the triggering event into the context, so the same job reads
-* `CI / check (pull_request)` on the PR and `CI / check (push)` on `main`, and exact-string
-* matching would fail in precisely the case this annotation exists for.
-*
-* `baseline: false` (`--no-baseline`) skips both reads entirely and reports `"skipped"`. Any other
-* failure to establish a clean baseline -- the branch-head read failing, the status read failing,
-* an unparseable status body, or zero statuses on the base head -- reports `"unavailable"` with a
-* `reason`, never `"read"` with an empty `redNames`: an empty list must mean "read, and none were
-* red", not "could not tell".
-*
-* Exported for the agent's automerge sweep, which annotates its CI-red hold with the same
-* baseline.
-*/
 async function readBaseline(fetcher, conn, baseRef, enabled) {
 	if (!enabled) return {
 		ref: baseRef,
@@ -7169,12 +5426,6 @@ async function readBaseline(fetcher, conn, baseRef, enabled) {
 		redNames
 	};
 }
-/**
-* Assemble a {@link PrChecksReport} from a PR detail read, a commit-status read, and the
-* once-per-invocation baseline -- the one place that shape is built, so the read-once path and
-* every `--wait` exit (settled, `head-moved`, `timeout`, retry-budget exhaustion) produce
-* identically-shaped reports.
-*/
 function buildReport(detail, checks, ctx, extras = {}) {
 	const { target, baseline, notices, waited, elapsedMs } = ctx;
 	const preexistingNames = new Set(baseline.status === "read" ? baseline.redNames : []);
@@ -7203,21 +5454,6 @@ function buildReport(detail, checks, ctx, extras = {}) {
 	if (extras.previousHeadSha !== void 0) report.previousHeadSha = extras.previousHeadSha;
 	return report;
 }
-/**
-* Poll the PR's live head until its checks settle, following the spec's poll contract: each poll
-* re-reads the PR detail (never pinning the head SHA from an earlier poll) and then that head's
-* commit status -- exactly two reads. A changed head SHA ends the wait immediately as
-* `head-moved`, carrying both SHAs, rather than re-pinning and continuing: a verdict for a commit
-* that is no longer head is meaningless, and following a rebasing head would let the wait outlive
-* its own timeout. Settlement additionally requires a **quiet interval**: two consecutive polls,
-* one interval apart, both settled with the same set of contexts -- a job that has posted no status
-* yet is invisible to this endpoint, so a workflow registering moments after another finished would
-* otherwise be reported settled before it ever ran. A red check never short-circuits the wait; the
-* point of `--wait` is a complete report. Up to {@link RETRY_BUDGET} consecutive failed or
-* unparseable status reads are absorbed (the counter resets on any good read) before the wait gives
-* up as `unparseable`; a timeout still reports whatever was last observed. The per-poll PR-detail
-* read carries its own budget of the same size, exhausting into a rethrow.
-*/
 async function waitForSettledChecks(fetcher, target, baseline, notices, poll) {
 	const { timeoutMs, intervalMs, sleep, now } = poll;
 	const startedAt = now();
@@ -7289,13 +5525,6 @@ async function waitForSettledChecks(fetcher, target, baseline, notices, poll) {
 		currentDetail = nextDetail;
 	}
 }
-/**
-* Read the PR's current head SHA's checks and produce a report -- classified into
-* {@link PrChecksStatus}, over one combined-status read by default or, with `options.wait`, over
-* {@link waitForSettledChecks}'s poll loop. Never touches `process.exitCode` and never prints: that
-* is `commands/pr-checks.ts`'s job, which also relays `report.notices` through `CliOutput.notice`
-* and strips it before emitting the JSON payload.
-*/
 async function runPrChecks(fetcher, options) {
 	const timings = options.wait === true ? resolvePollTimings(options) : void 0;
 	const target = await resolvePrChecksTarget(fetcher, options);
@@ -7319,12 +5548,6 @@ async function runPrChecks(fetcher, options) {
 		elapsedMs: 0
 	});
 }
-/**
-* The baseline summary clause, e.g. `3 red, 1 of them already red on main` -- present only when
-* the baseline was actually read and at least one check is red. An unavailable or skipped
-* baseline never earns a clause: saying nothing is the honest answer when "how many were
-* pre-existing" cannot be established, never an implied zero.
-*/
 function baselineClause(report) {
 	if (report.baseline.status !== "read") return null;
 	const redChecks = report.checks.filter((check) => check.verdict === "red");
@@ -7332,12 +5555,6 @@ function baselineClause(report) {
 	const preexistingCount = redChecks.filter((check) => check.preexisting).length;
 	return `${String(redChecks.length)} red, ${String(preexistingCount)} of them already red on ` + report.baseline.ref;
 }
-/**
-* Render a `pr:checks` report as text: one line per check (its state, context and description,
-* with the target URL appended only for a red check -- the line a human is about to go read), then
-* a summary line carrying the head SHA, the verdict, the baseline clause when there is one, and
-* the PR URL.
-*/
 function renderPrChecks(report) {
 	const lines = report.checks.map((check) => {
 		const parts = [check.state, check.context];
@@ -7420,34 +5637,10 @@ const prChecksCommand = defineCommand({
 });
 //#endregion
 //#region ../forgejo/src/closing-refs.ts
-/**
-* A closing keyword and the issue it references, e.g. `Closes #<n>`.
-*
-* Both boundaries mirror the forge's own matcher, and both are load-bearing against
-* fabricating a link the author never wrote. Leading `(?:^|[\s([])` (Forgejo's regex uses
-* exactly this set): without it `fix(es)?` matches the tail of "prefixes #12". Trailing
-* `(?![\w-])`: without it a `fix` keyword followed by `#12-of-3` harvests `#12` -- text the
-* forge would not treat as a reference, converted into a canonical footer line that closes a
-* real issue. The
-* separator is line-bound (`[ \t]`, never `\s`) so a keyword ending one line and an issue
-* number starting the next stay unrelated statements. The optional colon is deliberate --
-* `Fixes: #1` is a real reference (Forgejo's own regex ends `:?`), so do not codify a
-* no-colon rule; but a separator of some kind is required, so `fixes` run straight into
-* `#12` is nothing.
-*/
 const CLOSING_REF = /(?:^|[\s([])(clos(?:e|es|ed)|fix(?:es|ed)?|resolv(?:e|es|ed))(?::[ \t]*|[ \t]+)((?:[\w.-]+\/[\w.-]+)?#\d+)(?![\w-])/gim;
-/** Uppercase the first letter, so `closes #<n>` renders as `Closes #<n>`. */
 function capitalize(word) {
 	return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
 }
-/**
-* Harvest `Closes #<n>` references from full commit messages, deduplicated by issue,
-* first keyword winning.
-*
-* These must be read from whole messages (the `%B` format of `git log`), not subjects: a closing
-* keyword conventionally lives in the commit *footer*, and reading only `%s` silently
-* dropped it -- the PR then merged without ever linking the issue.
-*/
 function extractClosingRefs(messages) {
 	const byIssue = /* @__PURE__ */ new Map();
 	for (const message of messages) for (const [, keyword, issue] of message.matchAll(CLOSING_REF)) {
@@ -7460,44 +5653,13 @@ function extractClosingRefs(messages) {
 	}
 	return [...byIssue.values()];
 }
-/**
-* The issues `text` closes, for filtering refs against a body or bullet list. Reusing
-* CLOSING_REF is the point: a bare mention ("refs #281", "see upstream/lib#281") must NOT
-* satisfy a closing reference -- treating it as satisfied is precisely the silent link
-* loss this module exists to prevent -- and the regex's own boundaries keep `#28` from
-* matching inside `#281` and `#4` from matching inside `owner/repo#4`.
-*/
 function closedIssues(text) {
 	return new Set(extractClosingRefs([text]).map((ref) => ref.issue.toLowerCase()));
 }
-/**
-* The closing refs `messages` make that `body` does not -- the links that will be lost if `body`
-* is what lands on the PR. Extracted so the derive path and the update path compute "dropped"
-* from one definition: `derivePrContent` reports it for an explicit body it was handed, while
-* `checkClosingLinks` reports it for a body the update is deliberately *not* rewriting (the PR's
-* existing one).
-* Those are the same question asked about two different bodies, and answering it twice would let
-* the two drift.
-*/
 function droppedClosingRefs(messages, body) {
 	const closed = closedIssues(body);
 	return extractClosingRefs(messages).filter((ref) => !closed.has(ref.issue.toLowerCase()));
 }
-/**
-* Append to `target` any closing reference `source` makes that `target` does not carry, so neither
-* body's closing references are lost when one replaces the other -- used both when a managed body
-* replaces a preserved one (the human's own `Fixes #<m>` survives) and when a preserved body is kept
-* over a managed one (the run's `Closes #<n>` still lands). Reuses {@link droppedClosingRefs}, not a
-* second definition of what counts as a closing reference, so a bare mention ("refs #42") is never
-* treated as satisfying one. Appended refs land one per line under a blank line; when `target` is
-* empty or whitespace-only they become the whole body instead of trailing a leading blank line.
-* Returns `target` unchanged when nothing is missing, so the no-op patch omission this feeds is a
-* plain equality check.
-*
-* Exported for callers that PATCH a managed PR body directly (`updatePr`, no git operations)
-* rather than through the upsert -- the same "human's `Fixes #<m>` survives" guarantee
-* `planPrUpdate` gives a finalize, reused rather than redefined for a lighter-weight caller.
-*/
 function carryForwardClosingRefs(source, target) {
 	const missing = droppedClosingRefs([source], target);
 	if (missing.length === 0) return target;
@@ -7506,18 +5668,8 @@ function carryForwardClosingRefs(source, target) {
 }
 //#endregion
 //#region ../forgejo/src/git.ts
-/** A git child that touches no network: `rev-parse`, `log`, `status`, `symbolic-ref`. */
 const GIT_LOCAL_TIMEOUT_MS = 6e4;
-/** A git child that publishes: `push`. Longer than a local read, because the upload is sized by
-* the branch rather than by the round trip. */
 const GIT_WRITE_TIMEOUT_MS = 3e5;
-/**
-* The repo's default branch: a non-empty `override` wins, then `originHead` (the output of
-* `git symbolic-ref --short refs/remotes/origin/HEAD`) without its `origin/` prefix, then `main`.
-*
-* Only the leading `origin/` is stripped: a branch name can itself contain a slash (a release
-* train like `release/2.x`), so taking everything after the last slash would truncate it.
-*/
 function pickDefaultBranch(override, originHead) {
 	if (override !== void 0 && override !== "") return override;
 	if (originHead !== void 0) {
@@ -7526,7 +5678,6 @@ function pickDefaultBranch(override, originHead) {
 	}
 	return "main";
 }
-/** `origin/HEAD`'s branch name (`origin/<name>`), or undefined when git cannot say. */
 async function resolveOriginHead(git, cwd, signal = null) {
 	const result = await git.run([
 		"symbolic-ref",
@@ -7541,7 +5692,6 @@ async function resolveOriginHead(git, cwd, signal = null) {
 	const out = result.stdout.trim();
 	return out === "" ? void 0 : out;
 }
-/** The checked-out branch. Throws when there is none: not a repository, or a detached HEAD. */
 async function currentBranch(git, cwd, signal = null) {
 	const result = await git.run([
 		"rev-parse",
@@ -7557,11 +5707,6 @@ async function currentBranch(git, cwd, signal = null) {
 	if (branch === "HEAD") throw new FatalError("HEAD is detached. Check out a feature branch first.");
 	return branch;
 }
-/**
-* Prefer `origin/<base>` as the merge-base ref: the local branch may be stale
-* or absent in a worktree. Fall back to the local ref when the remote-tracking
-* ref does not exist.
-*/
 async function baseRef(git, cwd, base, signal = null) {
 	const remote = `origin/${base}`;
 	const result = await git.run([
@@ -7576,7 +5721,6 @@ async function baseRef(git, cwd, base, signal = null) {
 	});
 	return result.exitCode === 0 && result.stdout.trim() !== "" ? remote : base;
 }
-/** The subjects of the commits on `ref..HEAD`, newest first, as `git log` prints them. */
 async function commitSubjects(git, cwd, ref, signal = null) {
 	return (await git.run([
 		"log",
@@ -7588,18 +5732,6 @@ async function commitSubjects(git, cwd, ref, signal = null) {
 		signal
 	})).stdout.split("\n").map((line) => line.trim()).filter((line) => line !== "");
 }
-/**
-* Full commit messages, subject and body, one string per commit (`-z` NUL-separates them --
-* a message can contain anything else, including blank lines). Per-commit granularity
-* matters: concatenated, a message ending in "...the hot fix" and the next one starting
-* "#12 rework..." would read as a closing reference no single author ever wrote.
-*
-* A separate `%B` read rather than widening the `%s` one: subjects drive the title and the
-* bullet list, where a multi-line body would be noise. This exists only so closing keywords
-* survive -- they conventionally sit in the commit footer, which `%s` discards. And it must
-* fail loudly: swallowing a failed read here degrades to exactly the silent keyword-dropping
-* bug this path exists to fix.
-*/
 async function commitMessages(git, cwd, ref, signal = null) {
 	const result = await git.run([
 		"log",
@@ -7614,7 +5746,6 @@ async function commitMessages(git, cwd, ref, signal = null) {
 	if (result.exitCode !== 0) throw new FatalError(`Failed to read commit messages: ${result.stderr || result.stdout}`);
 	return result.stdout.split("\0").map((message) => message.trim()).filter((message) => message !== "");
 }
-/** Whether `git status --porcelain` lists anything. */
 async function hasUncommittedChanges(git, cwd, signal = null) {
 	return (await git.run(["status", "--porcelain"], {
 		cwd,
@@ -7622,19 +5753,6 @@ async function hasUncommittedChanges(git, cwd, signal = null) {
 		signal
 	})).stdout.trim() !== "";
 }
-/**
-* Push `branch` to `origin` and set it as the upstream. `env` is extra environment for the push
-* alone -- how a caller whose clone carries no credentials supplies them without putting a token
-* in argv or on disk.
-*
-* `forceWithLease` pushes with git's bare `--force-with-lease`, never a bare force: a caller that
-* rebased the branch onto the default branch rewrote history the remote already has, so a plain
-* push is rejected non-fast-forward, and the lease still refuses to clobber a remote that changed
-* since the clone. A caller that needs an explicit `<branch>:<sha>` lease -- because something
-* else may have moved the clone's own remote-tracking ref -- pushes itself instead.
-*
-* The push is not wired to an abort signal.
-*/
 async function pushBranch(git, cwd, branch, env, forceWithLease = false) {
 	const pushArgs = forceWithLease ? [
 		"push",
@@ -7662,7 +5780,6 @@ async function pushBranch(git, cwd, branch, env, forceWithLease = false) {
 }
 //#endregion
 //#region ../forgejo/src/pr-upsert.ts
-/** Conventional-commit types recognized as a branch-name prefix. */
 const COMMIT_TYPES = /* @__PURE__ */ new Set([
 	"feat",
 	"fix",
@@ -7676,16 +5793,9 @@ const COMMIT_TYPES = /* @__PURE__ */ new Set([
 	"style",
 	"revert"
 ]);
-/** Convert a segment to words by replacing dashes and underscores with spaces. */
 function words(segment) {
 	return segment.replaceAll("-", " ").replaceAll("_", " ");
 }
-/**
-* Turn a branch name into a readable title.
-*
-* `feat/pr-helper` -> `feat: pr helper` when the first segment is a
-* conventional-commit type; otherwise every separator becomes a space.
-*/
 function humanizeBranch(branch) {
 	const slash = branch.indexOf("/");
 	if (slash === -1) return words(branch);
@@ -7694,33 +5804,9 @@ function humanizeBranch(branch) {
 	if (COMMIT_TYPES.has(type)) return `${type}: ${words(rest)}`;
 	return `${words(type)} ${words(rest.replaceAll("/", " "))}`;
 }
-/**
-* The `WIP: ` prepend a Forgejo draft signals with, applied only when `draft` is set. Its inverse,
-* `stripWipPrefix`, lives in `pr-title.ts` beside the un-draft that consumes it; the shared
-* `hasWipPrefix` guard here is what keeps the two from drifting -- one definition of what counts as
-* a WIP prefix, so a title is never double-prefixed (`WIP: wip: x`) in a way the remover would only
-* half-clear.
-*/
 function withWipPrefix(title, draft) {
 	return draft && !hasWipPrefix(title) ? `WIP: ${title}` : title;
 }
-/**
-* Resolve the PR title and body: explicit values win, otherwise derive from the
-* branch's commits. A lone commit lends its subject; several commits mean the
-* branch name is the better summary and the subjects become the body.
-*
-* Closing keywords found in the commits are appended to the derived body as a footer,
-* unless the bullets already close that issue (a keyword in a subject carries into its
-* bullet -- appending it again would render `Closes #<n>` twice). A keyword reliably
-* closes an issue only from the **PR body**; in a commit message it is branch-gated on
-* Forgejo (see docs/forge-issue-pr-linking.md), so the derived body is where it must land.
-*
-* `droppedRefs` reports the refs the commits make that `body` does not close. It is the
-* caller's to surface -- losing a link silently is the failure this module exists to
-* prevent. A derived body closes every harvested ref by construction, so drops can only
-* come from an explicit body; computing them here, from the same extraction that built
-* the footer, keeps the report structurally unable to disagree with the body.
-*/
 function derivePrContent(input) {
 	const [only] = input.subjects;
 	const derivedTitle = input.subjects.length === 1 && only !== void 0 ? only : humanizeBranch(input.branch);
@@ -7739,14 +5825,9 @@ function derivePrContent(input) {
 		droppedRefs: []
 	};
 }
-/**
-* Why {@link assertModeAllows} refused. The message names no command; a caller that wants to point
-* the user at the other verb reads `reason`, `branch` and `existing` and words its own refusal.
-*/
 var PrModeError = class extends FatalError {
 	reason;
 	branch;
-	/** The open PR's number, or null when there is none. */
 	existing;
 	constructor(reason, branch, existing) {
 		super(reason === "already-open" ? `${branch} already has an open PR (#${String(existing)}).` : `${branch} has no open PR to update.`);
@@ -7755,61 +5836,13 @@ var PrModeError = class extends FatalError {
 		this.existing = existing;
 	}
 };
-/**
-* Refuse a run whose mode does not match what the forge actually holds. A refusal is nearly always
-* a case of reaching for the habitual verb rather than of genuine confusion about the PR's state,
-* so a caller words it as a pointer at the other verb.
-*/
 function assertModeAllows(mode, existing, branch) {
 	if (mode === "create" && existing !== null) throw new PrModeError("already-open", branch, existing);
 	if (mode === "update" && existing === null) throw new PrModeError("none-open", branch, null);
 }
-/**
-* Whether planning an update needs the PR's live title and body. It is skipped only when neither of
-* two reasons applies:
-*
-* - A field was not supplied. The result's title and body feed the dry-run body print, whose entire
-*   job is to be the last chance to spot a missing closing keyword; echoing content that is never
-*   sent would make that print a lie in exactly the place it is relied on, and it is also what the
-*   dropped-ref check has to be measured against.
-* - The caller expressed no draft intent (`draft === undefined`) and so must not change the PR's
-*   draft state as a side effect of retitling it. On Forgejo the title IS the draft flag, so a
-*   title that drops the marker silently PUBLISHES a draft PR, and the live title is the only place
-*   the marker can be read from.
-*
-* A caller that supplies `managedBodyMarkers` always needs it: deciding ownership needs the live
-* body, and there is no cheaper source.
-*/
 function prUpdateNeedsLive(request) {
 	return request.title === void 0 || request.body === void 0 || request.draft === void 0 || request.managedBodyMarkers !== void 0;
 }
-/**
-* Resolve what an update to an ALREADY-OPEN PR should send: only the fields the caller explicitly
-* supplied, never the commit-derived defaults. `live` is the PR's current content, read when
-* {@link prUpdateNeedsLive} says so and null otherwise; `wipTitles` says whether this forge marks a
-* draft with a title prefix.
-*
-* Derivation is a *create-time* convenience -- a first PR needs some title and body, and the
-* branch's commits are the only material there is. On an update it is a clobber: it replaces a
-* title and body somebody *authored* -- a run's summary, a person's plan seed -- with
-* `humanizeBranch(branch)` and a bullet list.
-*
-* The {@link PrUpsertMode} split is the first half of the guard (a habitual create re-run now
-* refuses instead of rewriting); this is the second, and it is the half that matters, because an
-* update inherits the same habit and would land in exactly the same place. The two are
-* independent: neither alone is sufficient.
-*
-* This is the invariant the rest of the codebase already states from both sides: the un-draft PATCH
-* sends a title only, "never the body, which is the human-authored plan seed". This was the one
-* path that violated it.
-*
-* A caller that supplies `managedBodyMarkers` is routed to
-* {@link planManagedUpdate} instead of the derive-and-patch logic below: ownership is decided from
-* the live body's own prefix, a managed body gets the full patch, and an unmarked (adopted) one is
-* preserved outright, with the WIP marker and the closing reference reconciled rather than the
-* whole body replaced. Its `previousBody` is therefore never null, so {@link checkClosingLinks}
-* runs on that path too -- see there for why the exemption it once had is gone.
-*/
 function planPrUpdate(request, derived, live, wipTitles) {
 	if (request.managedBodyMarkers !== void 0 && live !== null) return planManagedUpdate(request, derived, live, wipTitles);
 	const retitle = request.title === void 0 ? void 0 : derived.title;
@@ -7826,27 +5859,6 @@ function planPrUpdate(request, derived, live, wipTitles) {
 		previousBody: live?.body ?? null
 	};
 }
-/**
-* Resolve an update whose caller supplied `managedBodyMarkers`. Ownership is decided from the live
-* body: it starts with one of the markers (a **prefix** match, because quoting is not ownership) or
-* it does not.
-*
-* **Managed row**: the derived title and body, plus any closing reference the live body carries
-* that the derived one does not, so a human's `Fixes #<m>` added since the body was last written
-* by the caller survives the replacement. A field the caller did not supply is not on this row at all: it
-* falls to the preserve treatment below, mirroring {@link planPrUpdate}'s own `retitle` guard. That
-* guard IS the fix for the PRs whose descriptions a derived title once overwrote, and without the
-* same one here a marker-supplying caller that omitted `title` would PATCH `humanizeBranch(branch)`
-* over a managed PR -- unreachable today, since the only such caller supplies both, which is why it
-* has to be stated rather than observed.
-*
-* **Preserve row**: the live title and body, with exactly two mechanical edits -- the WIP draft
-* marker reconciled to the draft intent ({@link reconcileWipTitle}), and any closing reference the
-* derived body carries that the live one does not appended to it. No other prose moves.
-*
-* Either row omits a field from the patch when its computed value equals the live one, so a PR that
-* already carries the right marker and the right closing line receives no PATCH at all.
-*/
 function planManagedUpdate(request, derived, live, wipTitles) {
 	const managed = (request.managedBodyMarkers ?? []).some((marker) => live.body.startsWith(marker));
 	const rewriteTitle = managed && request.title !== void 0;
@@ -7868,17 +5880,6 @@ function planManagedUpdate(request, derived, live, wipTitles) {
 		previousBody: live.body
 	};
 }
-/**
-* Reconcile the WIP draft marker on a title being preserved, not derived -- forges that mark a
-* draft with a title prefix only (`wipTitles`). Elsewhere draft is a flag the host adapter already
-* handles, and this must not duplicate that, so the title comes back untouched.
-*
-* `draft === true` and `liveTitle` carries no recognized marker prepends `WIP: `; `draft === false`
-* and it does strips it ({@link stripWipPrefix}, the same definition the adder is built against);
-* `draft === undefined` leaves the title alone. A strip that would leave an empty title returns
-* `liveTitle` unchanged and warns instead of PATCHing a blank one -- the same refusal the un-draft
-* makes, one severity down, because this is a finalize and not a merge gate.
-*/
 function reconcileWipTitle(wipTitles, draft, liveTitle) {
 	if (!wipTitles || draft === void 0) return liveTitle;
 	if (draft) return hasWipPrefix(liveTitle) ? liveTitle : `WIP: ${liveTitle}`;
@@ -7889,26 +5890,9 @@ function reconcileWipTitle(wipTitles, draft, liveTitle) {
 	}
 	return stripped;
 }
-/**
-* Carry a WIP marker from `live` onto `next` when `next` has none of its own -- so retitling a
-* draft PR leaves it a draft. Normalizes to `WIP: ` rather than reproducing the exact marker
-* (`[WIP]`, `wip:`) it found: {@link hasWipPrefix} accepts every spelling Forgejo does, so the one
-* written back only has to be one of them, and `WIP: ` is the spelling the rest of this module
-* emits. A no-op when the live title is not a draft, or when the caller supplied its own marker.
-*
-* Title-prefix forges only -- callers must gate on `wipTitles` themselves, the same reason
-* {@link reconcileWipTitle} returns `liveTitle` untouched elsewhere: where draft is a flag,
-* preserving a prefix here would silently undo an explicit retitle.
-*/
 function keepWipPrefix(live, next) {
 	return hasWipPrefix(live) && !hasWipPrefix(next) ? `WIP: ${next}` : next;
 }
-/**
-* Thrown by {@link checkClosingLinks} when an update would remove closing references the PR body
-* carried and the caller did not allow it. `lost` holds them in body order; `fromCommits` is check
-* 1's finding from the same call, which the thrown error would otherwise hide from a caller that
-* warns about it. The message names no flag; the caller words the refusal with the way to allow it.
-*/
 var LostClosingRefsError = class extends FatalError {
 	lost;
 	fromCommits;
@@ -7918,44 +5902,6 @@ var LostClosingRefsError = class extends FatalError {
 		this.fromCommits = fromCommits;
 	}
 };
-/**
-* Guard the closing keywords an invocation would lose. Two checks, because a `Closes #<n>` can
-* reach a PR from two places -- and, deliberately, **two different severities**.
-*
-* 1. **The commits close an issue the resulting body does not** -- reported in
-*    {@link ClosingLinkReport.fromCommits}, for the caller to warn about. This one is genuinely
-*    *may*: a commit-carried keyword can still fire once the merge lands the commits on the default
-*    branch (branch-gated on Forgejo; see docs/forge-issue-pr-linking.md). Refusing would reject
-*    invocations whose link is fine. It only ever fires for an explicit body, since a derived body
-*    closes every harvested ref by construction.
-*
-* 2. **The body being REPLACED closed an issue the replacement does not** -- a
-*    {@link LostClosingRefsError}, unless `allowUnlink`. Nothing is uncertain here: the old body
-*    closed it, the new body does not, and if the commits closed it too then check 1's own
-*    extraction would have found it and this list would be empty. The link is simply gone.
-*
-* Check 2 is the one that would have caught the real incident, and a warning is not enough for it
-* -- the entire lesson of that incident is that nothing *reported* the loss and it merged anyway.
-* Two real pull requests lost their `Closes` lines out of a machine-written body; across their 49
-* commits not one carried a closing keyword, so check 1 had nothing to compare against and stayed
-* silent. Both merged, both issues stayed open. A second unread warning would not have changed
-* that outcome; refusing would have.
-*
-* Unlinking is still a legitimate thing to want -- a PR that no longer closes the issue it was
-* split from -- so `allowUnlink` is an opt-in, not a prohibition: the deliberate caller says so,
-* the accidental one cannot do it at all. An allowed unlink comes back as
-* {@link ClosingLinkReport.unlinked}.
-*
-* Check 2 needs the previous body, so it is skipped when `previousBody` is null -- a create, where
-* there is no previous body. Every update reads live when it supplies `managedBodyMarkers` (see
-* {@link planPrUpdate}), so that path has a `previousBody` and cannot fire check 2 by
-* construction rather than by exemption: both the managed row and the preserve row carry forward
-* every closing reference the previous body made that the new one drops (`carryForwardClosingRefs`),
-* so the lost list is empty there before this function ever runs -- a pinned invariant, not an
-* unread body being trusted to already close what it closed. It cannot fire on an update that
-* leaves the body alone either: `effective.body` is then the previous body, and a body always
-* closes whatever it closes.
-*/
 function checkClosingLinks(messages, plan, allowUnlink) {
 	const fromCommits = droppedClosingRefs(messages, plan.effective.body);
 	if (plan.previousBody === null) return {
@@ -7970,16 +5916,6 @@ function checkClosingLinks(messages, plan, allowUnlink) {
 	};
 }
 const ALWAYS_PROTECTED = /* @__PURE__ */ new Set(["main", "master"]);
-/**
-* Push the branch and create or update its pull request, as {@link PrUpsertMode} permits.
-*
-* One function for both create and update because everything up to the existing-PR lookup --
-* protected-branch guard, base resolution, commit reads, content derivation -- is identical, and
-* the two modes differ only in which side of that lookup they accept.
-*
-* A mode refusal is thrown as {@link PrModeError} and a refused unlink as
-* {@link LostClosingRefsError}; the caller words both.
-*/
 async function runPrUpsert(git, host, options) {
 	const { cwd } = options;
 	const mode = options.mode ?? "upsert";
@@ -8053,12 +5989,6 @@ async function runPrUpsert(git, host, options) {
 }
 //#endregion
 //#region ../forgejo/src/pr-upsert-messages.ts
-/**
-* The refusal for a {@link PrModeError}. Both messages name the other command, because being sent
-* here is nearly always a case of reaching for the habitual verb rather than of genuine confusion
-* about the PR's state. The parenthesis names the create command by its last word alone -- the
-* verb, without the program's name.
-*/
 function describePrModeError(error, commands) {
 	if (error.reason === "already-open") {
 		const createVerb = commands.create.split(" ").at(-1) ?? commands.create;
@@ -8066,11 +5996,6 @@ function describePrModeError(error, commands) {
 	}
 	return `${error.branch} has no open PR to update -- use \`${commands.create}\` to open one.`;
 }
-/**
-* The warnings for what `checkClosingLinks` found, one line each, in the order they are shown:
-* the commits' refs the body leaves out, then an allowed unlink. Empty when there is nothing to
-* say.
-*/
 function describeClosingLinks(report, flags) {
 	const lines = [];
 	if (report.fromCommits.length > 0) {
@@ -8083,19 +6008,9 @@ function describeClosingLinks(report, flags) {
 	}
 	return lines;
 }
-/**
-* The refusal for a {@link LostClosingRefsError}. A caller shows the error's `fromCommits` first,
-* through {@link describeClosingLinks}, since the thrown error would otherwise hide that finding.
-*/
 function describeLostClosingRefs(error, flags) {
 	return `Refusing to update: this would remove ${error.lost.map((dropped) => dropped.text).join(", ")} from the PR body, and the new body does not close it -- the issue would stay open when the PR merges, and nothing else reports that. Keep the line in the body you are passing, or pass ${flags.allowUnlink} if the PR really should stop closing it.`;
 }
-/**
-* The error a program throws in place of one `runPrUpsert` threw: a {@link PrModeError} or a
-* {@link LostClosingRefsError} becomes a `FatalError` in the program's own words, and anything else
-* comes back unchanged. For a lost-refs refusal the commits' refs are warned first, through `warn`,
-* because the thrown error would otherwise hide that finding.
-*/
 function rewordPrUpsertError(error, options) {
 	if (error instanceof PrModeError) return new FatalError(describePrModeError(error, options.commands));
 	if (error instanceof LostClosingRefsError) {
@@ -8117,7 +6032,6 @@ function prLabel(result) {
 function isDryRun(result) {
 	return result.action === "would-create" || result.action === "would-update";
 }
-/** The summary of a create, which an upsert may have turned into an update. */
 function formatPrCreate(result) {
 	const opening = result.action === "created" || result.action === "would-create";
 	if (isDryRun(result)) {
@@ -8137,11 +6051,6 @@ function formatPrCreate(result) {
 		body: null
 	};
 }
-/**
-* The summary of an update. `rewrites` says whether the caller passed a new title or body; without
-* one the PR's text is left as authored, and the summary says so and names the options that would
-* change it.
-*/
 function formatPrUpdate(result, rewrites, flags) {
 	if (isDryRun(result)) return {
 		lines: [`[dry-run] Would push ${prTarget(result)} to ${prLabel(result)}`],
@@ -8160,10 +6069,6 @@ function formatPrUpdate(result, rewrites, flags) {
 }
 //#endregion
 //#region ../forgejo/src/pr-host.ts
-/**
-* The Forgejo {@link PrHost}, over the API calls in `pr.ts`. Its content read, create and update
-* take no abort signal, as those calls never have.
-*/
 function forgejoPrHost(fetcher, conn) {
 	return {
 		wipTitles: true,
@@ -8187,11 +6092,6 @@ function forgejoPrHost(fetcher, conn) {
 		}
 	};
 }
-/**
-* The Forgejo {@link PrEditHost}, over the API calls in `pr.ts` and `repo.ts`. Its `ready` is a
-* title-only PATCH and never a body write: the body is the author's text, and the draft flag has
-* no PATCH field of its own on this forge.
-*/
 function forgejoPrEditHost(fetcher, conn) {
 	return {
 		wipTitles: true,
@@ -8203,14 +6103,8 @@ function forgejoPrEditHost(fetcher, conn) {
 }
 //#endregion
 //#region src/git.ts
-/** Exit codes reported when this module ends a child itself, following the shell's convention. */
 const TIMED_OUT_EXIT_CODE = 124;
 const ABORTED_EXIT_CODE = 143;
-/**
-* The one place a command runs git. Commands reach git only through this function, so a test
-* mocks this module and no other. A nonzero exit is a result, never a throw: the caller decides
-* what a failed `push` or a missing ref means. `env` adds to the inherited environment.
-*/
 function cliGit() {
 	return { run: (args, { cwd, env, timeoutMs, signal }) => new Promise((resolve, reject) => {
 		if (signal?.aborted === true) {
@@ -8297,11 +6191,6 @@ const FLAGS = {
 function warnClosingLinks(report) {
 	for (const line of describeClosingLinks(report, FLAGS)) rootLogger.warn(line);
 }
-/**
-* The part of `pr:create` and `pr:update` that is the same: refuse a GitHub remote, run the shared
-* upsert over this CLI's git and fetch seams, and reword its refusals and closing-link findings
-* with `bst-fj`'s own command and flag names.
-*/
 async function runForgejoPr(githubRefusal, options) {
 	const cwd = process.cwd();
 	const conn = requireForgejoTarget(cwd, void 0, githubRefusal);
@@ -8396,22 +6285,13 @@ const prCreateCommand = defineCommand({
 });
 //#endregion
 //#region ../forgejo/src/pr-files.ts
-/**
-* A pull request's changed-files listing. Its own module, because `pr.ts` is at its fan-in
-* ceiling and this read is about a diff, not a pull request's state.
-*/
 const DEFAULT_LIMIT = 100;
 const PrFileEntrySchema = z.object({
 	filename: z.string(),
-	/** Forgejo's swagger does not enumerate this, so it stays an open string. */
 	status: z.string().nullish(),
 	additions: z.number().default(0),
 	deletions: z.number().default(0)
 });
-/**
-* One page of the files a pull request changed, never a walk: a caller on a page load must not
-* turn a navigation into an unbounded forge loop, and `truncated` says when more exist.
-*/
 async function listPrFiles(executor, conn, prNumber, options) {
 	return readPrFilesPage(executor, conn, prNumber, 1, options?.limit ?? DEFAULT_LIMIT);
 }
@@ -8436,10 +6316,6 @@ async function readPrFilesPage(executor, conn, prNumber, page, limit) {
 }
 //#endregion
 //#region ../forgejo/src/pr-number.ts
-/**
-* The one parser for a pull request number given as text, shared by every bin's positional so a
-* malformed number refuses the same way whether a person or a script typed it.
-*/
 function parsePrNumber(raw) {
 	const value = Number(raw);
 	if (!/^\d+$/.test(raw) || !Number.isSafeInteger(value) || value < 1) throw new FatalError(`Invalid pull request number "${raw}" (expected a positive integer).`);
@@ -8447,16 +6323,10 @@ function parsePrNumber(raw) {
 }
 //#endregion
 //#region src/pr-files.ts
-/**
-* `bst-fj pr:files`: the files a pull request changes, over `@bensandee/forgejo/pr-files`.
-* Forgejo-only; `gh pr diff --name-only` already serves GitHub.
-*/
-/** List the files a pull request changes. */
 function runPrFiles(fetcher, options) {
 	const number = parsePrNumber(options.number);
 	return listPrFiles(fetcher, requireForgejoTarget(options.cwd, parseRepoTarget(options.repo), "pr:files is Forgejo-only -- gh pr diff --name-only already serves GitHub."), number);
 }
-/** Human-readable rendering: `status filename` per file, then a note when more files exist. */
 function renderPrFiles(listing) {
 	const lines = listing.files.map((file) => `${file.status ?? "unknown"} ${file.filename}`);
 	if (lines.length === 0) lines.push("No changed files.");
@@ -8505,12 +6375,6 @@ const prFilesCommand = defineCommand({
 });
 //#endregion
 //#region src/pr-list.ts
-/**
-* `bst-fj pr:list` -- a read-only, Forgejo-only pull request listing over the shared `listPulls`
-* pager (`@bensandee/forgejo/pr`), so a duplicate-work check needs no raw API call. GitHub-only
-* PR listing already has a first-class tool (`gh pr list`), the same precedent `pr:checks`
-* follows for the same structural reason.
-*/
 function parseState(state) {
 	if (state === "open" || state === "closed" || state === "all") return state;
 	throw new FatalError(`Invalid --state "${state}" (expected open, closed, or all).`);
@@ -8520,10 +6384,6 @@ function parseLimit(raw) {
 	if (!Number.isInteger(limit) || limit < 1) throw new FatalError(`Invalid --limit "${raw}" (expected a positive integer).`);
 	return limit;
 }
-/**
-* List a repository's pull requests, most recently updated first, sliced to `--limit`. Refuses a
-* github.com target before any fetch -- `gh pr list` already serves GitHub, first-class.
-*/
 async function runPrList(fetcher, options) {
 	const state = parseState(options.state);
 	const limit = parseLimit(options.limit);
@@ -8547,7 +6407,6 @@ function statusLabel(pr) {
 	if (pr.draft === true) return `${pr.state}/draft`;
 	return pr.state;
 }
-/** Human-readable rendering: one line per PR, most recently updated first. */
 function renderPrList(result) {
 	if (result.pulls.length === 0) return "No pull requests.";
 	return result.pulls.map((pr) => {
@@ -8603,16 +6462,6 @@ const prListCommand = defineCommand({
 });
 //#endregion
 //#region ../forgejo/src/pr-merge.ts
-/**
-* The one irreversible write a merge makes, and the two live reads that arm it. Split
-* out of `pr.ts` on cohesion rather than fan-in: a merge, the check that the PR is actually
-* mergeable, and the check that its head SHA is actually green are one concern, and one home for
-* them beats a caller reaching two files for a decision it must make atomically.
-*
-* `readMergeGate`'s live `open`/`draft`/`mergeable` read exists so a merge re-reads the forge
-* rather than trusting a label or a cached view it is about to act on.
-*/
-/** Merge a pull request by number. */
 async function mergePr(executor, conn, prNumber, options) {
 	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/pulls/${String(prNumber)}/merge`;
 	const body = {
@@ -8644,12 +6493,6 @@ const MergeGateSchema = z.object({
 	labels: z.array(z.object({ name: z.string() })).nullable(),
 	updated_at: z.string().nullish()
 });
-/**
-* Read a PR's live open/draft/mergeable state and current head SHA in one `/pulls/<n>` GET --
-* the gate's label-independent half. It confirms nothing has changed since an earlier judgment
-* that the PR was ready, including an ordinary push to the branch, which moves the head SHA the
-* status read below has to be scoped to.
-*/
 async function readMergeGate(executor, conn, prNumber) {
 	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/pulls/${String(prNumber)}`;
 	const res = await executor.fetch(url, { headers: { Authorization: `token ${conn.token}` } });
@@ -8671,15 +6514,6 @@ async function readMergeGate(executor, conn, prNumber) {
 		updatedAt: parsed.data.updated_at ?? null
 	};
 }
-/**
-* Read a PR's merge gate and, when mergeability is not yet confirmed, read it once more.
-*
-* Forgejo reports `mergeable: false` for a real conflict and for its own check still running, so a
-* lone `false` (or a null, which {@link readMergeGate} folds to `false`) proves nothing. A first
-* `true` is final. Otherwise the function waits `delayMs` and reads again: a second `false` at the
-* same head and merge base is `conflicted`; a moved head or merge base means the two reads saw two
-* different trees, so the result is `unconfirmed`.
-*/
 async function confirmMergeable(executor, conn, prNumber, options) {
 	const firstGate = await readMergeGate(executor, conn, prNumber);
 	if (firstGate.mergeable) return {
@@ -8732,18 +6566,11 @@ z.object({
 });
 //#endregion
 //#region src/pr-merge.ts
-/**
-* `bst-fj pr:merge`: merge a pull request, but only one a person would not want to look at first.
-* Every refusal happens before the merge request, and the merge is pinned to the head SHA the
-* confirming read saw, so a push that lands between the read and the merge makes the forge
-* refuse it rather than merge a tree nobody checked. Forgejo's branch protection still applies.
-*/
 const METHODS = [
 	"merge",
 	"rebase",
 	"squash"
 ];
-/** Long enough for Forgejo to finish its own mergeability check after a first `false`. */
 const RECHECK_DELAY_MS = 2e3;
 function parseMethod(raw) {
 	if (raw === void 0) return "merge";
@@ -8751,8 +6578,6 @@ function parseMethod(raw) {
 	if (method === void 0) throw new FatalError(`Invalid --method "${raw}" (expected one of: ${METHODS.join(", ")}).`);
 	return method;
 }
-/** Confirm, check, and (unless `dryRun`) merge. Throws a `FatalError` naming the reason for every
-* refusal, before any merge request. */
 async function runPrMerge(fetcher, options) {
 	const number = parsePrNumber(options.number);
 	const method = parseMethod(options.method);
@@ -8789,7 +6614,6 @@ async function runPrMerge(fetcher, options) {
 		merged: true
 	};
 }
-/** Human-readable rendering: one line saying what was merged, or what a dry run would merge. */
 function renderPrMerge(result) {
 	const what = `PR #${String(result.number)} (${result.method}) at ${result.headSha.slice(0, 12)}, checks ${result.checks}`;
 	return result.merged ? `Merged ${what}.` : `Dry run: would merge ${what}.`;
@@ -8853,19 +6677,7 @@ const prMergeCommand = defineCommand({
 });
 //#endregion
 //#region ../forgejo/src/pr-edit.ts
-/**
-* The two pull-request editing engines, forge-generic: what a base change and a ready write check,
-* send, and confirm. Each one drives a {@link PrEditHost}, so the sequence is written once and only
-* the writes differ per forge -- the refusals and the confirming re-read are the parts a person
-* relies on, and they must not be re-derived on each side of the seam.
-*
-* Engines and renderers share this module because every importer of either is the same command: a
-* renderer kept apart would be a second module for the same four callers.
-*/
-/** The wait before the one mergeability re-read after a retarget; both bins pass it. */
 const MERGEABLE_RECHECK_DELAY_MS = 2e3;
-/** What both forges call an editable pull request. One predicate, so the two engines cannot
-* disagree about it and a caller cannot read "open" as its own looser thing. */
 function isOpen(live) {
 	return live.state === "open" && live.merged === false;
 }
@@ -8873,16 +6685,6 @@ function notOpenMessage(prNumber, live) {
 	const what = live.merged ? "merged" : live.state;
 	return `Pull request #${String(prNumber)} is ${what}, so it has no base or draft state left to change. Reopen it first if this work is still live.`;
 }
-/**
-* Point an open pull request at a new base branch, then prove the forge took it.
-*
-* The re-read is the whole point of the command: a forge that does not implement the base field
-* answers the PATCH with 200 and changes nothing, so a report built from the request would claim a
-* move that never happened. `mergeable` rides along as advice only and never decides the outcome --
-* it is tri-state on both forges and a pull request whose base just moved is being recomputed by
-* definition -- so a `false` earns exactly one more read after a wait, and `null` and `true` are
-* taken as final.
-*/
 async function runPrRetarget(host, options) {
 	const live = await host.readLive(options.number);
 	if (!isOpen(live)) throw new FatalError(notOpenMessage(options.number, live));
@@ -8927,17 +6729,6 @@ async function runPrRetarget(host, options) {
 		dryRun: false
 	};
 }
-/**
-* Mark an open pull request ready, dropping its WIP marker or writing the title given.
-*
-* The draft is the forge's flag, never the title prefix: a prefix is how a title reads and a draft
-* is what the forge refuses to merge, and the two disagree on both forges. So the title is the
-* mechanism (it is the only lever Forgejo's PATCH has) and the flag is the question of whether
-* there is anything to do -- which is also why a successful write is re-read rather than trusted.
-* A draft whose title carries no marker this side recognises is refused rather than readied by
-* guessing at one: on that forge only the title can clear the flag, and an invented title is a
-* rewrite of someone's headline.
-*/
 async function runPrReady(host, options) {
 	const live = await host.readLive(options.number);
 	if (!isOpen(live)) throw new FatalError(notOpenMessage(options.number, live));
@@ -8995,7 +6786,6 @@ function mergeabilityLine(mergeable) {
 	if (mergeable === false) return "Mergeability: not mergeable -- advice, not a verdict.";
 	return "Mergeability: unknown -- the forge has not computed it.";
 }
-/** What happened to the base, and the mergeability reading as advice. */
 function renderPrRetarget(result) {
 	const number = `#${String(result.number)}`;
 	const lines = [];
@@ -9005,7 +6795,6 @@ function renderPrRetarget(result) {
 	lines.push(mergeabilityLine(result.mergeable));
 	return lines.join("\n");
 }
-/** What happened to the draft state and the title. */
 function renderPrReady(result) {
 	const number = `#${String(result.number)}`;
 	if (result.action === "readied") return `Pull request ${number} is no longer a draft, reading as "${result.title}".`;