karajan-code 2.5.0 → 2.6.0

package/src/brain/solomon-consult.js

@@ -0,0 +1,163 @@
+/**
+ * Brain → Solomon consultation for routing decisions.
+ *
+ * When the Brain's Decision is low confidence, ambiguous, or the triage+config
+ * combination yields conflicting signals, the Brain consults Solomon. Solomon
+ * ruling is treated as *advisory*: if it returns a concrete role adjustment
+ * (e.g. "add security"), Brain applies it; otherwise Brain keeps the baseline.
+ *
+ * This is intentionally conservative. A future iteration can make Solomon a
+ * binding arbiter for routing (like it is for pipeline-control decisions).
+ */
+
+/**
+ * Build a synthetic conflict payload suitable for invokeSolomon().
+ *
+ * @param {Object} args
+ * @param {import("./decisor.js").Decision} args.decision
+ * @param {Object} args.triage
+ * @param {string} args.task
+ * @returns {Object} conflict
+ */
+export function buildRoutingConflict({ decision, triage, task }) {
+  return {
+    task,
+    stage: "brain-routing",
+    reason: decision.solomonReason || "low-confidence routing decision",
+    iterationCount: 0,
+    maxIterations: 1,
+    history: [],
+    summary: `Brain rationale: ${decision.rationale}. Roles on: ${decision.rolesOn.join(", ")}. Confidence: ${decision.confidence}.`,
+    // Extra data Solomon's prompt can introspect via conflict.detail
+    detail: {
+      triageLevel: triage?.level,
+      triageTaskType: triage?.taskType,
+      triageConfidence: triage?.confidence,
+      rolesOn: decision.rolesOn,
+      rolesOff: decision.rolesOff,
+      reason: decision.solomonReason,
+    },
+  };
+}
+
+/**
+ * Invoke Solomon with a routing question and translate its ruling back into
+ * adjustments to the Decision's rolesOn/rolesOff lists.
+ *
+ * If anything goes wrong (Solomon disabled, invocation throws, ruling
+ * malformed), the original decision is returned unchanged with a diagnostic
+ * appended to its rationale.
+ *
+ * @param {Object} args
+ * @param {import("./decisor.js").Decision} args.decision
+ * @param {Object} args.triage
+ * @param {string} args.task
+ * @param {Object} args.config
+ * @param {Object} args.logger
+ * @param {Object} [args.emitter]
+ * @param {Object} [args.eventBase]
+ * @param {Object} [args.session]
+ * @param {Function} [args.askQuestion]
+ * @returns {Promise<import("./decisor.js").Decision>}
+ */
+export async function consultSolomonForRouting({
+  decision,
+  triage,
+  task,
+  config,
+  logger,
+  emitter = null,
+  eventBase = {},
+  session = {},
+  askQuestion = null,
+}) {
+  if (!decision?.consultSolomon) return decision;
+  // Route through the existing infrastructure.
+  let invokeSolomon;
+  try {
+    ({ invokeSolomon } = await import("../orchestrator/solomon-escalation.js"));
+  } catch (err) {
+    logger?.warn?.(`brain/solomon-consult: escalation module unavailable (${err.message})`);
+    return decision;
+  }
+
+  const conflict = buildRoutingConflict({ decision, triage, task });
+
+  let ruling;
+  try {
+    ruling = await invokeSolomon({
+      config,
+      logger,
+      emitter,
+      eventBase,
+      stage: "brain-routing",
+      conflict,
+      askQuestion,
+      session,
+      iteration: 0,
+    });
+  } catch (err) {
+    logger?.warn?.(`brain/solomon-consult: invokeSolomon threw (${err.message}) — keeping baseline`);
+    return {
+      ...decision,
+      rationale: `${decision.rationale} | solomon=failed(${err.message})`,
+    };
+  }
+
+  if (!ruling || typeof ruling !== "object") {
+    return {
+      ...decision,
+      rationale: `${decision.rationale} | solomon=no-ruling`,
+    };
+  }
+
+  return applyRulingToDecision(decision, ruling, logger);
+}
+
+/**
+ * Apply a Solomon ruling to a decision. Known ruling fields Solomon may
+ * return that we understand in routing context:
+ *   - action: "approve" / "continue" / "retry_different_approach" / "escalate"
+ *   - suggestedActions: list of strings that may include "add X" / "remove X"
+ *   - conditions: list of strings
+ *
+ * For routing we only look at suggestedActions (text-based) and parse simple
+ * "add X" / "skip X" / "remove X" hints against the valid role set. Everything
+ * else is logged for the rationale and ignored.
+ */
+export function applyRulingToDecision(decision, ruling, logger) {
+  const rolesOn = new Set(decision.rolesOn);
+  const rolesOff = new Set(decision.rolesOff);
+  const applied = [];
+
+  const suggestions = Array.isArray(ruling.suggestedActions) ? ruling.suggestedActions : [];
+  for (const raw of suggestions) {
+    const action = String(raw || "").toLowerCase();
+    const addMatch = action.match(/\b(?:add|enable|include)\s+(\w+)/);
+    const skipMatch = action.match(/\b(?:skip|disable|remove|drop)\s+(\w+)/);
+    if (addMatch) {
+      const role = addMatch[1];
+      rolesOn.add(role);
+      rolesOff.delete(role);
+      applied.push(`solomon-add:${role}`);
+    } else if (skipMatch) {
+      const role = skipMatch[1];
+      rolesOff.add(role);
+      rolesOn.delete(role);
+      applied.push(`solomon-skip:${role}`);
+    }
+  }
+
+  const ruleVerdict = ruling.action || ruling.verdict || "unknown";
+  logger?.info?.(`brain/solomon-consult: Solomon verdict=${ruleVerdict} applied=[${applied.join(",")}]`);
+
+  return {
+    ...decision,
+    rolesOn: Array.from(rolesOn).sort(),
+    rolesOff: Array.from(rolesOff).sort(),
+    appliedOverrides: [...decision.appliedOverrides, ...applied],
+    confidence: applied.length > 0 ? "high" : decision.confidence,
+    consultSolomon: false,
+    rationale: `${decision.rationale} | solomon=${ruleVerdict}${applied.length ? ` applied=${applied.join(",")}` : ""}`,
+  };
+}

package/src/budget/comparison.js

@@ -0,0 +1,96 @@
+/**
+ * Compute "With KJ" vs "Without KJ" budget comparison.
+ *
+ * Karajan reduces token consumption through two mechanisms:
+ *   1. RTK proxy compression (token-level output compression via the
+ *      Rust Token Killer proxy). Tracked as `rtkSavings.estimatedTokensSaved`.
+ *   2. Brain role-output compression (summarization/trimming of inter-role
+ *      outputs). Tracked in `brainCtx.compressionStats.totalSaved`.
+ *
+ * Given the real billed usage (from BudgetTracker) plus the saved tokens,
+ * this helper projects what usage would have been without KJ's compressions.
+ *
+ * Cost projection uses the blended rate from the real usage:
+ *   withoutKjCost = realCost * (realTokens + savedTokens) / realTokens
+ *
+ * When no compression data is available, `hasCompression` is false and the
+ * caller should render only the real cost (no comparison).
+ */
+
+/**
+ * @typedef {Object} KjComparison
+ * @property {boolean} hasCompression              - whether any savings data exists
+ * @property {{ tokens: number, cost: number }} withKj
+ * @property {{ tokens: number, cost: number }} withoutKj
+ * @property {number} savedTokens                  - total tokens saved
+ * @property {number} savedPct                     - savings as percent of the "without" total (0..100)
+ * @property {{ rtkTokens: number, brainTokens: number }} breakdown
+ */
+
+/**
+ * Compute the comparison from the current budget snapshot and available
+ * compression stats.
+ *
+ * @param {Object} args
+ * @param {number} [args.realTokens]                   - budget tracker total tokens
+ * @param {number} [args.realCost]                     - budget tracker cost in USD
+ * @param {{ estimatedTokensSaved?: number }} [args.rtkSavings]
+ * @param {{ compressionStats?: { totalSaved?: number } } | null} [args.brainCtx]
+ * @returns {KjComparison}
+ */
+export function computeKjComparison({ realTokens = 0, realCost = 0, rtkSavings = null, brainCtx = null } = {}) {
+  const realT = Math.max(0, Number(realTokens) || 0);
+  const realC = Math.max(0, Number(realCost) || 0);
+
+  const rtkTokens = Math.max(0, Number(rtkSavings?.estimatedTokensSaved) || 0);
+  const brainTokens = Math.max(0, Number(brainCtx?.compressionStats?.totalSaved) || 0);
+  const savedTokens = rtkTokens + brainTokens;
+
+  if (savedTokens === 0 || realT === 0) {
+    return {
+      hasCompression: false,
+      withKj: { tokens: realT, cost: realC },
+      withoutKj: { tokens: realT, cost: realC },
+      savedTokens: 0,
+      savedPct: 0,
+      breakdown: { rtkTokens, brainTokens },
+    };
+  }
+
+  const withoutKjTokens = realT + savedTokens;
+  const blendedRate = realC / realT;
+  const withoutKjCost = Number((blendedRate * withoutKjTokens).toFixed(4));
+  const savedPct = Number(((savedTokens / withoutKjTokens) * 100).toFixed(1));
+
+  return {
+    hasCompression: true,
+    withKj: { tokens: realT, cost: Number(realC.toFixed(4)) },
+    withoutKj: { tokens: withoutKjTokens, cost: withoutKjCost },
+    savedTokens,
+    savedPct,
+    breakdown: { rtkTokens, brainTokens },
+  };
+}
+
+/**
+ * Render a one-line comparison string for the CLI display. Returns null
+ * when there's no compression data (so the caller can fall back to the
+ * plain budget line).
+ *
+ * Example outputs:
+ *   "With KJ: $0.06 / 1,287 tokens · Without KJ: ~$1.30 / ~11,324 tokens (-89%)"
+ *
+ * @param {KjComparison} cmp
+ * @returns {string|null}
+ */
+export function formatComparisonLine(cmp) {
+  if (!cmp?.hasCompression) return null;
+  const fmt = (n) => n.toLocaleString("en-US");
+  const tok = (n) => `${fmt(n)} tokens`;
+  const cost = (n) => `$${n.toFixed(2)}`;
+  return [
+    `With KJ: ${cost(cmp.withKj.cost)} / ${tok(cmp.withKj.tokens)}`,
+    `Without KJ: ~${cost(cmp.withoutKj.cost)} / ~${tok(cmp.withoutKj.tokens)}`,
+    `(-${cmp.savedPct.toFixed(0)}%)`,
+  ].join(" · ");
+}

package/src/checks/binaries.js

@@ -0,0 +1,123 @@
+/**
+ * Binary / CLI availability checks.
+ *
+ * Covers:
+ *   - Agent CLIs (claude, codex, gemini, aider, opencode)
+ *   - Core binaries (node, npm, git)
+ *   - Docker
+ *   - Serena MCP (optional)
+ *
+ * All binary checks use `strategy: "manual"` because auto-installing binaries
+ * is invasive and platform-specific. Exception: Serena is `"prompt"` (we know
+ * the install command and can offer to run it).
+ */
+
+import { checkBinary, KNOWN_AGENTS } from "../utils/agent-detect.js";
+import { runCommand } from "../utils/process.js";
+import { withDocLink } from "../utils/doc-links.js";
+import { STRATEGY } from "./types.js";
+
+/**
+ * Check the presence of a named agent CLI (claude/codex/gemini/aider).
+ */
+function createAgentCheck(agent) {
+  return {
+    name: `agent:${agent.name}`,
+    label: `Agent: ${agent.name}`,
+    strategy: STRATEGY.MANUAL,
+    async detect() {
+      const result = await checkBinary(agent.name);
+      return {
+        ok: result.ok,
+        severity: "warn", // missing one agent CLI shouldn't block — user may not use it
+        detail: result.ok ? `${result.version} (${result.path})` : "Not found",
+        fix: result.ok ? undefined : withDocLink(`Install: ${agent.install}`, "agent_not_found"),
+      };
+    },
+  };
+}
+
+/**
+ * Check the presence of a core binary (node, npm, git).
+ */
+function createCoreBinaryCheck(bin) {
+  return {
+    name: bin,
+    label: bin,
+    strategy: STRATEGY.MANUAL,
+    async detect() {
+      const result = await checkBinary(bin);
+      return {
+        ok: result.ok,
+        severity: "fail",
+        detail: result.ok ? result.version : "Not found",
+        fix: result.ok ? undefined : `Install ${bin} from its official website.`,
+      };
+    },
+  };
+}
+
+/**
+ * Docker check. Manual strategy (platform-dependent install).
+ */
+export function createDockerCheck() {
+  return {
+    name: "docker",
+    label: "Docker",
+    strategy: STRATEGY.MANUAL,
+    async detect() {
+      const docker = await checkBinary("docker", "--version");
+      return {
+        ok: docker.ok,
+        severity: "warn", // only required if Sonar enabled; soft-fail here
+        detail: docker.ok ? docker.version : "Not found",
+        fix: docker.ok ? undefined : withDocLink("Install Docker: https://docs.docker.com/get-docker/", "sonar_docker"),
+      };
+    },
+  };
+}
+
+/**
+ * Serena MCP (optional). Prompt strategy: we know how to install it.
+ */
+export function createSerenaCheck() {
+  return {
+    name: "serena",
+    label: "Serena MCP",
+    strategy: STRATEGY.MANUAL,
+    applies: (config) => config.serena?.enabled === true,
+    describe: "Install Serena via: uvx --from git+https://github.com/oraios/serena serena",
+    async detect() {
+      let ok = false;
+      try {
+        const res = await runCommand("serena", ["--version"]);
+        ok = res.exitCode === 0;
+      } catch {
+        ok = false;
+      }
+      return {
+        ok,
+        severity: "warn",
+        detail: ok ? "Available" : "Not found (prompts will still include Serena instructions)",
+        fix: ok ? undefined : "Install Serena: uvx --from git+https://github.com/oraios/serena serena --help",
+      };
+    },
+  };
+}
+
+/**
+ * Aggregate: all binary-related checks for the current config.
+ * @returns {import("./types.js").Check[]}
+ */
+export function getBinaryChecks() {
+  const checks = [];
+  for (const agent of KNOWN_AGENTS) {
+    checks.push(createAgentCheck(agent));
+  }
+  for (const bin of ["node", "npm", "git"]) {
+    checks.push(createCoreBinaryCheck(bin));
+  }
+  checks.push(createDockerCheck());
+  checks.push(createSerenaCheck());
+  return checks;
+}

package/src/checks/ci.js

@@ -0,0 +1,105 @@
+/**
+ * CI infrastructure checks: required workflows, gh CLI, and GitHub secrets.
+ * Only applies when `config.ci.enabled === true`.
+ */
+
+import path from "node:path";
+import { exists } from "../utils/fs.js";
+import { runCommand } from "../utils/process.js";
+import { checkBinary } from "../utils/agent-detect.js";
+import { STRATEGY } from "./types.js";
+
+const REQUIRED_WORKFLOWS = ["kj-ci-gateway.yml", "automerge.yml", "houston-override.yml"];
+
+function ciEnabled(config) {
+  return config.ci?.enabled === true;
+}
+
+function createWorkflowCheck(workflow) {
+  return {
+    name: `ci:workflow:${workflow}`,
+    label: `CI workflow: ${workflow}`,
+    strategy: STRATEGY.MANUAL,
+    applies: ciEnabled,
+    async detect({ config }) {
+      const projectDir = config.projectDir || process.cwd();
+      const wfPath = path.join(projectDir, ".github", "workflows", workflow);
+      const wfExists = await exists(wfPath);
+      return {
+        ok: wfExists,
+        severity: "fail",
+        detail: wfExists ? "Found" : "Not found",
+        fix: wfExists
+          ? undefined
+          : `Run 'kj init --scaffold-ci' or copy from karajan-code/templates/workflows/${workflow}`,
+      };
+    },
+  };
+}
+
+export function createGhCliCheck() {
+  return {
+    name: "ci:gh",
+    label: "CI: gh CLI",
+    strategy: STRATEGY.MANUAL,
+    applies: ciEnabled,
+    async detect() {
+      const gh = await checkBinary("gh");
+      return {
+        ok: gh.ok,
+        severity: "fail",
+        detail: gh.ok ? gh.version : "Not found",
+        fix: gh.ok ? undefined : "Install GitHub CLI: https://cli.github.com/",
+      };
+    },
+  };
+}
+
+export function createGhSecretsCheck() {
+  return {
+    name: "ci:secrets",
+    label: "CI: GitHub secrets",
+    strategy: STRATEGY.MANUAL,
+    applies: ciEnabled,
+    async detect() {
+      try {
+        const { detectRepo } = await import("../ci/repo.js");
+        const repo = await detectRepo();
+        if (!repo) {
+          return { ok: true, severity: "info", detail: "No GitHub repo detected (skipped)" };
+        }
+        const res = await runCommand("gh", ["api", `repos/${repo}/actions/secrets`, "--jq", ".secrets[].name"]);
+        if (res.exitCode !== 0) {
+          return { ok: true, severity: "info", detail: "Cannot query secrets (gh unauthenticated?)" };
+        }
+        const names = new Set(res.stdout.split("\n").map((s) => s.trim()));
+        const hasAppId = names.has("KJ_CI_APP_ID");
+        const hasKey = names.has("KJ_CI_PRIVATE_KEY");
+        const secretsOk = hasAppId && hasKey;
+        const missing = [!hasAppId && "KJ_CI_APP_ID", !hasKey && "KJ_CI_PRIVATE_KEY"].filter(Boolean).join(" ");
+        return {
+          ok: secretsOk,
+          severity: "fail",
+          detail: secretsOk ? "KJ_CI_APP_ID + KJ_CI_PRIVATE_KEY found" : `Missing: ${missing}`,
+          fix: secretsOk ? undefined : "Add KJ_CI_APP_ID and KJ_CI_PRIVATE_KEY as GitHub repository secrets",
+        };
+      } catch {
+        return { ok: true, severity: "info", detail: "Cannot check secrets (unexpected error, skipped)" };
+      }
+    },
+  };
+}
+
+/**
+ * Aggregate of CI checks. Each check carries its own `applies` so the runner
+ * marks them SKIPPED when CI is disabled.
+ */
+export function getCiChecks() {
+  const checks = [];
+  for (const wf of REQUIRED_WORKFLOWS) {
+    checks.push(createWorkflowCheck(wf));
+  }
+  checks.push(createGhCliCheck());
+  checks.push(createGhSecretsCheck());
+  return checks;
+}

package/src/checks/config-files.js

@@ -0,0 +1,217 @@
+/**
+ * Config and rule-file checks.
+ *
+ * Covers:
+ *   - kj.config.yml existence (strategy: prompt — offer to run kj init)
+ *   - Review / coder rules discovery (strategy: none, informational)
+ *   - Agent config files: ~/.claude.json, ~/.codex/config.toml,
+ *     ~/.karajan/kj.config.yml (strategy: manual — structural fixes needed)
+ */
+
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { exists } from "../utils/fs.js";
+import { getConfigPath } from "../config.js";
+import { resolveRoleMdPath, loadFirstExisting } from "../roles/base-role.js";
+import { withDocLink } from "../utils/doc-links.js";
+import { STRATEGY } from "./types.js";
+
+/**
+ * kj.config.yml presence check.
+ */
+export function createConfigFileCheck() {
+  return {
+    name: "config",
+    label: "Config file",
+    strategy: STRATEGY.PROMPT,
+    describe: "Run 'kj init' to scaffold a default kj.config.yml",
+    async detect() {
+      const configPath = getConfigPath();
+      const configExists = await exists(configPath);
+      return {
+        ok: configExists,
+        severity: "fail",
+        detail: configExists ? configPath : "Not found",
+        fix: configExists ? undefined : withDocLink("Run 'kj init' to create the config file.", "config_missing"),
+      };
+    },
+  };
+}
+
+/**
+ * Review rules (.md) informational check.
+ */
+export function createReviewRulesCheck() {
+  return {
+    name: "review-rules",
+    label: "Reviewer rules (.md)",
+    strategy: STRATEGY.NONE,
+    async detect({ config }) {
+      const projectDir = config.projectDir || process.cwd();
+      const paths = resolveRoleMdPath("reviewer", projectDir);
+      const rules = await loadFirstExisting(paths);
+      return {
+        ok: true,
+        severity: "info",
+        detail: rules ? "Found" : "Not found (will use defaults)",
+      };
+    },
+  };
+}
+
+/**
+ * Coder rules (.md) informational check.
+ */
+export function createCoderRulesCheck() {
+  return {
+    name: "coder-rules",
+    label: "Coder rules (.md)",
+    strategy: STRATEGY.NONE,
+    async detect({ config }) {
+      const projectDir = config.projectDir || process.cwd();
+      const paths = resolveRoleMdPath("coder", projectDir);
+      const rules = await loadFirstExisting(paths);
+      return {
+        ok: true,
+        severity: "info",
+        detail: rules ? "Found" : "Not found (will use defaults)",
+      };
+    },
+  };
+}
+
+/**
+ * Detect duplicate TOML table headers (e.g. [mcp_servers."karajan-mcp"] twice).
+ */
+function findDuplicateTomlKeys(content) {
+  const tableHeaders = [];
+  const duplicates = [];
+  for (const line of content.split("\n")) {
+    const match = line.match(/^\s*\[([^\]]+)\]\s*$/);
+    if (match) {
+      const key = match[1].trim();
+      if (tableHeaders.includes(key)) {
+        duplicates.push(key);
+      } else {
+        tableHeaders.push(key);
+      }
+    }
+  }
+  return duplicates;
+}
+
+/**
+ * Claude config (~/.claude.json) validity.
+ */
+export function createClaudeConfigCheck() {
+  return {
+    name: "agent-config:claude",
+    label: "Agent config: claude (~/.claude.json)",
+    strategy: STRATEGY.MANUAL,
+    async detect() {
+      const home = os.homedir();
+      const claudeJsonPath = path.join(home, ".claude.json");
+      try {
+        const raw = await fs.readFile(claudeJsonPath, "utf8");
+        JSON.parse(raw);
+        return { ok: true, severity: "info", detail: "Valid JSON" };
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          // Not configured: Claude may not be in use. Informational skip.
+          return { ok: true, severity: "info", detail: "Not present (skipped)" };
+        }
+        return {
+          ok: false,
+          severity: "warn",
+          detail: `Invalid JSON: ${err.message.split("\n")[0]}`,
+          fix: "Fix the JSON syntax in ~/.claude.json. Common issues: trailing commas, missing quotes.",
+        };
+      }
+    },
+  };
+}
+
+/**
+ * Codex config (~/.codex/config.toml) validity.
+ */
+export function createCodexConfigCheck() {
+  return {
+    name: "agent-config:codex",
+    label: "Agent config: codex (~/.codex/config.toml)",
+    strategy: STRATEGY.MANUAL,
+    async detect() {
+      const home = os.homedir();
+      const codexTomlPath = path.join(home, ".codex", "config.toml");
+      try {
+        const raw = await fs.readFile(codexTomlPath, "utf8");
+        const duplicates = findDuplicateTomlKeys(raw);
+        if (duplicates.length > 0) {
+          return {
+            ok: false,
+            severity: "warn",
+            detail: `Duplicate TOML keys: ${duplicates.join(", ")}`,
+            fix: `Remove duplicate entries in ~/.codex/config.toml: ${duplicates.join(", ")}`,
+          };
+        }
+        return { ok: true, severity: "info", detail: "Valid TOML (no duplicate keys)" };
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          return { ok: true, severity: "info", detail: "Not present (skipped)" };
+        }
+        return {
+          ok: false,
+          severity: "warn",
+          detail: `Cannot read: ${err.message.split("\n")[0]}`,
+          fix: "Check file permissions on ~/.codex/config.toml",
+        };
+      }
+    },
+  };
+}
+
+/**
+ * KJ config (~/.karajan/kj.config.yml) YAML validity (separate from existence).
+ */
+export function createKjConfigYamlCheck() {
+  return {
+    name: "agent-config:karajan",
+    label: "Agent config: karajan (kj.config.yml)",
+    strategy: STRATEGY.MANUAL,
+    async detect() {
+      const kjConfigPath = getConfigPath();
+      try {
+        const raw = await fs.readFile(kjConfigPath, "utf8");
+        const yaml = await import("js-yaml");
+        yaml.default.load(raw);
+        return { ok: true, severity: "info", detail: "Valid YAML" };
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          // Covered by createConfigFileCheck — don't duplicate the failure
+          return { ok: true, severity: "info", detail: "Not present (covered by config check)" };
+        }
+        return {
+          ok: false,
+          severity: "fail",
+          detail: `Invalid YAML: ${err.message.split("\n")[0]}`,
+          fix: `Fix YAML syntax in ${kjConfigPath}. Run 'kj init' to regenerate if needed.`,
+        };
+      }
+    },
+  };
+}
+
+/**
+ * Aggregate: all config-file-related checks.
+ * @returns {import("./types.js").Check[]}
+ */
+export function getConfigFileChecks() {
+  return [
+    createConfigFileCheck(),
+    createReviewRulesCheck(),
+    createCoderRulesCheck(),
+    createClaudeConfigCheck(),
+    createCodexConfigCheck(),
+    createKjConfigYamlCheck(),
+  ];
+}