@open-tomato/rafa 0.45.0 → 0.46.0

package/dist/index-j4k2vdz3.js

@@ -0,0 +1,1125 @@
+// @bun
+import {
+  CORE_SECTION,
+  activeSettings,
+  registerConfigSections,
+  setConfigLoadHook
+} from "./index-gvek4r8m.js";
+import {
+  PR_PROVIDERS,
+  RELEASE_AUTO,
+  below,
+  describeValue,
+  flag,
+  fragmentsDirectory,
+  isMapping,
+  listOf,
+  mapOf,
+  oneOf,
+  refused,
+  refusedWith,
+  releaseEnabled,
+  releaseFile,
+  releasePublishMode,
+  releaseSettleMode,
+  releaseStrategy,
+  releaseTagMode,
+  text,
+  usdAmount,
+  versionCollisionMode
+} from "./index-ykggr043.js";
+
+// src/adapters/logger/settings.ts
+import { AsyncLocalStorage } from "async_hooks";
+var LOG_LEVELS = Object.freeze(["error", "warn", "debug"]);
+var LOGGER_THEMES = Object.freeze(["default", "plain"]);
+var DEFAULT_LOGGER_KIND = "console";
+var DEBUG_VERBOSITY = 2;
+var API_VERBOSITY = 3;
+var DEFAULT_LOGGER_SETTINGS = Object.freeze({
+  kind: DEFAULT_LOGGER_KIND,
+  level: "warn",
+  theme: "default",
+  modules: new Map,
+  callSite: false,
+  api: false
+});
+var scopes = new AsyncLocalStorage;
+var moduleLevel = { settings: DEFAULT_LOGGER_SETTINGS };
+function settingsOf(settings) {
+  return settings === null ? DEFAULT_LOGGER_SETTINGS : Object.freeze({ ...settings, modules: new Map(settings.modules) });
+}
+function cellHere() {
+  return scopes.getStore() ?? moduleLevel;
+}
+function setActiveLoggerSettings(settings) {
+  cellHere().settings = settingsOf(settings);
+}
+function activeLoggerSettings() {
+  return cellHere().settings;
+}
+function levelEnabled(level, module, settings, verbosity) {
+  if (level === "api")
+    return settings.api || verbosity >= API_VERBOSITY;
+  if (level === "debug" && verbosity >= DEBUG_VERBOSITY)
+    return true;
+  const threshold = (module === undefined ? undefined : settings.modules.get(module)) ?? settings.level;
+  return LOG_LEVELS.indexOf(level) <= LOG_LEVELS.indexOf(threshold);
+}
+
+// src/config-schema-board-project.ts
+var BOARD_PROJECT_RETRIES_MIN = 1;
+var BOARD_PROJECT_RETRIES_MAX = 10;
+var BOARD_PROJECT_RETRY_WAIT_MIN_SECONDS = 1;
+var BOARD_PROJECT_RETRY_WAIT_MAX_SECONDS = 60;
+var BOARD_PROJECT_PROGRESS_MIN_SECONDS = 1;
+var BOARD_PROJECT_PROGRESS_MAX_SECONDS = 300;
+var BOARD_PROJECT_WRITE_BATCH_MIN = 1;
+var BOARD_PROJECT_WRITE_BATCH_MAX = 100;
+var BOARD_PROJECT_WRITE_PAUSE_MIN_MS = 0;
+var BOARD_PROJECT_WRITE_PAUSE_MAX_MS = 60000;
+function isWholeBetween(raw, min, max) {
+  return typeof raw === "number" && Number.isSafeInteger(raw) && raw >= min && raw <= max;
+}
+function rangeWords(min, max) {
+  return `a whole number from ${String(min)} to ${String(max)}`;
+}
+function wholeBetween(min, max) {
+  return (raw, at) => isWholeBetween(raw, min, max) ? { value: raw, problems: [], extras: [] } : refused(at, raw, rangeWords(min, max));
+}
+function offOrWholeBetween(min, max) {
+  return (raw, at) => raw === false || isWholeBetween(raw, min, max) ? { value: raw, problems: [], extras: [] } : refused(at, raw, `false or ${rangeWords(min, max)}`);
+}
+var boardProjectRetries = offOrWholeBetween(BOARD_PROJECT_RETRIES_MIN, BOARD_PROJECT_RETRIES_MAX);
+var boardProjectRetryWaitSeconds = wholeBetween(BOARD_PROJECT_RETRY_WAIT_MIN_SECONDS, BOARD_PROJECT_RETRY_WAIT_MAX_SECONDS);
+var boardProjectProgressSeconds = offOrWholeBetween(BOARD_PROJECT_PROGRESS_MIN_SECONDS, BOARD_PROJECT_PROGRESS_MAX_SECONDS);
+var boardProjectWriteBatchSize = wholeBetween(BOARD_PROJECT_WRITE_BATCH_MIN, BOARD_PROJECT_WRITE_BATCH_MAX);
+var boardProjectWritePauseMs = wholeBetween(BOARD_PROJECT_WRITE_PAUSE_MIN_MS, BOARD_PROJECT_WRITE_PAUSE_MAX_MS);
+var BOARD_PROJECT_LIMIT_DEFAULTS = Object.freeze({
+  boardProjectRetries: 3,
+  boardProjectRetryWaitSeconds: 2,
+  boardProjectProgressSeconds: 10,
+  boardProjectWriteBatchSize: 20,
+  boardProjectWritePauseMs: 1000
+});
+var BOARD_PROJECT_LIMIT_SETTINGS = {
+  boardProjectRetries: { key: "board.project.retries", read: boardProjectRetries, cli: false },
+  boardProjectRetryWaitSeconds: {
+    key: "board.project.retryWaitSeconds",
+    read: boardProjectRetryWaitSeconds,
+    cli: false
+  },
+  boardProjectProgressSeconds: {
+    key: "board.project.progressSeconds",
+    read: boardProjectProgressSeconds,
+    cli: false
+  },
+  boardProjectWriteBatchSize: {
+    key: "board.project.writeBatchSize",
+    read: boardProjectWriteBatchSize,
+    cli: false
+  },
+  boardProjectWritePauseMs: {
+    key: "board.project.writePauseMs",
+    read: boardProjectWritePauseMs,
+    cli: false
+  }
+};
+var BOARD_PROJECT_SECTION = Object.freeze({
+  package: "board-project",
+  settings: Object.freeze(BOARD_PROJECT_LIMIT_SETTINGS),
+  defaults: BOARD_PROJECT_LIMIT_DEFAULTS
+});
+
+// src/config-schema-bugs.ts
+var BUGS_RECHECK_RUNS_MIN = 1;
+var BUGS_RECHECK_RUNS_MAX = 20;
+var BUGS_RECHECK_TIMEOUT_MIN = 1;
+var BUGS_RECHECK_TIMEOUT_MAX = 3600;
+function wholeNumberIn(min, max) {
+  return (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw >= min && raw <= max ? { value: raw, problems: [], extras: [] } : refused(at, raw, `a whole number from ${String(min)} to ${String(max)}`);
+}
+var bugsRecheckRuns = wholeNumberIn(BUGS_RECHECK_RUNS_MIN, BUGS_RECHECK_RUNS_MAX);
+var bugsRecheckTimeoutSeconds = wholeNumberIn(BUGS_RECHECK_TIMEOUT_MIN, BUGS_RECHECK_TIMEOUT_MAX);
+var BUGS_DEFAULTS = Object.freeze({
+  bugsRecheckRuns: 5,
+  bugsRecheckTimeoutSeconds: 300
+});
+var BUGS_SETTINGS = {
+  bugsRecheckRuns: { key: "bugs.recheck.runs", read: bugsRecheckRuns, cli: false },
+  bugsRecheckTimeoutSeconds: { key: "bugs.recheck.timeoutSeconds", read: bugsRecheckTimeoutSeconds, cli: false }
+};
+var BUGS_SECTION = Object.freeze({
+  package: "bugs",
+  settings: Object.freeze(BUGS_SETTINGS),
+  defaults: BUGS_DEFAULTS
+});
+
+// packages/rafa/src/errors/codes.ts
+var ERROR_LEVELS = Object.freeze(["error", "warn"]);
+var CODE_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*:[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var NEW_CONTEXT_LEAF = "new-context";
+var UNKNOWN_FAMILY = "unknown";
+var TEXT_FIELDS = ["description", "hint", "since"];
+var PREFIX = "error codes";
+function familyOf(code) {
+  return code.slice(0, code.indexOf(":"));
+}
+function codeProblem(code) {
+  if (!CODE_PATTERN.test(code))
+    return `${JSON.stringify(code)} is not <family>:<leaf> in kebab-case`;
+  const leaf = code.slice(code.indexOf(":") + 1);
+  if (leaf === NEW_CONTEXT_LEAF || leaf === UNKNOWN_FAMILY) {
+    return `${JSON.stringify(code)} uses the reserved leaf ${leaf}`;
+  }
+  if (familyOf(code) === UNKNOWN_FAMILY)
+    return `${JSON.stringify(code)} uses the reserved family ${UNKNOWN_FAMILY}`;
+  return null;
+}
+function entryProblem(entry, index) {
+  const codeFault = codeProblem(entry.code);
+  if (codeFault !== null)
+    return `[${index}].code ${codeFault}`;
+  const empty = TEXT_FIELDS.find((field) => (entry[field] ?? "").trim() === "");
+  if (empty !== undefined)
+    return `[${index}].${empty} is empty`;
+  if (!ERROR_LEVELS.includes(entry.level)) {
+    return `[${index}].level is ${JSON.stringify(entry.level)}, expected ${ERROR_LEVELS.join(" or ")}`;
+  }
+  return null;
+}
+function defineErrorCodes(entries) {
+  entries.forEach((entry, index) => {
+    const fault = entryProblem(entry, index);
+    if (fault !== null)
+      throw new TypeError(`${PREFIX}: ${fault}`);
+    const first = entries.findIndex((other) => other.code === entry.code);
+    if (first < index) {
+      throw new TypeError(`${PREFIX}: ${JSON.stringify(entry.code)} is declared at [${first}] and [${index}]`);
+    }
+  });
+  return Object.freeze(entries.map((entry) => Object.freeze({ ...entry })));
+}
+function isKnownCode(code, entries) {
+  if (code === `${UNKNOWN_FAMILY}:${NEW_CONTEXT_LEAF}`)
+    return true;
+  if (entries.some((entry) => entry.code === code))
+    return true;
+  return code === `${familyOf(code)}:${NEW_CONTEXT_LEAF}` && entries.some((entry) => familyOf(entry.code) === familyOf(code));
+}
+
+// packages/rafa/src/errors/rafa-codes.ts
+var SEED = "#949";
+var FAMILY_DESCRIPTIONS = Object.freeze({
+  api: "a call to a remote service",
+  cli: "routing a command line and running the command",
+  config: "reading the project or user config",
+  fs: "reading or writing files",
+  git: "running git",
+  input: "a value given on the command line or in a file",
+  skill: "a skill file's frontmatter",
+  spawn: "starting a child process",
+  tracker: "the issue tracker",
+  tsc: "type-checking"
+});
+var RAFA_CODES = defineErrorCodes([
+  { code: "cli:unknown-subject", description: "the first word names no subject", hint: "run rafa --help for the subjects", level: "error", since: SEED, legacy: "unknown_subject" },
+  { code: "cli:missing-action", description: "a subject is named with no action after it", hint: "run rafa <subject> --help for its actions", level: "error", since: SEED, legacy: "missing_action" },
+  { code: "cli:unknown-action", description: "the action names nothing the subject holds", hint: "run rafa <subject> --help for its actions", level: "error", since: SEED, legacy: "unknown_action" },
+  { code: "cli:unknown-module", description: "a module command names a module that is not mounted", hint: "run rafa module list for the modules that are mounted", level: "error", since: SEED, legacy: "unknown_module" },
+  { code: "cli:unexpected-version", description: "--version is typed beside a command, where it is read alone", hint: "run rafa --version alone, with no command beside it", level: "error", since: SEED, legacy: "unexpected_version" },
+  { code: "cli:invalid-spec", description: "a command declares a shape the dispatcher refuses", hint: "fix the command declaration the message names", level: "error", since: SEED, legacy: "invalid_spec" },
+  { code: "cli:no-project", description: "a command that needs a project ran outside one", hint: "run it inside a project, or run rafa init", level: "error", since: SEED, legacy: "no_project" },
+  { code: "cli:command-exit", description: "a command refused and set its own exit code", hint: "read the message above it", level: "error", since: SEED, legacy: "command_exit" },
+  { code: "cli:command-error", description: "a command threw an error it did not handle", hint: "file a bug with the stack", level: "error", since: SEED, legacy: "command_error" },
+  { code: "cli:result-unwritable", description: "the command result cannot be written, as with data JSON refuses", hint: "file a bug: the command answered data that cannot be written as JSON", level: "error", since: SEED, legacy: "result_unwritable" },
+  { code: "skill:missing-field", description: "a required frontmatter field is absent or empty", hint: "add the field the message names", level: "error", since: SEED, legacy: "missing-field" },
+  { code: "skill:wrong-type", description: "a frontmatter field has a type the schema cannot read", hint: "write the field as the schema expects", level: "error", since: SEED, legacy: "wrong-type" },
+  { code: "skill:invalid-name", description: "a skill name is not kebab-case", hint: "rename the skill in kebab-case", level: "error", since: SEED, legacy: "invalid-name" },
+  { code: "skill:description-too-long", description: "the description is at or past its limit", hint: "shorten the description", level: "error", since: SEED, legacy: "description-too-long" },
+  { code: "skill:listing-too-long", description: "description and when_to_use together pass the listing limit", hint: "shorten when_to_use", level: "error", since: SEED, legacy: "listing-too-long" },
+  { code: "skill:unknown-stack", description: "a stack entry is outside the vocabulary", hint: "use a stack the schema lists", level: "error", since: SEED, legacy: "unknown-stack" },
+  { code: "skill:unpaired-prevents", description: "prevents is set without signal, or signal without prevents", hint: "set both or neither", level: "error", since: SEED, legacy: "unpaired-prevents" },
+  { code: "skill:unknown-signal", description: "signal holds a value the schema does not list", hint: "use a listed signal", level: "error", since: SEED, legacy: "unknown-signal" },
+  { code: "skill:unusable-glob", description: "a paths glob gates on nothing it seems to gate on", hint: "rewrite the glob", level: "error", since: SEED, legacy: "unusable-glob" },
+  { code: "skill:forbidden-field", description: "an instinct field appears on a skill", hint: "remove the field", level: "error", since: SEED, legacy: "forbidden-field" },
+  { code: "skill:unknown-provenance", description: "provenance names neither first-party nor a known mapping", hint: "use first-party or a known mapping", level: "error", since: SEED, legacy: "unknown-provenance" },
+  { code: "skill:invalid-reviewed", description: "provenance.reviewed is not who and a date", hint: "write <who> <YYYY-MM-DD>", level: "error", since: SEED, legacy: "invalid-reviewed" },
+  { code: "skill:empty-failure-string", description: "a failure_strings entry is blank", hint: "remove the blank entry", level: "error", since: SEED, legacy: "empty-failure-string" },
+  { code: "skill:short-failure-string", description: "a failure_strings entry is too short to name one failure", hint: "lengthen the entry", level: "warn", since: SEED, legacy: "short-failure-string" },
+  { code: "git:no-identity", description: "a git commit runs with no author identity set, often in a scratch home", hint: "set user.name and user.email where the commit runs", level: "error", since: SEED },
+  { code: "git:filesystem-boundary", description: "git prints an extra line when run outside a repository", hint: "run inside a repository, or read only the first line", level: "warn", since: SEED },
+  { code: "tsc:tests-excluded", description: "type errors in test files stay hidden because tsc excludes tests", hint: "type-check the test files", level: "error", since: SEED },
+  { code: "fs:gitignored-fixture", description: "a test reads a gitignored file a fresh checkout lacks", hint: "plant the file in the test, never read the live one", level: "error", since: SEED },
+  { code: "fs:live-home", description: "a test reads the live home directory instead of a planted one", hint: "point HOME at a scratch folder in the test", level: "error", since: SEED },
+  { code: "fs:not-found", description: "a file or folder the step needs is missing", hint: "create it, or fix the path", level: "error", since: SEED },
+  { code: "input:missing-param", description: "a required value was not given", hint: "pass the value the message names", level: "error", since: SEED },
+  { code: "input:invalid-value", description: "a given value is outside what the step accepts", hint: "pass one of the values the message lists", level: "error", since: SEED },
+  { code: "api:http-status", description: "a remote service answered with an error status", hint: "read the status, then retry or fix the request", level: "error", since: SEED },
+  { code: "config:invalid-value", description: "a config key holds a value its reader refuses", hint: "fix the key the message names", level: "error", since: SEED },
+  { code: "tracker:unreachable", description: "the issue tracker could not be reached", hint: "check the network and gh auth status", level: "error", since: SEED },
+  { code: "tracker:unavailable", description: "a tracker kind could not be made or failed its preflight, and the chain passed it over", hint: "read the reason given, or leave the fallback tracker in use", level: "warn", since: "#950" },
+  { code: "spawn:nonzero-exit", description: "a child process exited nonzero", hint: "read the child's stderr above", level: "error", since: SEED }
+]);
+function listedCodes(projectCodes) {
+  return Object.freeze([
+    ...RAFA_CODES.map((entry) => Object.freeze({ ...entry, source: "rafa" })),
+    ...projectCodes.map((entry) => Object.freeze({ ...entry, source: "project" }))
+  ]);
+}
+
+// src/config-schema-errors.ts
+var ERROR_CODE_KEYS = ["code", "description", "hint", "level", "since"];
+var KNOWN_KEYS = new Set(ERROR_CODE_KEYS);
+var ERRORS_DEFAULTS = Object.freeze({ errorsCodes: Object.freeze([]) });
+var codeText = (raw, at) => {
+  const read = text("a code, <family>:<leaf>")(raw, at);
+  if (read.value === undefined)
+    return read;
+  const fault = codeProblem(read.value);
+  return fault === null ? read : refused(at, raw, `a code: ${fault}`);
+};
+var EXPECTED = {
+  description: "a one-line description, a non-empty string",
+  hint: "the next action, a non-empty string",
+  since: "the version or issue that added it, a non-empty string"
+};
+var NO_SINCE = { value: undefined, problems: [], extras: [] };
+var errorCodeEntry = (raw, at) => {
+  if (!isMapping(raw))
+    return refused(at, raw, `a mapping of: ${ERROR_CODE_KEYS.join(", ")}`);
+  const code = codeText(raw.code, below(at, ".code"));
+  const description = text(EXPECTED.description)(raw.description, below(at, ".description"));
+  const hint = text(EXPECTED.hint)(raw.hint, below(at, ".hint"));
+  const level = oneOf(ERROR_LEVELS)(raw.level, below(at, ".level"));
+  const since = raw.since === undefined || raw.since === null ? NO_SINCE : text(EXPECTED.since)(raw.since, below(at, ".since"));
+  const problems = [code, description, hint, level, since].flatMap((reading) => reading.problems);
+  const extras = Object.entries(raw).filter(([key]) => !KNOWN_KEYS.has(key)).map(([key, value]) => ({ key: `${at.key}.${key}`, value }));
+  if (code.value === undefined || description.value === undefined || hint.value === undefined || level.value === undefined || problems.length > 0)
+    return { value: undefined, problems, extras };
+  const entry = {
+    code: code.value,
+    description: description.value,
+    hint: hint.value,
+    level: level.value,
+    ...since.value === undefined ? {} : { since: since.value }
+  };
+  return { value: Object.freeze(entry), problems: [], extras };
+};
+var errorCodes = (raw, at) => {
+  const read = listOf(errorCodeEntry, "error code entries")(raw, at);
+  const entries = read.value;
+  if (entries === undefined)
+    return read;
+  const problems = entries.flatMap((entry, index) => {
+    const label = `${below(at, `[${index}]`).label}.code is ${JSON.stringify(entry.code)}`;
+    if (RAFA_CODES.some((own) => own.code === entry.code)) {
+      return [`${label}, which rafa already declares; add a leaf of your own instead`];
+    }
+    const first = entries.findIndex((other) => other.code === entry.code);
+    return first < index ? [`${label}, already given at [${first}]`] : [];
+  });
+  return problems.length === 0 ? read : { ...refusedWith(problems), extras: read.extras };
+};
+var ERRORS_SETTINGS = {
+  errorsCodes: { key: "errors.codes", read: errorCodes, cli: false, itemKeys: ERROR_CODE_KEYS }
+};
+var ERRORS_SECTION = Object.freeze({
+  package: "errors",
+  settings: Object.freeze(ERRORS_SETTINGS),
+  defaults: ERRORS_DEFAULTS
+});
+
+// src/config-schema-features.ts
+var FEATURES_DEFAULTS = Object.freeze({
+  featuresBoard: true,
+  featuresPr: true,
+  featuresRun: true,
+  featuresRelease: true
+});
+var FEATURES_SETTINGS = {
+  featuresBoard: { key: "features.board", read: flag, cli: false },
+  featuresPr: { key: "features.pr", read: flag, cli: false },
+  featuresRun: { key: "features.run", read: flag, cli: false },
+  featuresRelease: { key: "features.release", read: flag, cli: false }
+};
+var FEATURES_SECTION = Object.freeze({
+  package: "features",
+  settings: Object.freeze(FEATURES_SETTINGS),
+  defaults: FEATURES_DEFAULTS
+});
+
+// src/config-schema-hub.ts
+var HUB_TIMEOUT_MIN_SECONDS = 1;
+var HUB_TIMEOUT_MAX_SECONDS = 30;
+var MS_PER_SECOND = 1000;
+var HUB_TIMEOUT = /^(\d+)s$/;
+var HUB_URL_PROTOCOLS = Object.freeze(["http:", "https:"]);
+var HUB_DEFAULTS = Object.freeze({
+  hubUrl: null,
+  hubTokenSecret: null,
+  hubTimeout: "3s"
+});
+function hubTimeoutMs(raw) {
+  const match = typeof raw === "string" ? HUB_TIMEOUT.exec(raw) : null;
+  if (match === null)
+    return null;
+  const seconds = Number(match[1]);
+  return seconds >= HUB_TIMEOUT_MIN_SECONDS && seconds <= HUB_TIMEOUT_MAX_SECONDS ? seconds * MS_PER_SECOND : null;
+}
+var hubTimeout = (raw, at) => hubTimeoutMs(raw) === null ? refused(at, raw, `a duration of whole seconds from ${String(HUB_TIMEOUT_MIN_SECONDS)}s to ${String(HUB_TIMEOUT_MAX_SECONDS)}s, such as 3s`) : { value: raw, problems: [], extras: [] };
+function isHubUrl(raw) {
+  if (typeof raw !== "string" || raw.trim() !== raw)
+    return false;
+  const url = URL.parse(raw);
+  return url !== null && HUB_URL_PROTOCOLS.includes(url.protocol) && url.username === "" && url.password === "";
+}
+var hubUrl = (raw, at) => isHubUrl(raw) ? { value: raw, problems: [], extras: [] } : refused(at, raw, "an http or https URL with no user name or password, such as https://hub.example.org");
+var HUB_SETTINGS = {
+  hubUrl: { key: "hub.url", read: hubUrl, cli: false },
+  hubTokenSecret: { key: "hub.tokenSecret", read: text("a secret store name"), cli: false },
+  hubTimeout: { key: "hub.timeout", read: hubTimeout, cli: false }
+};
+var HUB_STRATEGY = "service";
+function labelOf(input) {
+  const source = input.sources.effortSync;
+  const path = source === "user" ? input.userPath : input.path;
+  return path ?? source;
+}
+function hubUrlProblems(input) {
+  if (input.config.effortSync !== HUB_STRATEGY || input.config.hubUrl !== null)
+    return [];
+  return [
+    `${labelOf(input)}: effort.sync is ${describeValue(HUB_STRATEGY)} and no config file names hub.url;` + " expected hub.url, the address of the hub, such as https://hub.example.org"
+  ];
+}
+var HUB_SECTION = Object.freeze({
+  package: "hub",
+  settings: Object.freeze(HUB_SETTINGS),
+  defaults: HUB_DEFAULTS,
+  checks: Object.freeze([hubUrlProblems])
+});
+function hubContextOf(config) {
+  const url = config.hubUrl ?? null;
+  if (url === null)
+    return;
+  const timeout = config.hubTimeout ?? HUB_DEFAULTS.hubTimeout;
+  const timeoutMs = hubTimeoutMs(timeout);
+  if (timeoutMs === null) {
+    throw new TypeError(`hub.timeout is ${describeValue(timeout)}, which no config accepts`);
+  }
+  return Object.freeze({ url, tokenSecret: config.hubTokenSecret ?? null, timeoutMs });
+}
+
+// src/bugs/places.ts
+var BUILT_IN_ENVIRONMENTS = ["local", "ci", "prod"];
+var CI_OFF = ["", "0", "false"];
+function suggestedEnvironment(env) {
+  return CI_OFF.includes((env["CI"] ?? "").trim().toLowerCase()) ? "local" : "ci";
+}
+
+// src/bugs/title.ts
+var TITLE_VARIABLES = ["type", "project", "projectType", "module", "action", "summary"];
+var UNKNOWN_VALUE = "unknown";
+var DEFAULT_BUG_TITLE = "?(${module}?( - ${action}): )${summary}";
+var MODULE_SHAPE = "[a-z0-9][a-z0-9._-]*";
+var ACTION_SHAPE = "[a-z0-9][a-z0-9._ -]*";
+var SUMMARY = "summary";
+var VARIABLE_SHAPES = { module: MODULE_SHAPE, action: ACTION_SHAPE };
+var FREE_SHAPE = ".+";
+var GROUP_OPEN = "?(";
+var GROUP_CLOSE = ")";
+var VARIABLE_OPEN = "${";
+var VARIABLE_CLOSE = "}";
+
+class TitleTemplateError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TitleTemplateError";
+  }
+}
+function isPrintable(value) {
+  return typeof value === "string" && value.trim() !== "" && value.trim() !== UNKNOWN_VALUE;
+}
+function isTitleVariable(name) {
+  return TITLE_VARIABLES.includes(name);
+}
+function readVariable(template, at) {
+  const close = template.indexOf(VARIABLE_CLOSE, at);
+  if (close === -1)
+    throw new TitleTemplateError(`"${VARIABLE_OPEN}" at ${at} is never closed`);
+  const name = template.slice(at + VARIABLE_OPEN.length, close);
+  if (!isTitleVariable(name)) {
+    throw new TitleTemplateError(`\${${name}} names no variable, expected one of: ${TITLE_VARIABLES.join(", ")}`);
+  }
+  return { node: { kind: "variable", name }, next: close + VARIABLE_CLOSE.length };
+}
+function readNodes(template, start, depth) {
+  const nodes = [];
+  let text2 = "";
+  let at = start;
+  const flush = () => {
+    if (text2 !== "")
+      nodes.push({ kind: "text", text: text2 });
+    text2 = "";
+  };
+  while (at < template.length) {
+    if (template.startsWith(GROUP_OPEN, at)) {
+      flush();
+      const inner = readNodes(template, at + GROUP_OPEN.length, depth + 1);
+      nodes.push({ kind: "group", nodes: inner.nodes });
+      at = inner.next;
+    } else if (depth > 0 && template[at] === GROUP_CLOSE) {
+      flush();
+      return { nodes, next: at + GROUP_CLOSE.length };
+    } else if (template.startsWith(VARIABLE_OPEN, at)) {
+      flush();
+      const variable = readVariable(template, at);
+      nodes.push(variable.node);
+      at = variable.next;
+    } else {
+      text2 += template[at];
+      at += 1;
+    }
+  }
+  if (depth > 0)
+    throw new TitleTemplateError(`a "${GROUP_OPEN}" group is never closed`);
+  flush();
+  return { nodes, next: at };
+}
+function parseTitleTemplate(template) {
+  return readNodes(template, 0, 0).nodes;
+}
+function variablesOf(nodes) {
+  return nodes.flatMap((node) => {
+    if (node.kind === "variable")
+      return [node.name];
+    return node.kind === "group" ? variablesOf(node.nodes) : [];
+  });
+}
+function groupShows(nodes, values) {
+  return nodes.every((node) => node.kind !== "variable" || isPrintable(values[node.name]));
+}
+function printed(values, name) {
+  const value = values[name];
+  return isPrintable(value) ? value.trim() : "";
+}
+function shownValues(nodes, values) {
+  return Object.fromEntries(nodes.flatMap((node) => {
+    if (node.kind === "text")
+      return [];
+    if (node.kind === "variable") {
+      return printed(values, node.name) === "" ? [] : [[node.name, printed(values, node.name)]];
+    }
+    return groupShows(node.nodes, values) ? Object.entries(shownValues(node.nodes, values)) : [];
+  }));
+}
+function renderNodes(nodes, values) {
+  return nodes.map((node) => {
+    if (node.kind === "text")
+      return node.text;
+    if (node.kind === "variable")
+      return printed(values, node.name);
+    return groupShows(node.nodes, values) ? renderNodes(node.nodes, values) : "";
+  }).join("");
+}
+function renderTitle(template, values) {
+  return renderNodes(parseTitleTemplate(template), values).trim();
+}
+function escapeLiteral(text2) {
+  return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function patternOf(nodes, last) {
+  return nodes.map((node) => {
+    if (node.kind === "text")
+      return escapeLiteral(node.text);
+    if (node.kind === "group")
+      return `(?:${patternOf(node.nodes, last)})?`;
+    const shape = node.name === last ? FREE_SHAPE : `${VARIABLE_SHAPES[node.name] ?? FREE_SHAPE}?`;
+    return `(?<${node.name}>${shape})`;
+  }).join("");
+}
+function parseTitle(template, title) {
+  const nodes = parseTitleTemplate(template);
+  const names = variablesOf(nodes);
+  const match = new RegExp(`^${patternOf(nodes, names.at(-1))}$`, "u").exec(title.trim());
+  if (match === null)
+    return null;
+  return Object.fromEntries(names.flatMap((name) => {
+    const value = match.groups?.[name];
+    return value === undefined ? [] : [[name, value]];
+  }));
+}
+function titleRoundTrips(template, values) {
+  const nodes = parseTitleTemplate(template);
+  const title = renderNodes(nodes, values).trim();
+  if (title === "")
+    return false;
+  const read = parseTitle(template, title) ?? {};
+  const shown = shownValues(nodes, values);
+  return variablesOf(nodes).every((name) => (read[name] ?? null) === (shown[name] ?? null));
+}
+var SAMPLE = {
+  type: "bug",
+  project: "api",
+  projectType: "cli",
+  module: "loop",
+  action: "start",
+  summary: "Does not find the branch: again"
+};
+function samplesOf(names) {
+  const optional = names.filter((name) => name !== SUMMARY);
+  const subsets = optional.reduce((found, name) => [...found, ...found.map((subset) => [...subset, name])], [[]]);
+  return subsets.map((subset) => Object.fromEntries([...subset, SUMMARY].map((name) => [name, SAMPLE[name]])));
+}
+function nodesProblem(template, nodes) {
+  const names = variablesOf(nodes);
+  const twice = names.find((name, index) => names.indexOf(name) !== index);
+  if (twice !== undefined)
+    return `\${${twice}} appears twice`;
+  if (names.at(-1) !== SUMMARY)
+    return `\${${SUMMARY}} must be the last variable`;
+  if (!nodes.some((node) => node.kind === "variable" && node.name === SUMMARY)) {
+    return `\${${SUMMARY}} must stand outside every ?( ) group`;
+  }
+  const failed = samplesOf(names).find((sample) => !titleRoundTrips(template, sample));
+  return failed === undefined ? null : `the title ${JSON.stringify(renderTitle(template, failed))} does not read back as the fields it was rendered from`;
+}
+function templateProblem(template) {
+  try {
+    return nodesProblem(template, parseTitleTemplate(template));
+  } catch (error) {
+    if (error instanceof TitleTemplateError)
+      return error.message;
+    throw error;
+  }
+}
+
+// src/config-schema-issues.ts
+var SUMMARY_MAX_DEFAULT = 80;
+var SUMMARY_MAX_FLOOR = 20;
+var SUMMARY_MAX_CEILING = 120;
+var TEMPLATE_EXPECTED = "a title template";
+var PLACE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var MODULE = new RegExp(`^${MODULE_SHAPE}$`);
+var ACTION = new RegExp(`^${ACTION_SHAPE}$`);
+function accepted(value) {
+  return { value, problems: [], extras: [] };
+}
+var titleTemplate = (raw, at) => {
+  if (typeof raw !== "string" || raw.trim() === "")
+    return refused(at, raw, TEMPLATE_EXPECTED);
+  const problem = templateProblem(raw);
+  return problem === null ? accepted(raw) : refused(at, raw, `${TEMPLATE_EXPECTED}: ${problem}`);
+};
+var summaryMax = (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw >= SUMMARY_MAX_FLOOR && raw <= SUMMARY_MAX_CEILING ? accepted(raw) : refused(at, raw, `a whole number from ${SUMMARY_MAX_FLOOR} to ${SUMMARY_MAX_CEILING}`);
+function nameOf(shape, reserved, expected) {
+  return (raw, at) => typeof raw === "string" && shape.test(raw) && !reserved.includes(raw) ? accepted(raw) : refused(at, raw, expected);
+}
+var place = nameOf(PLACE, [...BUILT_IN_ENVIRONMENTS, UNKNOWN_VALUE], `a place name in lower-case kebab-case, other than ${BUILT_IN_ENVIRONMENTS.join(", ")} and ${UNKNOWN_VALUE}`);
+var moduleName = nameOf(MODULE, [UNKNOWN_VALUE], `a module name in lower-case letters, digits, ".", "_" and "-", other than ${UNKNOWN_VALUE}`);
+var actionName = nameOf(ACTION, [UNKNOWN_VALUE], `an action in lower-case letters, digits, ".", "_", "-" and spaces, other than ${UNKNOWN_VALUE}`);
+var ISSUES_DEFAULTS = Object.freeze({
+  issuesTitleBug: DEFAULT_BUG_TITLE,
+  issuesSummaryMax: SUMMARY_MAX_DEFAULT,
+  issuesEnvironments: Object.freeze([]),
+  issuesVocabularyModules: Object.freeze([]),
+  issuesVocabularyActions: Object.freeze([])
+});
+var ISSUES_SETTINGS = {
+  issuesTitleBug: { key: "issues.titles.bug", read: titleTemplate, cli: false },
+  issuesSummaryMax: { key: "issues.titles.summaryMax", read: summaryMax, cli: false },
+  issuesEnvironments: { key: "issues.environments", read: listOf(place, "place names"), cli: false },
+  issuesVocabularyModules: { key: "issues.vocabulary.modules", read: listOf(moduleName, "module names"), cli: false },
+  issuesVocabularyActions: { key: "issues.vocabulary.actions", read: listOf(actionName, "actions"), cli: false }
+};
+var ISSUES_SECTION = Object.freeze({
+  package: "issues",
+  settings: Object.freeze(ISSUES_SETTINGS),
+  defaults: ISSUES_DEFAULTS
+});
+function bugRulesOf(config) {
+  return {
+    template: config.issuesTitleBug,
+    summaryMax: config.issuesSummaryMax,
+    environments: [...BUILT_IN_ENVIRONMENTS, ...config.issuesEnvironments],
+    modules: config.issuesVocabularyModules,
+    actions: config.issuesVocabularyActions,
+    codes: listedCodes(config.errorsCodes)
+  };
+}
+
+// src/config-schema-logger.ts
+var MODULE_LEVEL_KEY = "level";
+var MODULE_EXPECTED = `a mapping holding ${MODULE_LEVEL_KEY}`;
+var moduleLevel2 = (raw, at) => {
+  if (!isMapping(raw))
+    return refused(at, raw, MODULE_EXPECTED);
+  const level = oneOf(LOG_LEVELS)(raw[MODULE_LEVEL_KEY], below(at, `.${MODULE_LEVEL_KEY}`));
+  const extras = Object.entries(raw).filter(([key]) => key !== MODULE_LEVEL_KEY).map(([key, value]) => ({ key: `${at.key}.${key}`, value }));
+  return { ...level, extras };
+};
+var LOGGER_DEFAULTS = Object.freeze({
+  loggerKind: DEFAULT_LOGGER_KIND,
+  loggerLevel: "warn",
+  loggerTheme: "default",
+  loggerModules: new Map,
+  loggerCallSite: false,
+  loggerApi: false
+});
+var LOGGER_SETTINGS = {
+  loggerKind: { key: "logger.kind", read: text("an adapter kind, such as console"), cli: false },
+  loggerLevel: { key: "logger.level", read: oneOf(LOG_LEVELS), cli: false },
+  loggerTheme: { key: "logger.theme", read: oneOf(LOGGER_THEMES), cli: false },
+  loggerModules: { key: "logger.modules", read: mapOf(moduleLevel2, MODULE_EXPECTED), cli: false, map: true },
+  loggerCallSite: { key: "logger.callSite", read: flag, cli: false },
+  loggerApi: { key: "logger.api", read: flag, cli: false }
+};
+var LOGGER_SECTION = Object.freeze({
+  package: "logger",
+  settings: Object.freeze(LOGGER_SETTINGS),
+  defaults: LOGGER_DEFAULTS
+});
+function loggerSettingsOf(config) {
+  return {
+    kind: config.loggerKind,
+    level: config.loggerLevel,
+    theme: config.loggerTheme,
+    modules: config.loggerModules,
+    callSite: config.loggerCallSite,
+    api: config.loggerApi
+  };
+}
+
+// src/config-schema-loop-continue.ts
+import { join } from "path";
+var RETRIES_ON_CONTINUE_MIN = 1;
+var RETRIES_ON_CONTINUE_MAX = 3;
+var FORCE_WRAP_UP_MAX_NEW_FAILURES_MIN = 1;
+var FORCE_WRAP_UP_MAX_NEW_FAILURES_MAX = 50;
+var CONTINUE_CRITERIA_MODES = ["extend", "replace"];
+function countOrFalse(min, max) {
+  const expected = `false or a whole number from ${String(min)} to ${String(max)}`;
+  return (raw, at) => raw === false || typeof raw === "number" && Number.isSafeInteger(raw) && raw >= min && raw <= max ? { value: raw, problems: [], extras: [] } : refused(at, raw, expected);
+}
+var retriesOnContinue = countOrFalse(RETRIES_ON_CONTINUE_MIN, RETRIES_ON_CONTINUE_MAX);
+var forceWrapUpMaxNewFailures = countOrFalse(FORCE_WRAP_UP_MAX_NEW_FAILURES_MIN, FORCE_WRAP_UP_MAX_NEW_FAILURES_MAX);
+var continueCriteria = text("a file path");
+var continueCriteriaMode = oneOf(CONTINUE_CRITERIA_MODES);
+var LOOP_CONTINUE_DEFAULTS = Object.freeze({
+  loopRetriesOnContinue: 1,
+  loopContinueCriteria: join(".rafa", "continue-criteria.md"),
+  loopContinueCriteriaMode: "extend",
+  loopForceWrapUpMaxNewFailures: false
+});
+var LOOP_CONTINUE_SETTINGS = {
+  loopRetriesOnContinue: { key: "loop.retriesOnContinue", read: retriesOnContinue, cli: false },
+  loopContinueCriteria: { key: "loop.continue.criteria", read: continueCriteria, cli: false },
+  loopContinueCriteriaMode: { key: "loop.continue.criteriaMode", read: continueCriteriaMode, cli: false },
+  loopForceWrapUpMaxNewFailures: {
+    key: "loop.forceWrapUp.maxNewFailures",
+    read: forceWrapUpMaxNewFailures,
+    cli: false
+  }
+};
+var LOOP_CONTINUE_SECTION = Object.freeze({
+  package: "loop-continue",
+  settings: Object.freeze(LOOP_CONTINUE_SETTINGS),
+  defaults: LOOP_CONTINUE_DEFAULTS
+});
+
+// src/config-schema-loop-retries.ts
+var LOOP_RETRIES_MIN = 1;
+var LOOP_RETRIES_MAX = 3;
+function isLoopRetryCount(raw) {
+  return typeof raw === "number" && Number.isSafeInteger(raw) && raw >= LOOP_RETRIES_MIN && raw <= LOOP_RETRIES_MAX;
+}
+var loopRetries = (raw, at) => raw === false || isLoopRetryCount(raw) ? { value: raw, problems: [], extras: [] } : refused(at, raw, `false or a whole number from ${String(LOOP_RETRIES_MIN)} to ${String(LOOP_RETRIES_MAX)}`);
+var LOOP_RETRIES_DEFAULTS = Object.freeze({
+  loopRetries: false
+});
+var LOOP_RETRIES_SETTINGS = {
+  loopRetries: { key: "loop.retries", read: loopRetries, cli: false }
+};
+var LOOP_RETRIES_SECTION = Object.freeze({
+  package: "loop-retries",
+  settings: Object.freeze(LOOP_RETRIES_SETTINGS),
+  defaults: LOOP_RETRIES_DEFAULTS
+});
+
+// src/pr/types.ts
+var MERGE_METHODS = Object.freeze([
+  "squash",
+  "merge",
+  "rebase"
+]);
+function isMergeMethod(value) {
+  return typeof value === "string" && MERGE_METHODS.includes(value);
+}
+
+// src/config-schema-release.ts
+var PR_DEFAULTS = Object.freeze({
+  prProvider: null,
+  prMergeMethod: "squash",
+  prBase: null,
+  prResolveBudget: 2,
+  prVersionCollision: "report"
+});
+var RELEASE_DEFAULTS = Object.freeze({
+  releaseEnabled: RELEASE_AUTO,
+  releaseVersionFile: "package.json",
+  releaseChangelog: "CHANGELOG.md",
+  releaseHeading: "## {version} \u2014 {date}, {title}",
+  releaseFragments: ".changes",
+  releaseStrategy: "semver-by-level",
+  releaseSettle: "push",
+  releaseTag: "manual",
+  releasePublishCommand: "npm publish",
+  releasePublish: "manual",
+  releaseMoveLock: false
+});
+var DANGEROUS_RELEASE_DEFAULTS = Object.freeze({
+  dangerousAcceptVersionCollision: false
+});
+var mergeMethod = oneOf(MERGE_METHODS);
+var PR_SETTINGS = {
+  prProvider: { key: "pr.provider", read: oneOf(PR_PROVIDERS), cli: false },
+  prMergeMethod: { key: "pr.mergeMethod", read: mergeMethod, cli: false },
+  prBase: { key: "pr.base", read: text("a branch name"), cli: false },
+  prResolveBudget: { key: "pr.resolveBudget", read: usdAmount, cli: false },
+  prVersionCollision: {
+    key: "pr.versionCollision",
+    read: versionCollisionMode,
+    cli: false
+  }
+};
+var RELEASE_SETTINGS = {
+  releaseEnabled: { key: "release.enabled", read: releaseEnabled, cli: false },
+  releaseVersionFile: {
+    key: "release.versionFile",
+    read: releaseFile,
+    cli: false
+  },
+  releaseChangelog: { key: "release.changelog", read: releaseFile, cli: false },
+  releaseHeading: {
+    key: "release.heading",
+    read: text("a changelog heading template"),
+    cli: false
+  },
+  releaseFragments: {
+    key: "release.fragments",
+    read: fragmentsDirectory,
+    cli: false
+  },
+  releaseStrategy: { key: "release.strategy", read: releaseStrategy, cli: false },
+  releaseSettle: { key: "release.settle", read: releaseSettleMode, cli: false },
+  releaseTag: { key: "release.tag", read: releaseTagMode, cli: false },
+  releasePublishCommand: {
+    key: "release.publishCommand",
+    read: text("a publish command"),
+    cli: false
+  },
+  releasePublish: { key: "release.publish", read: releasePublishMode, cli: false },
+  releaseMoveLock: { key: "release.moveLock", read: flag, cli: false }
+};
+var DANGEROUS_RELEASE_SETTINGS = {
+  dangerousAcceptVersionCollision: {
+    key: "dangerous.acceptVersionCollision",
+    read: flag,
+    cli: false
+  }
+};
+var RELEASE_SECTION = Object.freeze({
+  package: "release",
+  settings: Object.freeze({ ...PR_SETTINGS, ...RELEASE_SETTINGS, ...DANGEROUS_RELEASE_SETTINGS }),
+  defaults: Object.freeze({ ...PR_DEFAULTS, ...RELEASE_DEFAULTS, ...DANGEROUS_RELEASE_DEFAULTS })
+});
+
+// src/config-schema-tests.ts
+import { isAbsolute } from "path";
+var GLOB_PATTERN = "a glob pattern relative to the repository root";
+var repoGlob = (raw, at) => typeof raw === "string" && isAbsolute(raw) ? refused(at, raw, GLOB_PATTERN) : text(GLOB_PATTERN)(raw, at);
+var globList = listOf(repoGlob, "glob patterns");
+var TESTS_DEFAULTS = Object.freeze({
+  testsFullSuiteTriggers: Object.freeze([
+    "bunfig.toml",
+    "tsconfig*.json",
+    "package.json",
+    "bun.lock",
+    "bun.lockb"
+  ]),
+  testsIntegration: Object.freeze([
+    "**/*-integration.test.ts",
+    "**/*.integration.test.ts",
+    "**/*-spawned*.test.ts",
+    "**/*-cli.test.ts"
+  ]),
+  testsContract: Object.freeze(["**/*.contract.test.ts"]),
+  testsAlwaysRun: Object.freeze(["src/**/*.sweep.test.ts"]),
+  testsRetakeRedAlone: true
+});
+var TESTS_SETTINGS = {
+  testsFullSuiteTriggers: {
+    key: "tests.fullSuiteTriggers",
+    read: globList,
+    cli: false
+  },
+  testsIntegration: { key: "tests.integration", read: globList, cli: false },
+  testsContract: { key: "tests.contract", read: globList, cli: false },
+  testsAlwaysRun: { key: "tests.alwaysRun", read: globList, cli: false },
+  testsRetakeRedAlone: { key: "tests.retakeRedAlone", read: flag, cli: false }
+};
+var TESTS_SECTION = Object.freeze({
+  package: "tests",
+  settings: Object.freeze(TESTS_SETTINGS),
+  defaults: TESTS_DEFAULTS
+});
+
+// src/config-schema-triage.ts
+var SIMILARITY_THRESHOLD_MAX = 1;
+var SIMILARITY_WEIGHT_MIN = 0;
+var SIMILARITY_WEIGHT_MAX = 1;
+var SIMILARITY_CANDIDATES_MIN = 1;
+var SIMILARITY_CANDIDATES_MAX = 10;
+function isThreshold(raw) {
+  return typeof raw === "number" && Number.isFinite(raw) && raw > 0 && raw <= SIMILARITY_THRESHOLD_MAX;
+}
+function isCandidateCount(raw) {
+  return typeof raw === "number" && Number.isSafeInteger(raw) && raw >= SIMILARITY_CANDIDATES_MIN && raw <= SIMILARITY_CANDIDATES_MAX;
+}
+function isWeight(raw) {
+  return typeof raw === "number" && Number.isFinite(raw) && raw >= SIMILARITY_WEIGHT_MIN && raw <= SIMILARITY_WEIGHT_MAX;
+}
+var similarityThreshold = (raw, at) => raw === false || isThreshold(raw) ? { value: raw, problems: [], extras: [] } : refused(at, raw, `false or a number above 0 and at most ${String(SIMILARITY_THRESHOLD_MAX)}`);
+var similarityCandidates = (raw, at) => isCandidateCount(raw) ? { value: raw, problems: [], extras: [] } : refused(at, raw, `a whole number from ${String(SIMILARITY_CANDIDATES_MIN)} to ${String(SIMILARITY_CANDIDATES_MAX)}`);
+var similarityWeight = (raw, at) => isWeight(raw) ? { value: raw, problems: [], extras: [] } : refused(at, raw, `a number from ${String(SIMILARITY_WEIGHT_MIN)} to ${String(SIMILARITY_WEIGHT_MAX)}`);
+var TRIAGE_DEFAULTS = Object.freeze({
+  triageSimilarityThreshold: 0.3,
+  triageSimilarityCandidates: 3,
+  triageSimilarityWeightsCauseLeaf: 0.15,
+  triageSimilarityWeightsCauseFamily: 0.05,
+  triageSimilarityWeightsBoundary: 0.1
+});
+var TRIAGE_SETTINGS = {
+  triageSimilarityThreshold: {
+    key: "triage.similarity.threshold",
+    read: similarityThreshold,
+    cli: false
+  },
+  triageSimilarityCandidates: {
+    key: "triage.similarity.candidates",
+    read: similarityCandidates,
+    cli: false
+  },
+  triageSimilarityWeightsCauseLeaf: {
+    key: "triage.similarity.weights.causeLeaf",
+    read: similarityWeight,
+    cli: false
+  },
+  triageSimilarityWeightsCauseFamily: {
+    key: "triage.similarity.weights.causeFamily",
+    read: similarityWeight,
+    cli: false
+  },
+  triageSimilarityWeightsBoundary: {
+    key: "triage.similarity.weights.boundary",
+    read: similarityWeight,
+    cli: false
+  }
+};
+var TRIAGE_SECTION = Object.freeze({
+  package: "triage",
+  settings: Object.freeze(TRIAGE_SETTINGS),
+  defaults: TRIAGE_DEFAULTS
+});
+
+// src/config-schema-wrap-up.ts
+var WRAP_UP_RETRIES_MIN = 1;
+var WRAP_UP_RETRIES_MAX = 3;
+function isRetryCount(raw) {
+  return typeof raw === "number" && Number.isSafeInteger(raw) && raw >= WRAP_UP_RETRIES_MIN && raw <= WRAP_UP_RETRIES_MAX;
+}
+var wrapUpRetries = (raw, at) => raw === false || isRetryCount(raw) ? { value: raw, problems: [], extras: [] } : refused(at, raw, `false or a whole number from ${String(WRAP_UP_RETRIES_MIN)} to ${String(WRAP_UP_RETRIES_MAX)}`);
+var WRAP_UP_DEFAULTS = Object.freeze({
+  loopWrapUpRetries: 1
+});
+var WRAP_UP_SETTINGS = {
+  loopWrapUpRetries: { key: "loop.wrapUp.retries", read: wrapUpRetries, cli: false }
+};
+var WRAP_UP_SECTION = Object.freeze({
+  package: "wrap-up",
+  settings: Object.freeze(WRAP_UP_SETTINGS),
+  defaults: WRAP_UP_DEFAULTS
+});
+
+// src/config-registry.ts
+var CONFIG_SECTIONS = Object.freeze([
+  CORE_SECTION,
+  HUB_SECTION,
+  LOOP_RETRIES_SECTION,
+  LOOP_CONTINUE_SECTION,
+  WRAP_UP_SECTION,
+  RELEASE_SECTION,
+  BOARD_PROJECT_SECTION,
+  TRIAGE_SECTION,
+  ERRORS_SECTION,
+  BUGS_SECTION,
+  LOGGER_SECTION,
+  ISSUES_SECTION,
+  TESTS_SECTION,
+  FEATURES_SECTION
+]);
+function handConfigToLogger(config) {
+  setActiveLoggerSettings(loggerSettingsOf(config));
+}
+var CORE_HEAD = ["version", "store", "effortBusyTimeoutMs", "effortSync"];
+var CORE_PLAN_TO_LOOP = [
+  "inject",
+  "planDir",
+  "specsDir",
+  "trackerDefault",
+  "trackerFallback",
+  "learningAdapter",
+  "learningBlessMinConfidence",
+  "learningPromoteAfter",
+  "learningPromoteMinConfidence",
+  "outputMode",
+  "prerequisitesRequired",
+  "prerequisitesOptional",
+  "trackingSpecs",
+  "trackingPlans",
+  "trackingAll",
+  "modules",
+  "allowList",
+  "settingSources",
+  "loopWorktreeDir"
+];
+var CORE_BOARD = [
+  "boardTrustedAuthors",
+  "boardRelationships",
+  "boardProjectTemplate",
+  "boardProjectNumber"
+];
+var CORE_CLAIMS = ["roadmapIssue", "claimsStaleAfter", "claimsAhead"];
+var CORE_CLEANUP = [
+  "cleanupStaleDays",
+  "cleanupWorktreeIdleDays",
+  "cleanupKeep",
+  "dangerousAcceptStaleRefs"
+];
+var CORE_TAIL = [
+  "dangerousSelfUpdateDuringLoop",
+  "statusNotice",
+  "tiersRafa",
+  "tiersSkills",
+  "tiersAgents",
+  "routing",
+  "taskSkills",
+  "taskLessons",
+  "mergeDuplicates",
+  "namingBranch"
+];
+function run(record, names) {
+  return Object.fromEntries(names.map((name) => [name, record[name]]));
+}
+var CORE_SPECS = CORE_SECTION.settings;
+var CORE_VALUES = CORE_SECTION.defaults;
+var CONFIG_DEFAULTS = Object.freeze({
+  ...run(CORE_VALUES, CORE_HEAD),
+  ...HUB_DEFAULTS,
+  ...run(CORE_VALUES, CORE_PLAN_TO_LOOP),
+  ...LOOP_RETRIES_DEFAULTS,
+  ...LOOP_CONTINUE_DEFAULTS,
+  ...WRAP_UP_DEFAULTS,
+  ...PR_DEFAULTS,
+  ...run(CORE_VALUES, CORE_BOARD),
+  ...BOARD_PROJECT_LIMIT_DEFAULTS,
+  ...run(CORE_VALUES, CORE_CLAIMS),
+  ...TRIAGE_DEFAULTS,
+  ...RELEASE_DEFAULTS,
+  ...ERRORS_DEFAULTS,
+  ...BUGS_DEFAULTS,
+  ...LOGGER_DEFAULTS,
+  ...ISSUES_DEFAULTS,
+  ...run(CORE_VALUES, CORE_CLEANUP),
+  ...DANGEROUS_RELEASE_DEFAULTS,
+  ...run(CORE_VALUES, CORE_TAIL),
+  ...TESTS_DEFAULTS,
+  ...FEATURES_DEFAULTS
+});
+var SETTINGS = Object.freeze({
+  ...run(CORE_SPECS, CORE_HEAD),
+  ...HUB_SETTINGS,
+  ...run(CORE_SPECS, CORE_PLAN_TO_LOOP),
+  ...LOOP_RETRIES_SETTINGS,
+  ...LOOP_CONTINUE_SETTINGS,
+  ...WRAP_UP_SETTINGS,
+  ...PR_SETTINGS,
+  ...run(CORE_SPECS, CORE_BOARD),
+  ...BOARD_PROJECT_LIMIT_SETTINGS,
+  ...run(CORE_SPECS, CORE_CLAIMS),
+  ...TRIAGE_SETTINGS,
+  ...RELEASE_SETTINGS,
+  ...ERRORS_SETTINGS,
+  ...BUGS_SETTINGS,
+  ...LOGGER_SETTINGS,
+  ...ISSUES_SETTINGS,
+  ...run(CORE_SPECS, CORE_CLEANUP),
+  ...DANGEROUS_RELEASE_SETTINGS,
+  ...run(CORE_SPECS, CORE_TAIL),
+  ...TESTS_SETTINGS,
+  ...FEATURES_SETTINGS
+});
+var SETTING_NAMES = Object.freeze(Object.keys(SETTINGS));
+function inSettingOrder(sections, names) {
+  const cuts = names.reduce((runs, name) => {
+    const section = sections.find((candidate) => Object.hasOwn(candidate.settings, name));
+    if (section === undefined)
+      throw new Error(`rafa config registry: no section defines setting ${name}`);
+    const last = runs.at(-1);
+    return last?.section === section ? [...runs.slice(0, -1), { section, names: [...last.names, name] }] : [...runs, { section, names: [name] }];
+  }, []);
+  return cuts.map(({ section, names: run2 }, index) => ({
+    package: section.package,
+    settings: Object.fromEntries(run2.map((name) => [name, section.settings[name]])),
+    defaults: Object.fromEntries(run2.map((name) => [name, section.defaults[name]])),
+    checks: cuts.findIndex((cut) => cut.section === section) === index ? section.checks ?? [] : []
+  }));
+}
+function holdsCoreSections() {
+  const active = activeSettings();
+  return SETTING_NAMES.every((name) => active[name] === SETTINGS[name]);
+}
+function registerCoreConfigSections() {
+  if (holdsCoreSections())
+    return;
+  registerConfigSections(inSettingOrder(CONFIG_SECTIONS, SETTING_NAMES));
+  setConfigLoadHook(handConfigToLogger);
+}
+var SETTING_BY_KEY = new Map(SETTING_NAMES.map((setting) => [
+  SETTINGS[setting].key,
+  setting
+]));
+function sectionsOf(key) {
+  const parts = key.split(".");
+  return parts.slice(1).map((_, index) => parts.slice(0, index + 1).join("."));
+}
+var SECTIONS = new Set([...SETTING_BY_KEY.keys()].flatMap(sectionsOf));
+var KNOWN_UNDER = (() => {
+  const known = new Map;
+  const add = (parent, name) => {
+    const names = known.get(parent) ?? [];
+    if (!names.includes(name))
+      known.set(parent, [...names, name]);
+  };
+  for (const setting of SETTING_NAMES) {
+    const { key, itemKeys } = SETTINGS[setting];
+    const parts = key.split(".");
+    parts.forEach((part, index) => add(parts.slice(0, index).join("."), part));
+    for (const name of itemKeys ?? [])
+      add(`${key}[]`, name);
+  }
+  return known;
+})();
+
+export { DEFAULT_LOGGER_KIND, activeLoggerSettings, levelEnabled, hubContextOf, CODE_PATTERN, NEW_CONTEXT_LEAF, UNKNOWN_FAMILY, familyOf, codeProblem, isKnownCode, RAFA_CODES, ERRORS_DEFAULTS, FEATURES_SETTINGS, suggestedEnvironment, UNKNOWN_VALUE, MODULE_SHAPE, ACTION_SHAPE, renderTitle, titleRoundTrips, ISSUES_DEFAULTS, bugRulesOf, isLoopRetryCount, MERGE_METHODS, isMergeMethod, RELEASE_DEFAULTS, CONFIG_DEFAULTS, SETTINGS, SETTING_NAMES, registerCoreConfigSections };