@open-tomato/rafa 0.42.0 → 0.44.0

package/dist/{index-bceachy6.js → index-cknayrpc.js}

@@ -637,6 +637,163 @@ var BOARD_PROJECT_LIMIT_SETTINGS = {
   }
 };
 
+// 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 })));
+}
+
+// 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 }
+]);
+
+// 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 }
+};
+
 // src/config-schema-hub.ts
 var HUB_TIMEOUT_MIN_SECONDS = 1;
 var HUB_TIMEOUT_MAX_SECONDS = 30;
@@ -692,6 +849,300 @@ function hubContextOf(config) {
   return Object.freeze({ url, tokenSecret: config.hubTokenSecret ?? null, timeoutMs });
 }
 
+// src/bugs/places.ts
+var BUILT_IN_ENVIRONMENTS = ["local", "ci", "prod"];
+
+// 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 accepted2(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 ? accepted2(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 ? accepted2(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) ? accepted2(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 }
+};
+
+// 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-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 },
+  loggerCallSite: { key: "logger.callSite", read: flag, cli: false },
+  loggerApi: { key: "logger.api", read: flag, cli: false }
+};
+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 as join2 } from "path";
 var RETRIES_ON_CONTINUE_MIN = 1;
@@ -825,7 +1276,8 @@ var TESTS_DEFAULTS = Object.freeze({
     "**/*-spawned*.test.ts",
     "**/*-cli.test.ts"
   ]),
-  testsAlwaysRun: Object.freeze(["src/**/*.sweep.test.ts"])
+  testsAlwaysRun: Object.freeze(["src/**/*.sweep.test.ts"]),
+  testsRetakeRedAlone: true
 });
 var TESTS_SETTINGS = {
   testsFullSuiteTriggers: {
@@ -834,7 +1286,8 @@ var TESTS_SETTINGS = {
     cli: false
   },
   testsIntegration: { key: "tests.integration", read: globList, cli: false },
-  testsAlwaysRun: { key: "tests.alwaysRun", read: globList, cli: false }
+  testsAlwaysRun: { key: "tests.alwaysRun", read: globList, cli: false },
+  testsRetakeRedAlone: { key: "tests.retakeRedAlone", read: flag, cli: false }
 };
 
 // src/config-schema-triage.ts
@@ -1085,6 +1538,9 @@ var CONFIG_DEFAULTS = Object.freeze({
   claimsAhead: "off",
   ...TRIAGE_DEFAULTS,
   ...RELEASE_DEFAULTS,
+  ...ERRORS_DEFAULTS,
+  ...LOGGER_DEFAULTS,
+  ...ISSUES_DEFAULTS,
   cleanupStaleDays: 30,
   cleanupWorktreeIdleDays: 7,
   cleanupKeep: Object.freeze([]),
@@ -1178,6 +1634,9 @@ var SETTINGS = {
   claimsAhead: { key: "claims.ahead", read: claimsAhead, cli: false },
   ...TRIAGE_SETTINGS,
   ...RELEASE_SETTINGS,
+  ...ERRORS_SETTINGS,
+  ...LOGGER_SETTINGS,
+  ...ISSUES_SETTINGS,
   cleanupStaleDays: { key: "cleanup.staleDays", read: dayCount, cli: false },
   cleanupWorktreeIdleDays: {
     key: "cleanup.worktreeIdleDays",
@@ -1335,6 +1794,18 @@ function readLayer(rawOf, atOf) {
     releaseSettle: read("releaseSettle"),
     releaseTag: read("releaseTag"),
     releasePublishCommand: read("releasePublishCommand"),
+    errorsCodes: read("errorsCodes"),
+    loggerKind: read("loggerKind"),
+    loggerLevel: read("loggerLevel"),
+    loggerTheme: read("loggerTheme"),
+    loggerModules: read("loggerModules"),
+    loggerCallSite: read("loggerCallSite"),
+    loggerApi: read("loggerApi"),
+    issuesTitleBug: read("issuesTitleBug"),
+    issuesSummaryMax: read("issuesSummaryMax"),
+    issuesEnvironments: read("issuesEnvironments"),
+    issuesVocabularyModules: read("issuesVocabularyModules"),
+    issuesVocabularyActions: read("issuesVocabularyActions"),
     cleanupStaleDays: read("cleanupStaleDays"),
     cleanupWorktreeIdleDays: read("cleanupWorktreeIdleDays"),
     cleanupKeep: read("cleanupKeep"),
@@ -1350,7 +1821,8 @@ function readLayer(rawOf, atOf) {
     taskLessons: read("taskLessons"),
     testsFullSuiteTriggers: read("testsFullSuiteTriggers"),
     testsIntegration: read("testsIntegration"),
-    testsAlwaysRun: read("testsAlwaysRun")
+    testsAlwaysRun: read("testsAlwaysRun"),
+    testsRetakeRedAlone: read("testsRetakeRedAlone")
   };
   return { layer, problems, extras };
 }
@@ -1429,7 +1901,8 @@ function parseConfigText(text2, path) {
 var MAP_SETTINGS = new Set([
   "tiersSkills",
   "tiersAgents",
-  "routing"
+  "routing",
+  "loggerModules"
 ]);
 function mergeMaps(...layers) {
   const merged = new Map;
@@ -1846,7 +2319,7 @@ function planStubFromPath(planPath) {
 }
 
 // src/adapters/output/text.ts
-var DEBUG_VERBOSITY = 2;
+var DEBUG_VERBOSITY2 = 2;
 function formatPayload(payload) {
   return typeof payload === "string" ? payload : JSON.stringify(payload);
 }
@@ -1864,7 +2337,7 @@ function createTextOutput({ verbosity, stream }) {
 `);
   };
   const debug = (message) => {
-    if (verbosity >= DEBUG_VERBOSITY)
+    if (verbosity >= DEBUG_VERBOSITY2)
       writeLine(`debug: ${message}`);
   };
   const info = (message) => {
@@ -1926,14 +2399,16 @@ function createTextOutput({ verbosity, stream }) {
 }
 
 // src/adapters/output/active.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+var scopes2 = new AsyncLocalStorage2;
 var DEFAULT_OUTPUT = createTextOutput({ verbosity: 0, stream: process.stdout });
 var active = DEFAULT_OUTPUT;
 var activeMode = "text";
 function activeOutput() {
-  return active;
+  return scopes2.getStore()?.output ?? active;
 }
 function activeOutputMode() {
-  return activeMode;
+  return scopes2.getStore()?.mode ?? activeMode;
 }
 
-export { MERGE_METHODS, isMergeMethod, SKILL_TIERS, RAFA_INSTINCTS_PATH, BUNDLED_SKILLS_DIR, isSkillTier, realEntry, bundledBinDirectory, skillTierDirectory, resolveSkillTiers, resolveInstinctScopes, tierExists, TEST_SCOPES, isAgentName, BUDGET_FLAG, readTestScope, parseTaskDeclaration, stripTaskDeclaration, resolveDeclarationFlags, isMapping, describeValue, messageOf, CONFIG_VERSIONS, STORE_BACKENDS, SYNC_STRATEGIES, BOARD_RELATIONSHIP_MODES, INJECT_MODES, OUTPUT_MODES, CLAUDE_SETTING_SOURCES, PR_PROVIDERS, RELEASE_AUTO, SKILL_RESOLVERS, CLAIMS_STALE_DISABLED, BUSY_TIMEOUT_MIN_MS, BUSY_TIMEOUT_MAX_MS, isBusyTimeoutMs, claimDurationHours, isGitHubLogin, BOARD_PROJECT_TEMPLATE_DEFAULT, listOf, hubContextOf, PREREQUISITE_KINDS, requiredPrerequisite, optionalPrerequisite, MODULE_SOURCE_KINDS, isLoopRetryCount, RELEASE_DEFAULTS, pinKey, pinLine, collisionMessage, readItemBytes, resolveTiers, findTierItem, DEFAULT_ROUTING, CONFIG_FILE, CONFIG_DEFAULTS, SETTINGS, ConfigError, configFilePath, parseConfigText, resolveConfig, isStampableStub, planStubFromPrompt, stampPrompt, planStubFromPath, createTextOutput, activeOutput, activeOutputMode, RAFA_BLOCK_KINDS, isRafaBlockKind, readRafaBlocks, REPORT_STATUSES, FINDING_KINDS, FINDING_SIGNALS, FINDING_DOMAINS, CHANGE_LEVELS, parseReport };
+export { MERGE_METHODS, isMergeMethod, SKILL_TIERS, RAFA_INSTINCTS_PATH, BUNDLED_SKILLS_DIR, isSkillTier, realEntry, bundledBinDirectory, skillTierDirectory, resolveSkillTiers, resolveInstinctScopes, tierExists, TEST_SCOPES, isAgentName, BUDGET_FLAG, readTestScope, parseTaskDeclaration, stripTaskDeclaration, resolveDeclarationFlags, isMapping, describeValue, messageOf, CONFIG_VERSIONS, STORE_BACKENDS, SYNC_STRATEGIES, BOARD_RELATIONSHIP_MODES, INJECT_MODES, OUTPUT_MODES, CLAUDE_SETTING_SOURCES, PR_PROVIDERS, RELEASE_AUTO, SKILL_RESOLVERS, CLAIMS_STALE_DISABLED, BUSY_TIMEOUT_MIN_MS, BUSY_TIMEOUT_MAX_MS, isBusyTimeoutMs, claimDurationHours, isGitHubLogin, BOARD_PROJECT_TEMPLATE_DEFAULT, listOf, hubContextOf, PREREQUISITE_KINDS, requiredPrerequisite, optionalPrerequisite, MODULE_SOURCE_KINDS, DEFAULT_LOGGER_KIND, setActiveLoggerSettings, activeLoggerSettings, levelEnabled, loggerSettingsOf, isLoopRetryCount, RELEASE_DEFAULTS, pinKey, pinLine, collisionMessage, readItemBytes, resolveTiers, findTierItem, DEFAULT_ROUTING, CONFIG_FILE, CONFIG_DEFAULTS, SETTINGS, ConfigError, configFilePath, parseConfigText, resolveConfig, isStampableStub, planStubFromPrompt, stampPrompt, planStubFromPath, RAFA_BLOCK_KINDS, isRafaBlockKind, readRafaBlocks, REPORT_STATUSES, FINDING_KINDS, FINDING_SIGNALS, FINDING_DOMAINS, CHANGE_LEVELS, parseReport, createTextOutput, activeOutput, activeOutputMode };