karajan-code 4.70.4 → 5.0.1

package/src/canvas/parse-md.js

@@ -1,238 +0,0 @@
-/**
- * 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].replaceAll(/^`+|`+$/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

@@ -1,101 +0,0 @@
-/**
- * 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

@@ -1,85 +0,0 @@
-/**
- * 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

@@ -1,163 +0,0 @@
-/**
- * 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/ci/dispatch.js

@@ -1,99 +0,0 @@
-/**
- * Karajan CI dispatch client — sends repository_dispatch events via gh CLI
- * so the Karajan CI Gateway can publish comments and reviews on PRs.
- *
- * Event types are configurable via ci config:
- *   - comment_event (default: "kj-comment")
- *   - review_event  (default: "kj-review")
- *
- * Only active when ci.enabled: true.
- */
-
-import { runCommand } from "../utils/process.js";
-
-export const VALID_AGENTS = [
-  "Coder",
-  "Reviewer",
-  "Solomon",
-  "Sonar",
-  "Tester",
-  "Security",
-  "Planner"
-];
-
-const VALID_REVIEW_EVENTS = ["APPROVE", "REQUEST_CHANGES"];
-
-function validateCommon({ repo, prNumber }) {
-  if (!repo) throw new Error("repo is required (e.g. 'owner/repo')");
-  if (!prNumber) throw new Error("prNumber is required (positive integer)");
-}
-
-function validateAgent(agent) {
-  if (!VALID_AGENTS.includes(agent)) {
-    throw new Error(
-      `Invalid agent "${agent}". Must be one of: ${VALID_AGENTS.join(", ")}`
-    );
-  }
-}
-
-async function sendDispatch(repo, payload) {
-  const res = await runCommand(
-    "gh",
-    ["api", `repos/${repo}/dispatches`, "--method", "POST", "--input", "-"],
-    { input: JSON.stringify(payload) }
-  );
-
-  if (res.exitCode === 127) {
-    throw new Error(
-      "gh CLI not found. Install GitHub CLI: https://cli.github.com/"
-    );
-  }
-
-  if (res.exitCode !== 0) {
-    throw new Error(
-      `Dispatch failed (exit ${res.exitCode}): ${res.stderr || res.stdout}`
-    );
-  }
-}
-
-/**
- * Send a comment event so the gateway posts a PR comment.
- * @param {object} opts
- * @param {object} [opts.ciConfig] - ci config section (optional)
- */
-export async function dispatchComment({ repo, prNumber, agent, body, ciConfig }) {
-  validateCommon({ repo, prNumber });
-  validateAgent(agent);
-  if (!body) throw new Error("body is required (comment text)");
-
-  const prefix = ciConfig?.comment_prefix === false ? "" : `[${agent}] `;
-  const eventType = ciConfig?.comment_event || "kj-comment";
-
-  await sendDispatch(repo, {
-    event_type: eventType,
-    client_payload: { pr_number: prNumber, agent, body: `${prefix}${body}` }
-  });
-}
-
-/**
- * Send a review event so the gateway submits a formal PR review.
- * @param {object} opts
- * @param {object} [opts.ciConfig] - ci config section (optional)
- */
-export async function dispatchReview({ repo, prNumber, event, body, agent, ciConfig }) {
-  validateCommon({ repo, prNumber });
-  validateAgent(agent);
-  if (!VALID_REVIEW_EVENTS.includes(event)) {
-    throw new Error(
-      `event must be one of: ${VALID_REVIEW_EVENTS.join(", ")} (got "${event}")`
-    );
-  }
-  if (!body) throw new Error("body is required (review text)");
-
-  const eventType = ciConfig?.review_event || "kj-review";
-
-  await sendDispatch(repo, {
-    event_type: eventType,
-    client_payload: { pr_number: prNumber, event, body, agent }
-  });
-}

package/src/ci/index.js

@@ -1,3 +0,0 @@
-export { dispatchComment, dispatchReview, VALID_AGENTS } from "./dispatch.js";
-export { detectRepo, detectPrNumber } from "./repo.js";
-export { getPrDiff } from "./pr-diff.js";