karajan-code 2.7.4 → 2.9.0

package/src/canvas/parse-md.js

@@ -0,0 +1,238 @@
+/**
+ * REASONS Canvas markdown parser.
+ *
+ * Reads a `SPEC.canvas.md` file and returns a Canvas object that
+ * validates against canvas/schema.js.
+ *
+ * Format:
+ *
+ *   # <title>
+ *
+ *   ## REASONS:Requirements
+ *   <problem statement, free text>
+ *
+ *   Definition of done:
+ *   - bullet 1
+ *   - bullet 2
+ *
+ *   ## REASONS:Entities
+ *   - `User` — fields: id, email. has-many Order.
+ *   - `Order` — ...
+ *
+ *   ## REASONS:Approach
+ *   <free text>
+ *
+ *   ## REASONS:Structure
+ *   - touches: src/auth/*, src/orders/*
+ *   - depends_on: TokenService
+ *   - contracts: POST /orders, GET /orders/:id
+ *
+ *   ## REASONS:Operations
+ *   1. <title>
+ *      Acceptance:
+ *      - shell: `cmd here`
+ *      - gherkin: ```Given … When … Then …```
+ *   2. ...
+ *
+ *   ## REASONS:Norms
+ *   - bullet
+ *
+ *   ## REASONS:Safeguards
+ *   - bullet
+ *
+ * Permissive on whitespace and bullet style ("- ", "* ", "1. ").
+ * Strict on structure: a missing required section ⇒ exception with a
+ * pointer to which section is missing.
+ */
+
+const SECTION_HEADER_RE = /^##\s+REASONS:(\w+)\s*$/i;
+const TITLE_RE = /^#\s+(.+?)\s*$/;
+const BULLET_RE = /^\s*(?:[-*]|\d+\.)\s+(.+?)\s*$/;
+const ACCEPTANCE_HEADER_RE = /^\s*Acceptance(?:\s+tests?)?\s*:\s*$/i;
+const TEST_LINE_RE = /^\s*(?:[-*])\s+(shell|gherkin)\s*:\s*(.+?)\s*$/i;
+
+/**
+ * Parse a SPEC.canvas.md string into a Canvas object.
+ * Throws { name: "CanvasParseError", message } on missing required sections.
+ *
+ * @param {string} source — markdown text
+ * @returns {object} Canvas object (un-validated against schema; caller validates)
+ */
+export function parseCanvasMarkdown(source) {
+  if (typeof source !== "string" || source.length === 0) {
+    throw makeError("Canvas markdown is empty or not a string.");
+  }
+
+  const lines = source.split(/\r?\n/);
+  const sections = {};
+  let title = null;
+  let currentName = null;
+  let currentBuf = [];
+
+  // First pass: split into sections.
+  for (const line of lines) {
+    const titleMatch = line.match(TITLE_RE);
+    if (titleMatch && currentName === null && title === null) {
+      title = titleMatch[1].trim();
+      continue;
+    }
+    const sectionMatch = line.match(SECTION_HEADER_RE);
+    if (sectionMatch) {
+      // flush previous
+      if (currentName) {
+        sections[currentName] = currentBuf.join("\n");
+      }
+      currentName = sectionMatch[1].toLowerCase();
+      currentBuf = [];
+      continue;
+    }
+    if (currentName) currentBuf.push(line);
+  }
+  if (currentName) sections[currentName] = currentBuf.join("\n");
+
+  if (!title) throw makeError("Missing title — first line must be `# <title>`.");
+
+  // Required sections — must be PRESENT (header exists), but content
+  // may be empty for sections like Structure where every key is
+  // optional. Use `in` so an empty-body section is accepted.
+  for (const required of ["requirements", "approach", "structure", "operations"]) {
+    if (!(required in sections)) {
+      throw makeError(`Missing required section: ## REASONS:${capitalize(required)}`);
+    }
+  }
+
+  return {
+    title,
+    requirements: parseRequirements(sections.requirements),
+    entities: sections.entities ? parseEntities(sections.entities) : [],
+    approach: sections.approach.trim(),
+    structure: parseStructure(sections.structure),
+    operations: parseOperations(sections.operations),
+    norms: sections.norms ? parseBullets(sections.norms) : [],
+    safeguards: sections.safeguards ? parseBullets(sections.safeguards) : [],
+  };
+}
+
+function capitalize(s) {
+  return s.length > 0 ? s[0].toUpperCase() + s.slice(1) : s;
+}
+
+function makeError(msg) {
+  const e = new Error(msg);
+  e.name = "CanvasParseError";
+  return e;
+}
+
+/**
+ * Requirements: a paragraph (problem) + optional "Definition of done:" bullets.
+ */
+function parseRequirements(text) {
+  const lines = text.split("\n");
+  const problemLines = [];
+  const done = [];
+  let inDone = false;
+  for (const line of lines) {
+    if (/^\s*Definition of done:?\s*$/i.test(line)) { inDone = true; continue; }
+    if (inDone) {
+      const m = line.match(BULLET_RE);
+      if (m) done.push(m[1].trim());
+      continue;
+    }
+    if (line.trim()) problemLines.push(line.trim());
+  }
+  const problem = problemLines.join(" ").trim();
+  if (!problem) throw makeError("REASONS:Requirements is empty or has no problem statement.");
+  return { problem, done };
+}
+
+/**
+ * Entities: each bullet is "Name — fields: f1, f2. notes." (loose).
+ * We parse the first word as the entity name and capture the rest as notes.
+ */
+function parseEntities(text) {
+  const out = [];
+  for (const raw of text.split("\n")) {
+    const m = raw.match(BULLET_RE);
+    if (!m) continue;
+    const body = m[1].trim();
+    // First token (possibly `quoted`) is the name; rest is notes.
+    const nameMatch = body.match(/^[`"']?([A-Za-z][\w-]*)[`"']?\s*[—-]?\s*(.*)$/);
+    if (!nameMatch) continue;
+    const [, name, rest] = nameMatch;
+    const fields = [];
+    const fm = rest.match(/fields?:\s*([^.]+)/i);
+    if (fm) fields.push(...fm[1].split(",").map((s) => s.trim()).filter(Boolean));
+    out.push({ name, fields, notes: rest });
+  }
+  return out;
+}
+
+function parseStructure(text) {
+  const out = { touches: [], depends_on: [], contracts: [] };
+  for (const raw of text.split("\n")) {
+    const m = raw.match(BULLET_RE);
+    if (!m) continue;
+    const body = m[1].trim();
+    const kvMatch = body.match(/^(touches|depends_on|contracts)\s*:\s*(.+)$/i);
+    if (!kvMatch) continue;
+    const key = kvMatch[1].toLowerCase();
+    const values = kvMatch[2].split(",").map((s) => s.trim()).filter(Boolean);
+    out[key] = values;
+  }
+  return out;
+}
+
+function parseBullets(text) {
+  const out = [];
+  for (const raw of text.split("\n")) {
+    const m = raw.match(BULLET_RE);
+    if (m) out.push(m[1].trim());
+  }
+  return out;
+}
+
+/**
+ * Operations: each top-level numbered/bulleted entry is one Operation.
+ * Inside, an "Acceptance:" sub-line introduces nested bullets where each
+ * bullet is "shell: <cmd>" or "gherkin: <scenario>".
+ */
+function parseOperations(text) {
+  const ops = [];
+  const lines = text.split("\n");
+  let current = null;
+  let inAcceptance = false;
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    // Top-level operation: numbered list or single dash at left margin.
+    const topMatch = line.match(/^(\d+\.\s+|[-*]\s+)(.+)$/);
+    if (topMatch && !line.startsWith("    ") && !line.startsWith("\t")) {
+      if (current) ops.push(current);
+      current = { title: topMatch[2].trim(), acceptance: [] };
+      inAcceptance = false;
+      continue;
+    }
+    if (current) {
+      if (ACCEPTANCE_HEADER_RE.test(line)) { inAcceptance = true; continue; }
+      const testMatch = line.match(TEST_LINE_RE);
+      if (testMatch && inAcceptance) {
+        current.acceptance.push({
+          type: testMatch[1].toLowerCase(),
+          content: testMatch[2].replace(/^`+|`+$/g, "").trim(),
+        });
+      }
+    }
+  }
+  if (current) ops.push(current);
+
+  if (ops.length === 0) {
+    throw makeError("REASONS:Operations has no operations. Each operation must be a numbered or bulleted item with at least one acceptance test.");
+  }
+  for (const op of ops) {
+    if (op.acceptance.length === 0) {
+      throw makeError(`Operation "${op.title}" has no acceptance tests. Add at least one ` +
+        '`- shell: <cmd>` or `- gherkin: <scenario>` under an "Acceptance:" line.');
+    }
+  }
+  return ops;
+}

package/src/canvas/schema.js

@@ -0,0 +1,101 @@
+/**
+ * REASONS Canvas — Valibot schema for the structured SPEC format.
+ *
+ * Issue #539. Per Martin Fowler's Structured Prompt-Driven Development
+ * (https://martinfowler.com/articles/structured-prompt-driven/), a
+ * Canvas captures intent in 7 named sections so the planner doesn't
+ * have to improvise. The shape:
+ *
+ *   Requirements — problem + done-when bullets
+ *   Entities     — domain nouns + relationships
+ *   Approach     — strategy + trade-offs
+ *   Structure    — system fit, dependencies, contracts
+ *   Operations   — concrete numbered steps. Each = one HU.
+ *   Norms        — task-level engineering standards
+ *   Safeguards   — non-negotiables: invariants, perf, security
+ *
+ * Operations carry their acceptance tests inline so the planner-time
+ * validator (validate.js) can check them parse BEFORE any LLM call.
+ * That's the bug-class fix this whole feature exists for: the
+ * 2026-04-29 incident where the planner emitted a syntactically-broken
+ * jq query and the coder iterated 3× against an irreparable test.
+ */
+
+import * as v from "valibot";
+
+const NonEmptyString = v.pipe(v.string(), v.minLength(1));
+
+const Entity = v.looseObject({
+  name: NonEmptyString,
+  fields: v.optional(v.array(v.string())),
+  relationships: v.optional(v.array(v.unknown())),
+  notes: v.optional(v.string()),
+});
+
+const AcceptanceTest = v.looseObject({
+  type: v.picklist(["shell", "gherkin"]),
+  content: NonEmptyString,
+  // optional: file hint for tester translation of gherkin
+  file: v.optional(v.string()),
+});
+
+const Operation = v.looseObject({
+  // Either a free-form title or numbered step text.
+  title: NonEmptyString,
+  // Optional: the file or module the operation produces / touches.
+  file_hint: v.optional(v.string()),
+  // Optional: dependencies on other operation titles or HU ids.
+  blocked_by: v.optional(v.array(v.string())),
+  // Required: at least ONE acceptance test per operation. Empty array
+  // is rejected at plan-time so we never ship an HU without a contract.
+  acceptance: v.pipe(v.array(AcceptanceTest), v.minLength(1)),
+});
+
+const CanvasSchema = v.looseObject({
+  // Title is the project / feature name. The planner uses it as the
+  // plan name unless the user overrides on prompt.
+  title: NonEmptyString,
+  requirements: v.looseObject({
+    problem: NonEmptyString,
+    // Definition-of-done bullets. Empty array allowed — sometimes the
+    // problem statement IS the contract — but a non-empty array
+    // discourages woolly specs.
+    done: v.optional(v.array(NonEmptyString)),
+  }),
+  entities: v.optional(v.array(Entity)),
+  approach: NonEmptyString,
+  structure: v.looseObject({
+    touches: v.optional(v.array(v.string())),
+    depends_on: v.optional(v.array(v.string())),
+    contracts: v.optional(v.array(v.string())),
+  }),
+  operations: v.pipe(v.array(Operation), v.minLength(1)),
+  norms: v.optional(v.array(NonEmptyString)),
+  safeguards: v.optional(v.array(NonEmptyString)),
+});
+
+/**
+ * Validate-only entry point. Throws an Error with the offending path
+ * + message when the canvas doesn't match the schema. The validator
+ * (validate.js) uses this AND adds parse-checks for acceptance tests.
+ *
+ * @param {unknown} canvas
+ * @returns {import("valibot").InferOutput<typeof CanvasSchema>}
+ */
+export function parseCanvas(canvas) {
+  return v.parse(CanvasSchema, canvas);
+}
+
+/**
+ * Soft check: returns the validation result without throwing. Useful
+ * for surfacing every schema error at once instead of bailing on the
+ * first.
+ *
+ * @param {unknown} canvas
+ * @returns {{ success: true, output: object } | { success: false, issues: object[] }}
+ */
+export function safeParseCanvas(canvas) {
+  const r = v.safeParse(CanvasSchema, canvas);
+  if (r.success) return { success: true, output: r.output };
+  return { success: false, issues: r.issues };
+}

package/src/canvas/to-flat.js

@@ -0,0 +1,85 @@
+/**
+ * Canvas → flat task string adapter.
+ *
+ * Renders a validated Canvas object as a single markdown blob the
+ * existing planner can consume verbatim. Preserves every section
+ * with its original heading so downstream steps (planner prompt,
+ * coder prompt, plan JSON `task` field) see the same shape.
+ *
+ * The point: Canvas users get planner-time validation (catching
+ * broken acceptance tests before they're persisted) AND benefit from
+ * every existing planner / coder pipeline without those pipelines
+ * needing Canvas awareness. Norms + Safeguards explicitly bracketed
+ * so prompts that scan for them can find them with a regex.
+ */
+
+/**
+ * @param {object} canvas — output of validateCanvas (.canvas)
+ * @returns {string} markdown task ready for the planner
+ */
+export function canvasToTask(canvas) {
+  const lines = [`# ${canvas.title}`, ""];
+
+  // Requirements
+  lines.push("## Requirements", canvas.requirements.problem);
+  if (canvas.requirements.done && canvas.requirements.done.length > 0) {
+    lines.push("", "Definition of done:");
+    for (const d of canvas.requirements.done) lines.push(`- ${d}`);
+  }
+  lines.push("");
+
+  // Entities (optional)
+  if (canvas.entities && canvas.entities.length > 0) {
+    lines.push("## Entities");
+    for (const e of canvas.entities) {
+      const fields = e.fields && e.fields.length > 0 ? ` — fields: ${e.fields.join(", ")}` : "";
+      lines.push(`- ${e.name}${fields}${e.notes ? `. ${e.notes}` : ""}`);
+    }
+    lines.push("");
+  }
+
+  // Approach
+  lines.push("## Approach", canvas.approach, "");
+
+  // Structure (optional content)
+  lines.push("## Structure");
+  if (canvas.structure?.touches?.length > 0) lines.push(`- touches: ${canvas.structure.touches.join(", ")}`);
+  if (canvas.structure?.depends_on?.length > 0) lines.push(`- depends_on: ${canvas.structure.depends_on.join(", ")}`);
+  if (canvas.structure?.contracts?.length > 0) lines.push(`- contracts: ${canvas.structure.contracts.join(", ")}`);
+  lines.push("");
+
+  // Operations — each becomes one HU. Acceptance tests inline so the
+  // planner sees the contract from turn 1.
+  lines.push("## Operations");
+  canvas.operations.forEach((op, i) => {
+    lines.push(`${i + 1}. ${op.title}`);
+    if (op.file_hint) lines.push(`   file: ${op.file_hint}`);
+    if (op.blocked_by && op.blocked_by.length > 0) lines.push(`   depends on: ${op.blocked_by.join(", ")}`);
+    lines.push("   Acceptance:");
+    for (const t of op.acceptance) {
+      // Render shell as one-liner, gherkin as fenced block so newlines survive.
+      if (t.type === "gherkin") {
+        lines.push("   - gherkin:", "     ```gherkin", ...t.content.split("\n").map((l) => `     ${l}`), "     ```");
+      } else {
+        lines.push(`   - shell: \`${t.content}\``);
+      }
+    }
+  });
+  lines.push("");
+
+  // Norms (optional) — bracketed so prompts can find them.
+  if (canvas.norms && canvas.norms.length > 0) {
+    lines.push("## Norms (per-task engineering standards — coder MUST follow)");
+    for (const n of canvas.norms) lines.push(`- ${n}`);
+    lines.push("");
+  }
+
+  // Safeguards (optional) — bracketed similarly.
+  if (canvas.safeguards && canvas.safeguards.length > 0) {
+    lines.push("## Safeguards (non-negotiable invariants — code MUST hold these)");
+    for (const s of canvas.safeguards) lines.push(`- ${s}`);
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}

package/src/canvas/validate.js

@@ -0,0 +1,163 @@
+/**
+ * REASONS Canvas validator.
+ *
+ * Schema validation + planner-time sanity checks for acceptance tests.
+ * The schema is enforced via Valibot in canvas/schema.js. This module
+ * adds the bug-class fix: parse-check every shell acceptance test
+ * BEFORE it gets persisted into a plan and BEFORE any LLM is called.
+ *
+ * Catches the 2026-04-29 incident class:
+ *   `length as $n | .filesOver300LOC == $n` → exits non-zero with a
+ *   descriptive error pointing at the offending operation + test
+ *   index, BEFORE the user has paid for any agent run.
+ */
+
+import { spawnSync } from "node:child_process";
+import { safeParseCanvas } from "./schema.js";
+
+/**
+ * Run a single shell acceptance test through `bash -n` (parse-only,
+ * doesn't execute) to catch shell-level syntax errors. Then, if the
+ * test invokes `jq`, also probe the jq query through `jq -n <query>`
+ * with empty input — jq errors there iff the query has bad syntax.
+ *
+ * Trade-off accepted: bash -n won't catch every command-substitution
+ * pitfall (it parses but doesn't expand), and jq -n with empty input
+ * may pass queries that fail at runtime against real input. The point
+ * is to catch the OBVIOUS bugs cheaply, not to be airtight.
+ *
+ * @param {string} cmd
+ * @returns {{ ok: true } | { ok: false, kind: string, error: string }}
+ */
+export function validateShellTest(cmd) {
+  if (typeof cmd !== "string" || cmd.trim().length === 0) {
+    return { ok: false, kind: "empty", error: "shell test is empty" };
+  }
+
+  // Layer 1: bash -n parse-check on the whole command.
+  const bash = spawnSync("bash", ["-n", "-c", cmd], { encoding: "utf8", timeout: 5000 });
+  if (bash.status !== 0) {
+    const err = (bash.stderr || "").trim() || "bash -n rejected the command";
+    return { ok: false, kind: "shell-syntax", error: err };
+  }
+
+  // Layer 2: every `jq '...'` invocation gets its query parse-checked.
+  // Permissive regex: catches `jq -e 'X'`, `jq "X"`, `| jq 'X'`. False
+  // negatives are fine — better to skip a real jq than misinterpret a
+  // shell-quoting edge case.
+  //
+  // We distinguish COMPILE errors (the bug we want to catch — invalid
+  // syntax, e.g. `length as $n | .field` over an array) from RUNTIME
+  // errors (the query is well-formed but fails on null input from
+  // `-n`, like `.foo[]` on null). Only compile errors fail validation;
+  // runtime errors against synthetic input are expected because real
+  // input isn't available at plan-time.
+  const jqRe = /\bjq\b\s+(?:-[a-zA-Z]+\s+)*(?:'([^']+)'|"([^"]+)")/g;
+  for (const m of cmd.matchAll(jqRe)) {
+    const query = m[1] || m[2];
+    if (!query) continue;
+
+    // Static pattern detector for the 2026-04-29 as-binding misuse:
+    // `[expr] | length as $X | .field` and similar. The `as $X`
+    // binds the value to a name but does NOT change the value
+    // flowing through the pipe. The next `.field` is therefore
+    // applied to the array tail (or whatever the previous stage
+    // returned), not to the original root. Always wrong.
+    //
+    // Detection: a pipeline whose tail is `length as $X | .X` (or
+    // any `<terminal-operator> as $X | .field`) is the smell.
+    const asBindingMisuse = /\b(?:length|keys|values|min|max|add|first|last)\s+as\s+\$[A-Za-z_][\w]*\s*\|\s*\.[A-Za-z_]/;
+    if (asBindingMisuse.test(query)) {
+      return {
+        ok: false,
+        kind: "jq-syntax",
+        error: "Likely as-binding misuse: `length as $n | .field` does not change the value flowing through; `.field` is applied to the previous stage's output, not the root. Use `. as $r | <transform> | $r.field` instead.",
+      };
+    }
+
+    const jq = spawnSync("jq", ["-n", query], { encoding: "utf8", timeout: 5000 });
+    if (jq.status !== 0) {
+      const err = (jq.stderr || "").trim() || "jq rejected the query";
+      // jq distinguishes compile errors with these tokens. Anything
+      // else (e.g. "Cannot index null with string") is a runtime error
+      // against the empty input, NOT a syntax bug.
+      const isCompileError = /\b(compile error|syntax error|unexpected|jq: error \(at <stdin>:\d+\): ?$)/i.test(err);
+      if (isCompileError) {
+        return { ok: false, kind: "jq-syntax", error: err };
+      }
+      // Special case: `length as $n | .field` returns "Cannot index
+      // array/number/string with string" on -n input because the as-
+      // binding misuse means `.field` is applied to the wrong thing.
+      // This is exactly the 2026-04-29 bug class. Treat it as syntax-
+      // adjacent: the query is "compilable" but semantically broken
+      // by misuse of as-binding.
+      if (/Cannot index (array|number|string) with string/i.test(err)) {
+        return { ok: false, kind: "jq-syntax", error: err };
+      }
+      // Otherwise let it pass — runtime error against synthetic input
+      // is fine. jq parsed the query successfully.
+    }
+  }
+
+  return { ok: true };
+}
+
+/**
+ * Validate every operation's acceptance tests in a parsed Canvas.
+ * Returns an array of issues; empty array means everything passed.
+ *
+ * @param {object} canvas
+ * @returns {Array<{ operationIndex: number, operationTitle: string, testIndex: number, type: string, content: string, kind: string, error: string }>}
+ */
+export function validateAcceptanceTests(canvas) {
+  const issues = [];
+  if (!canvas || !Array.isArray(canvas.operations)) return issues;
+  canvas.operations.forEach((op, opIdx) => {
+    (op.acceptance || []).forEach((t, tIdx) => {
+      if (t.type === "shell") {
+        const r = validateShellTest(t.content);
+        if (!r.ok) {
+          issues.push({
+            operationIndex: opIdx,
+            operationTitle: op.title,
+            testIndex: tIdx,
+            type: t.type,
+            content: t.content,
+            kind: r.kind,
+            error: r.error,
+          });
+        }
+      } else if (t.type === "gherkin") {
+        // Minimal gherkin sanity: must contain at least one Given AND
+        // one Then. When/And/But are optional. This catches "blank
+        // gherkin" without trying to parse the language.
+        if (!/\bGiven\b/i.test(t.content) || !/\bThen\b/i.test(t.content)) {
+          issues.push({
+            operationIndex: opIdx,
+            operationTitle: op.title,
+            testIndex: tIdx,
+            type: t.type,
+            content: t.content,
+            kind: "gherkin-incomplete",
+            error: "Gherkin scenario must contain at least one Given and one Then.",
+          });
+        }
+      }
+    });
+  });
+  return issues;
+}
+
+/**
+ * Top-level validator. Runs schema + acceptance-test parse-checks.
+ *
+ * @param {unknown} canvas
+ * @returns {{ valid: true, canvas: object } | { valid: false, schemaIssues?: object[], testIssues?: object[] }}
+ */
+export function validateCanvas(canvas) {
+  const schema = safeParseCanvas(canvas);
+  if (!schema.success) return { valid: false, schemaIssues: schema.issues };
+  const testIssues = validateAcceptanceTests(schema.output);
+  if (testIssues.length > 0) return { valid: false, testIssues };
+  return { valid: true, canvas: schema.output };
+}

package/src/checks/binaries.js

@@ -60,7 +60,7 @@ function createCoreBinaryCheck(bin) {
 /**
  * Docker check. Manual strategy (platform-dependent install).
  */
-export function createDockerCheck() {
+function createDockerCheck() {
   return {
     name: "docker",
     label: "Docker",
@@ -80,7 +80,7 @@ export function createDockerCheck() {
 /**
  * Serena MCP (optional). Prompt strategy: we know how to install it.
  */
-export function createSerenaCheck() {
+function createSerenaCheck() {
   return {
     name: "serena",
     label: "Serena MCP",
@@ -88,7 +88,7 @@ export function createSerenaCheck() {
     applies: (config) => config.serena?.enabled === true,
     describe: "Install Serena via: uvx --from git+https://github.com/oraios/serena serena",
     async detect() {
-      let ok = false;
+      let ok;
       try {
         const res = await runCommand("serena", ["--version"]);
         ok = res.exitCode === 0;

package/src/checks/ci.js

@@ -37,7 +37,7 @@ function createWorkflowCheck(workflow) {
   };
 }
 
-export function createGhCliCheck() {
+function createGhCliCheck() {
   return {
     name: "ci:gh",
     label: "CI: gh CLI",
@@ -55,7 +55,7 @@ export function createGhCliCheck() {
   };
 }
 
-export function createGhSecretsCheck() {
+function createGhSecretsCheck() {
   return {
     name: "ci:secrets",
     label: "CI: GitHub secrets",

package/src/checks/config-files.js

@@ -20,7 +20,7 @@ import { STRATEGY } from "./types.js";
 /**
  * kj.config.yml presence check.
  */
-export function createConfigFileCheck() {
+function createConfigFileCheck() {
   return {
     name: "config",
     label: "Config file",
@@ -42,7 +42,7 @@ export function createConfigFileCheck() {
 /**
  * Review rules (.md) informational check.
  */
-export function createReviewRulesCheck() {
+function createReviewRulesCheck() {
   return {
     name: "review-rules",
     label: "Reviewer rules (.md)",
@@ -63,7 +63,7 @@ export function createReviewRulesCheck() {
 /**
  * Coder rules (.md) informational check.
  */
-export function createCoderRulesCheck() {
+function createCoderRulesCheck() {
   return {
     name: "coder-rules",
     label: "Coder rules (.md)",
@@ -104,7 +104,7 @@ function findDuplicateTomlKeys(content) {
 /**
  * Claude config (~/.claude.json) validity.
  */
-export function createClaudeConfigCheck() {
+function createClaudeConfigCheck() {
   return {
     name: "agent-config:claude",
     label: "Agent config: claude (~/.claude.json)",
@@ -135,7 +135,7 @@ export function createClaudeConfigCheck() {
 /**
  * Codex config (~/.codex/config.toml) validity.
  */
-export function createCodexConfigCheck() {
+function createCodexConfigCheck() {
   return {
     name: "agent-config:codex",
     label: "Agent config: codex (~/.codex/config.toml)",
@@ -173,7 +173,7 @@ export function createCodexConfigCheck() {
 /**
  * KJ config (~/.karajan/kj.config.yml) YAML validity (separate from existence).
  */
-export function createKjConfigYamlCheck() {
+function createKjConfigYamlCheck() {
   return {
     name: "agent-config:karajan",
     label: "Agent config: karajan (kj.config.yml)",