@open-tomato/rafa 0.41.0 → 0.43.0

package/dist/{index-3jpz9nr3.js → index-cknayrpc.js}

@@ -1,48 +1,451 @@
 // @bun
 import {
-  BOARD_PROJECT_TEMPLATE_DEFAULT,
-  BOARD_RELATIONSHIP_MODES,
-  CLAUDE_SETTING_SOURCES,
-  CONFIG_VERSIONS,
-  INJECT_MODES,
-  OUTPUT_MODES,
-  PR_PROVIDERS,
-  RELEASE_AUTO,
-  SKILL_TIERS,
-  STORE_BACKENDS,
-  SYNC_STRATEGIES,
-  below,
-  busyTimeoutMs,
-  claimsAhead,
-  claimsStaleAfter,
-  confidence,
-  dayCount,
-  describeValue,
-  flag,
-  githubLogin,
-  isMapping,
-  isSkillTier,
-  issueNumber,
-  lessonSwitch,
-  listOf,
-  mapReading,
-  mergeMethod,
-  messageOf,
-  oneOf,
-  projectNumber,
-  projectUrl,
-  recurrenceCount,
-  refused,
-  refusedWith,
-  releaseEnabled,
-  routeTarget,
-  skillResolverName,
-  subsetOf,
-  text,
-  tierPin,
-  tierSwitch,
-  usdAmount
-} from "./index-m2ahxjw8.js";
+  CONFIDENCE_MAX,
+  CONFIDENCE_MIN
+} from "./index-hf2k497d.js";
+
+// src/pr/types.ts
+var MERGE_METHODS = Object.freeze([
+  "squash",
+  "merge",
+  "rebase"
+]);
+function isMergeMethod(value) {
+  return typeof value === "string" && MERGE_METHODS.includes(value);
+}
+
+// src/schema/tiers.ts
+import { existsSync, realpathSync } from "fs";
+import { dirname, join } from "path";
+var SKILL_TIERS = ["project", "rafa", "user"];
+var INSTINCT_SCOPES = ["project", "user"];
+var CLAUDE_SKILLS_PATH = join(".claude", "skills");
+var RAFA_INSTINCTS_PATH = join(".rafa", "instincts");
+var BUNDLED_SKILLS_DIR = join("bundled", "skills");
+var BUNDLED_BIN_DIR = join("bundled", "bin");
+function isSkillTier(value) {
+  return SKILL_TIERS.includes(value);
+}
+function realEntry(entry) {
+  try {
+    return realpathSync(entry);
+  } catch {
+    return entry;
+  }
+}
+function bundledSkillsDirectory(entry) {
+  return join(dirname(realEntry(entry ?? Bun.main)), BUNDLED_SKILLS_DIR);
+}
+function bundledBinDirectory(entry) {
+  return join(dirname(realEntry(entry ?? Bun.main)), BUNDLED_BIN_DIR);
+}
+function skillTierDirectory(tier, seams) {
+  if (tier === "user")
+    return join(seams.home, CLAUDE_SKILLS_PATH);
+  if (tier === "rafa")
+    return bundledSkillsDirectory(seams.entry);
+  return seams.projectRoot === null ? null : join(seams.projectRoot, CLAUDE_SKILLS_PATH);
+}
+function resolveSkillTiers(seams) {
+  const located = [];
+  for (const tier of SKILL_TIERS) {
+    const dir = skillTierDirectory(tier, seams);
+    if (dir !== null)
+      located.push({ tier, dir });
+  }
+  return located;
+}
+function instinctScopeDirectory(scope, seams) {
+  if (scope === "user")
+    return join(seams.home, RAFA_INSTINCTS_PATH);
+  return seams.projectRoot === null ? null : join(seams.projectRoot, RAFA_INSTINCTS_PATH);
+}
+function resolveInstinctScopes(seams) {
+  const located = [];
+  for (const scope of INSTINCT_SCOPES) {
+    const dir = instinctScopeDirectory(scope, seams);
+    if (dir !== null)
+      located.push({ scope, dir });
+  }
+  return located;
+}
+function tierExists(dir) {
+  return existsSync(dir);
+}
+
+// src/utils/declaration.ts
+var DECLARATION_KEYS = [
+  "agent",
+  "model",
+  "effort",
+  "budget",
+  "tools",
+  "skills",
+  "tests"
+];
+var GRANULAR_KEYS = ["model", "effort", "tools"];
+var AGENT_OWNED_KEYS = ["model", "tools"];
+var MODEL_ALIASES = ["opus", "sonnet", "haiku", "fable"];
+var EFFORT_LEVELS = [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var TEST_SCOPES = ["affected", "module", "full"];
+var DEFAULT_TEST_SCOPE = "affected";
+var DECLARATION_BLOCK = /\{([^{}]*)\}$/;
+var ENTRY_TOKEN = /^([A-Za-z_][A-Za-z0-9_-]*)=(.*)$/;
+var FULL_MODEL_NAME = /^claude-[a-z0-9][a-z0-9.-]*$/;
+var AGENT_NAME = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+function isAgentName(value) {
+  return AGENT_NAME.test(value);
+}
+var TOOL_NAME = /^[A-Za-z][A-Za-z0-9_-]*$/;
+var SKILL_NAME = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+var BUDGET_FLAG = "--max-budget-usd";
+var BUDGET_VALUE = /^(?:0|[1-9]\d{0,5})(?:\.\d{1,6})?$/;
+function parseBudgetUsd(value) {
+  if (!BUDGET_VALUE.test(value))
+    return null;
+  const usd = Number(value);
+  return usd > 0 ? usd : null;
+}
+function isEffortLevel(value) {
+  return EFFORT_LEVELS.includes(value);
+}
+function isTestScope(value) {
+  return TEST_SCOPES.includes(value);
+}
+function readTestScope(declaration) {
+  return declaration?.tests ?? DEFAULT_TEST_SCOPE;
+}
+function isModelValue(value) {
+  if (MODEL_ALIASES.includes(value))
+    return true;
+  return FULL_MODEL_NAME.test(value);
+}
+function parseToolList(value) {
+  const parts = value.split(",");
+  if (parts.length === 0)
+    return null;
+  const tools = [];
+  for (const part of parts) {
+    if (!TOOL_NAME.test(part))
+      return null;
+    if (!tools.includes(part))
+      tools.push(part);
+  }
+  return tools;
+}
+function parseSkillList(value) {
+  const parts = value.split(",");
+  if (parts.length === 0)
+    return null;
+  const skills = [];
+  for (const part of parts) {
+    if (!SKILL_NAME.test(part))
+      return null;
+    if (!skills.includes(part))
+      skills.push(part);
+  }
+  return skills;
+}
+function unusableValue(key, token) {
+  return { reason: "unusable-value", key, text: token };
+}
+function isDeclarationKey(key) {
+  return DECLARATION_KEYS.includes(key);
+}
+function tokenise(body) {
+  const trimmed = body.trim();
+  if (trimmed.length === 0)
+    return [];
+  return trimmed.split(/\s+/);
+}
+function readBlock(raw, body) {
+  const entries = [];
+  const extras = [];
+  const issues = [];
+  const seen = new Set;
+  let agent = null;
+  let model = null;
+  let effort = null;
+  let budget = null;
+  let tools = null;
+  let skills = null;
+  let tests = null;
+  for (const token of tokenise(body)) {
+    const match = token.match(ENTRY_TOKEN);
+    const key = match?.[1];
+    const value = match?.[2];
+    if (key === undefined || value === undefined) {
+      issues.push({ reason: "stray-token", key: "", text: token });
+      continue;
+    }
+    const entry = { key, value };
+    entries.push(entry);
+    if (!isDeclarationKey(key)) {
+      extras.push(entry);
+      continue;
+    }
+    if (seen.has(key)) {
+      issues.push({ reason: "duplicate-key", key, text: token });
+      continue;
+    }
+    seen.add(key);
+    if (key === "agent") {
+      if (AGENT_NAME.test(value))
+        agent = value;
+      else
+        issues.push(unusableValue(key, token));
+      continue;
+    }
+    if (key === "model") {
+      if (isModelValue(value))
+        model = value;
+      else
+        issues.push(unusableValue(key, token));
+      continue;
+    }
+    if (key === "effort") {
+      if (isEffortLevel(value))
+        effort = value;
+      else
+        issues.push(unusableValue(key, token));
+      continue;
+    }
+    if (key === "budget") {
+      const usd = parseBudgetUsd(value);
+      if (usd === null)
+        issues.push(unusableValue(key, token));
+      else
+        budget = usd;
+      continue;
+    }
+    if (key === "tools") {
+      const parsed = parseToolList(value);
+      if (parsed === null)
+        issues.push(unusableValue(key, token));
+      else
+        tools = parsed;
+      continue;
+    }
+    if (key === "tests") {
+      if (isTestScope(value))
+        tests = value;
+      else
+        issues.push(unusableValue(key, token));
+      continue;
+    }
+    const named = parseSkillList(value);
+    if (named === null)
+      issues.push(unusableValue(key, token));
+    else
+      skills = named;
+  }
+  if (seen.size === 0)
+    return null;
+  return {
+    raw,
+    entries,
+    extras,
+    issues,
+    agent,
+    model,
+    effort,
+    budget,
+    tools,
+    skills,
+    tests
+  };
+}
+function parseTaskDeclaration(taskText) {
+  const trimmed = taskText.trimEnd();
+  const match = trimmed.match(DECLARATION_BLOCK);
+  const raw = match?.[0];
+  const body = match?.[1];
+  if (raw === undefined || body === undefined) {
+    return { text: taskText, declaration: null };
+  }
+  const before = trimmed.slice(0, trimmed.length - raw.length).trimEnd();
+  if (before.length === 0)
+    return { text: taskText, declaration: null };
+  const declaration = readBlock(raw, body);
+  if (declaration === null)
+    return { text: taskText, declaration: null };
+  return { text: before, declaration };
+}
+function stripTaskDeclaration(taskText) {
+  return parseTaskDeclaration(taskText).text;
+}
+function budgetArgs(budget) {
+  return budget === null ? [] : [BUDGET_FLAG, String(budget)];
+}
+function resolveDeclarationFlags(declaration, agentDeclaresEffort) {
+  if (declaration === null)
+    return { args: [], suppressed: [] };
+  const { agent, effort } = declaration;
+  const isPresent = (key) => declaration[key] !== null;
+  const budget = budgetArgs(declaration.budget);
+  if (agent !== null) {
+    if (effort === null || agentDeclaresEffort(agent)) {
+      return { args: ["--agent", agent, ...budget], suppressed: GRANULAR_KEYS.filter(isPresent) };
+    }
+    return {
+      args: ["--agent", agent, "--effort", effort, ...budget],
+      suppressed: AGENT_OWNED_KEYS.filter(isPresent)
+    };
+  }
+  const args = [];
+  if (declaration.model !== null)
+    args.push("--model", declaration.model);
+  if (declaration.effort !== null)
+    args.push("--effort", declaration.effort);
+  args.push(...budget);
+  if (declaration.tools !== null) {
+    args.push("--tools", declaration.tools.join(","));
+  }
+  return { args, suppressed: [] };
+}
+
+// src/config-sections.ts
+function isMapping(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function describeValue(value) {
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "a list";
+  if (typeof value === "object")
+    return "a mapping";
+  return String(value);
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var CONFIG_VERSIONS = [1];
+var STORE_BACKENDS = ["sqlite", "ndjson"];
+var SYNC_STRATEGIES = ["local", "file", "git", "service", "p2p"];
+var BOARD_RELATIONSHIP_MODES = ["labels", "native"];
+var INJECT_MODES = ["full", "stage", "task"];
+var OUTPUT_MODES = ["text", "json", "events"];
+var CLAUDE_SETTING_SOURCES = ["user", "project", "local"];
+var PR_PROVIDERS = ["gh", "none"];
+var RELEASE_AUTO = "auto";
+var TIER_SWITCHES = ["on", "off"];
+var SKILL_RESOLVERS = ["planner", "tag", "none"];
+var LESSON_SWITCHES = ["on", "off"];
+var CLAIMS_STALE_DISABLED = "disabled";
+var CLAIMS_AHEAD = ["off", "allow"];
+function accepted(value) {
+  return { value, problems: [], extras: [] };
+}
+function refused(at, raw, expected) {
+  const problem = `${at.label} is ${describeValue(raw)}, expected ${expected}`;
+  return { value: undefined, problems: [problem], extras: [] };
+}
+function refusedWith(problems) {
+  return { value: undefined, problems, extras: [] };
+}
+function mapReading(reading, map) {
+  return reading.value === undefined ? { ...reading, value: undefined } : { ...reading, value: map(reading.value) };
+}
+function below(at, step) {
+  return { label: `${at.label}${step}`, key: `${at.key}${step}` };
+}
+function oneOf(values) {
+  const expected = `one of: ${values.join(", ")}`;
+  return (raw, at) => {
+    const hit = values.find((value) => value === raw);
+    return hit === undefined ? refused(at, raw, expected) : accepted(hit);
+  };
+}
+function text(expected) {
+  return (raw, at) => typeof raw === "string" && raw.trim() !== "" ? accepted(raw) : refused(at, raw, expected);
+}
+var flag = (raw, at) => typeof raw === "boolean" ? accepted(raw) : refused(at, raw, "true or false");
+var mergeMethod = oneOf(MERGE_METHODS);
+var usdAmount = (raw, at) => {
+  const usd = typeof raw === "number" ? parseBudgetUsd(String(raw)) : null;
+  return usd === null ? refused(at, raw, "a number of US dollars above zero, at most six digits either side of the point") : accepted(usd);
+};
+var issueNumber = (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw > 0 ? accepted(raw) : refused(at, raw, "an issue number, a whole number above zero");
+var dayCount = (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw > 0 ? accepted(raw) : refused(at, raw, "a number of days, a whole number above zero");
+var BUSY_TIMEOUT_MIN_MS = 1;
+var BUSY_TIMEOUT_MAX_MS = 60000;
+function isBusyTimeoutMs(raw) {
+  return typeof raw === "number" && Number.isSafeInteger(raw) && raw >= BUSY_TIMEOUT_MIN_MS && raw <= BUSY_TIMEOUT_MAX_MS;
+}
+var busyTimeoutMs = (raw, at) => isBusyTimeoutMs(raw) ? accepted(raw) : refused(at, raw, `a lock wait in milliseconds, a whole number from ${String(BUSY_TIMEOUT_MIN_MS)} to ${String(BUSY_TIMEOUT_MAX_MS)}`);
+var confidence = (raw, at) => typeof raw === "number" && Number.isFinite(raw) && toHundredths(raw) >= toHundredths(CONFIDENCE_MIN) && toHundredths(raw) <= toHundredths(CONFIDENCE_MAX) ? accepted(raw) : refused(at, raw, `a confidence from ${String(CONFIDENCE_MIN)} to ${String(CONFIDENCE_MAX)}`);
+function toHundredths(value) {
+  return Math.round(value * 100);
+}
+var recurrenceCount = (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw >= 1 ? accepted(raw) : refused(at, raw, "a count, a whole number of 1 or more");
+var releaseEnabled = (raw, at) => typeof raw === "boolean" || raw === RELEASE_AUTO ? accepted(raw) : refused(at, raw, `true, false or ${RELEASE_AUTO}`);
+var tierSwitch = oneOf(TIER_SWITCHES);
+var tierPin = (raw, at) => {
+  if (raw === false)
+    return accepted(false);
+  const tier = SKILL_TIERS.find((name) => name === raw);
+  return tier === undefined ? refused(at, raw, `false or one of: ${SKILL_TIERS.join(", ")}`) : accepted(tier);
+};
+var routeTarget = (raw, at) => raw === false || typeof raw === "string" && raw.trim() !== "" ? accepted(raw) : refused(at, raw, "false or an agent name");
+var skillResolverName = oneOf(SKILL_RESOLVERS);
+var lessonSwitch = oneOf(LESSON_SWITCHES);
+var CLAIM_DURATION = /^(\d+)([hd])$/;
+var HOURS_PER_DAY = 24;
+function claimDurationHours(raw) {
+  const match = typeof raw === "string" ? CLAIM_DURATION.exec(raw) : null;
+  if (match === null)
+    return null;
+  const hours = Number(match[1]) * (match[2] === "d" ? HOURS_PER_DAY : 1);
+  return Number.isSafeInteger(hours) && hours > 0 ? hours : null;
+}
+var claimsStaleAfter = (raw, at) => raw === CLAIMS_STALE_DISABLED || claimDurationHours(raw) !== null ? accepted(raw) : refused(at, raw, `a duration of whole hours or days above zero, such as 36h or 3d, or ${CLAIMS_STALE_DISABLED}`);
+var claimsAhead = oneOf(CLAIMS_AHEAD);
+var GITHUB_LOGIN = /^[A-Za-z0-9][A-Za-z0-9-]*(?:\[bot\])?$/;
+function isGitHubLogin(value) {
+  return typeof value === "string" && GITHUB_LOGIN.test(value);
+}
+var githubLogin = (raw, at) => isGitHubLogin(raw) ? accepted(raw) : refused(at, raw, "a GitHub login");
+var BOARD_PROJECT_TEMPLATE_DEFAULT = "https://github.com/orgs/open-tomato/projects/6";
+var PROJECT_URL = /^https:\/\/github\.com\/(?:orgs|users)\/[A-Za-z0-9][A-Za-z0-9-]*\/projects\/[1-9]\d*$/;
+var projectUrl = (raw, at) => typeof raw === "string" && PROJECT_URL.test(raw) ? accepted(raw) : refused(at, raw, "a GitHub project URL, https://github.com/orgs/<owner>/projects/<number> or /users/<owner>/\u2026");
+var projectNumber = (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw > 0 ? accepted(raw) : refused(at, raw, "a project number, a whole number above zero");
+function listOf(item, expected) {
+  return (raw, at) => {
+    if (!Array.isArray(raw))
+      return refused(at, raw, `a list of ${expected}`);
+    const readings = raw.map((entry, index) => item(entry, below(at, `[${index}]`)));
+    const problems = readings.flatMap((reading) => reading.problems);
+    const extras = readings.flatMap((reading) => reading.extras);
+    if (problems.length > 0)
+      return { value: undefined, problems, extras };
+    const values = readings.flatMap((reading) => reading.value === undefined ? [] : [reading.value]);
+    return { value: Object.freeze(values), problems, extras };
+  };
+}
+function subsetOf(values) {
+  const expected = `a comma-separated subset of: ${values.join(", ")}`;
+  return (raw, at) => {
+    if (typeof raw !== "string")
+      return refused(at, raw, expected);
+    const named = [];
+    for (const entry of raw.split(",")) {
+      const hit = values.find((value) => value === entry.trim());
+      if (hit === undefined || named.includes(hit))
+        return refused(at, raw, expected);
+      named.push(hit);
+    }
+    return accepted(Object.freeze(named));
+  };
+}
 
 // src/config-items.ts
 var itemText = text("a non-empty string");
@@ -117,7 +520,7 @@ var moduleSource = (raw, at) => {
 };
 
 // src/config-schema.ts
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 
 // src/config-readers.ts
 import { isAbsolute, normalize } from "path";
@@ -234,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;
@@ -289,8 +849,302 @@ 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 } from "path";
+import { join as join2 } from "path";
 var RETRIES_ON_CONTINUE_MIN = 1;
 var RETRIES_ON_CONTINUE_MAX = 3;
 var FORCE_WRAP_UP_MAX_NEW_FAILURES_MIN = 1;
@@ -306,7 +1160,7 @@ 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"),
+  loopContinueCriteria: join2(".rafa", "continue-criteria.md"),
   loopContinueCriteriaMode: "extend",
   loopForceWrapUpMaxNewFailures: false
 });
@@ -422,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: {
@@ -431,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
@@ -642,7 +1498,7 @@ var DEFAULT_ROUTES = Object.freeze([
 var DEFAULT_ROUTING = new Map(DEFAULT_ROUTES);
 
 // src/config-schema.ts
-var CONFIG_FILE = join2(".rafa", "config.yaml");
+var CONFIG_FILE = join3(".rafa", "config.yaml");
 var CONFIG_DEFAULTS = Object.freeze({
   version: 1,
   store: "sqlite",
@@ -650,8 +1506,8 @@ var CONFIG_DEFAULTS = Object.freeze({
   effortSync: "local",
   ...HUB_DEFAULTS,
   inject: "stage",
-  planDir: join2(".rafa", "plans"),
-  specsDir: join2(".rafa", "specs"),
+  planDir: join3(".rafa", "plans"),
+  specsDir: join3(".rafa", "specs"),
   trackerDefault: "github",
   trackerFallback: Object.freeze(["local"]),
   learningAdapter: "local",
@@ -667,7 +1523,7 @@ var CONFIG_DEFAULTS = Object.freeze({
   modules: Object.freeze([]),
   allowList: Object.freeze([]),
   settingSources: Object.freeze(["project", "local"]),
-  loopWorktreeDir: join2(".rafa", "worktrees"),
+  loopWorktreeDir: join3(".rafa", "worktrees"),
   ...LOOP_RETRIES_DEFAULTS,
   ...LOOP_CONTINUE_DEFAULTS,
   ...WRAP_UP_DEFAULTS,
@@ -682,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([]),
@@ -775,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",
@@ -850,7 +1712,7 @@ function knownKeysAbove(key) {
 }
 
 // src/config.ts
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 class ConfigError extends Error {
   problems;
   constructor(problems, options) {
@@ -932,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"),
@@ -947,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 };
 }
@@ -1003,7 +1878,7 @@ function parseYaml(text2, path) {
   }
 }
 function configFilePath(root) {
-  return join3(root, CONFIG_FILE);
+  return join4(root, CONFIG_FILE);
 }
 function parseConfigText(text2, path) {
   const document = parseYaml(text2, path) ?? {};
@@ -1026,7 +1901,8 @@ function parseConfigText(text2, path) {
 var MAP_SETTINGS = new Set([
   "tiersSkills",
   "tiersAgents",
-  "routing"
+  "routing",
+  "loggerModules"
 ]);
 function mergeMaps(...layers) {
   const merged = new Map;
@@ -1443,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);
 }
@@ -1461,7 +2337,7 @@ function createTextOutput({ verbosity, stream }) {
 `);
   };
   const debug = (message) => {
-    if (verbosity >= DEBUG_VERBOSITY)
+    if (verbosity >= DEBUG_VERBOSITY2)
       writeLine(`debug: ${message}`);
   };
   const info = (message) => {
@@ -1523,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 { hubContextOf, PREREQUISITE_KINDS, requiredPrerequisite, optionalPrerequisite, MODULE_SOURCE_KINDS, isLoopRetryCount, RELEASE_DEFAULTS, pinKey, pinLine, collisionMessage, readItemBytes, resolveTiers, findTierItem, DEFAULT_ROUTES, DEFAULT_ROUTING, CONFIG_FILE, CONFIG_DEFAULTS, SETTINGS, SETTING_NAMES, SETTING_BY_KEY, SECTIONS, knownKeysAbove, 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 };