karajan-code 1.59.1 → 2.0.1

package/src/config.js

@@ -34,8 +34,15 @@ const DEFAULTS = {
     discover: { enabled: false },
     architect: { enabled: false },
     hu_reviewer: { enabled: false },
+    brain: { enabled: true },
     auto_simplify: true
   },
+  brain: {
+    enabled: true,
+    provider: "claude",
+    bypass_solomon_on_correctness: true,
+    max_consecutive_verification_failures: 2
+  },
   review_mode: "standard",
   max_iterations: 5,
   max_budget_usd: null,
@@ -49,7 +56,7 @@ const DEFAULTS = {
     model: null,
     deterministic: true,
     retries: 1,
-    fallback_reviewer: "codex"
+    fallback_reviewer: null
   },
   development: {
     methodology: "tdd",
@@ -128,7 +135,7 @@ const DEFAULTS = {
   policies: {},
   serena: { enabled: false },
   planning_game: { enabled: false, project_id: null, codeveloper: null },
-  becaria: { enabled: false, review_event: "becaria-review", comment_event: "becaria-comment", comment_prefix: true },
+  ci: { enabled: false, review_event: "kj-review", comment_event: "kj-comment", comment_prefix: true },
   git: { auto_commit: false, auto_push: false, auto_pr: false, auto_rebase: true, branch_prefix: "feat/" },
   output: { report_dir: "./.reviews", log_level: "info", quiet: true },
   budget: {
@@ -159,50 +166,12 @@ const DEFAULTS = {
   failFast: {
     repeatThreshold: 2
   },
-  retry: {
-    max_attempts: 3,
-    initial_backoff_ms: 1000,
-    max_backoff_ms: 30000,
-    backoff_multiplier: 2,
-    jitter_factor: 0.1
-  },
   webperf: {
     enabled: true,
     devtools_mcp: false,
     thresholds: { lcp: 2500, cls: 0.1, inp: 200 }
   },
   telemetry: true,
-  proxy: {
-    enabled: true,
-    port: "auto",
-    compression: {
-      enabled: true,
-      ai_compression: false,
-      ai_model: "haiku",
-      ai_provider: "anthropic",
-      layers: {
-        git: true,
-        tests: true,
-        build: true,
-        infra: true,
-        packages: true,
-        read_dedup: true,
-        glob_truncate: true,
-        grep_collapse: true,
-      },
-      pressure_thresholds: {
-        low: 0.5,
-        medium: 0.8,
-        high: 0.9,
-      },
-    },
-    cache: {
-      persist_to_disk: true,
-      flush_interval_ms: 5000,
-    },
-    inject_prompts: true,
-    monitor: true,
-  },
   guards: {
     output: {
       enabled: true,
@@ -398,12 +367,12 @@ function applyMethodologyOverride(out, flags) {
   out.development.require_test_changes = methodology === "tdd";
 }
 
-function applyBecariaOverride(out, flags) {
-  out.becaria = out.becaria || { enabled: false };
-  if (flags.enableBecaria === undefined) return;
-  out.becaria.enabled = Boolean(flags.enableBecaria);
-  // BecarIA requires git automation (commit + push + PR)
-  if (out.becaria.enabled) {
+function applyCiOverride(out, flags) {
+  out.ci = out.ci || { enabled: false };
+  if (flags.enableCi === undefined) return;
+  out.ci.enabled = Boolean(flags.enableCi);
+  // CI requires git automation (commit + push + PR)
+  if (out.ci.enabled) {
     out.git.auto_commit = true;
     out.git.auto_push = true;
     out.git.auto_pr = true;
@@ -432,10 +401,6 @@ function applyMiscOverrides(out, flags) {
   if (flags.pgTask) out.planning_game.enabled = true;
   if (flags.pgProject) out.planning_game.project_id = flags.pgProject;
 
-  out.proxy = out.proxy || {};
-  if (flags.noProxy) out.proxy.enabled = false;
-  if (flags.proxyPort) out.proxy.port = flags.proxyPort;
-
   out.model_selection = out.model_selection || { enabled: true, tiers: {}, role_overrides: {} };
   if (flags.smartModels === true) out.model_selection.enabled = true;
   if (flags.smartModels === false || flags.noSmartModels === true) out.model_selection.enabled = false;
@@ -461,7 +426,7 @@ export function applyRunOverrides(config, flags) {
   applyPipelineOverrides(out, flags);
   applyScalarAndBooleanOverrides(out, flags);
   applyMethodologyOverride(out, flags);
-  applyBecariaOverride(out, flags);
+  applyCiOverride(out, flags);
   applyMiscOverrides(out, flags);
   applyOutputModeOverrides(out, flags);
 
@@ -479,7 +444,7 @@ const AGENT_MODEL_SIGNATURES = {
   gemini: ["gemini", "flash-"]
 };
 
-export function isModelCompatible(agent, model) {
+function isModelCompatible(agent, model) {
   if (!model || !agent) return true;
   const lower = model.toLowerCase();
 

package/src/git/automation.js

@@ -110,7 +110,7 @@ export function buildPrBody({ task, stageResults }) {
 }
 
 /**
- * Create an early PR after the first coder iteration (BecarIA Gateway flow).
+ * Create an early PR after the first coder iteration (Karajan CI flow).
  * Commits, pushes, and creates a PR before the reviewer runs.
  * Returns { prNumber, prUrl, commits } or null if nothing to commit.
  */
@@ -125,10 +125,10 @@ export async function earlyPrCreation({ gitCtx, task, logger, session, stageResu
   }
 
   const commits = commitResult.commit ? [commitResult.commit] : [];
-  await addCheckpoint(session, { stage: "becaria-commit", committed: true });
+  await addCheckpoint(session, { stage: "ci-commit", committed: true });
 
   await pushBranch(gitCtx.branch);
-  await addCheckpoint(session, { stage: "becaria-push", branch: gitCtx.branch });
+  await addCheckpoint(session, { stage: "ci-push", branch: gitCtx.branch });
   logger.info(`Pushed branch for early PR: ${gitCtx.branch}`);
 
   const body = buildPrBody({ task, stageResults });
@@ -138,7 +138,7 @@ export async function earlyPrCreation({ gitCtx, task, logger, session, stageResu
     title: commitMessageFromTask(task),
     body
   });
-  await addCheckpoint(session, { stage: "becaria-pr", branch: gitCtx.branch, pr: prUrl });
+  await addCheckpoint(session, { stage: "ci-pr", branch: gitCtx.branch, pr: prUrl });
   logger.info(`Early PR created: ${prUrl}`);
 
   // Extract PR number from URL (e.g. https://github.com/owner/repo/pull/42)
@@ -147,7 +147,7 @@ export async function earlyPrCreation({ gitCtx, task, logger, session, stageResu
 }
 
 /**
- * Incremental push after each coder iteration (BecarIA Gateway flow).
+ * Incremental push after each coder iteration (Karajan CI flow).
  * Commits and pushes without creating a new PR.
  */
 export async function incrementalPush({ gitCtx, task, logger, session }) {
@@ -161,10 +161,10 @@ export async function incrementalPush({ gitCtx, task, logger, session }) {
   }
 
   const commits = commitResult.commit ? [commitResult.commit] : [];
-  await addCheckpoint(session, { stage: "becaria-incremental-commit", committed: true });
+  await addCheckpoint(session, { stage: "ci-incremental-commit", committed: true });
 
   await pushBranch(gitCtx.branch);
-  await addCheckpoint(session, { stage: "becaria-incremental-push", branch: gitCtx.branch });
+  await addCheckpoint(session, { stage: "ci-incremental-push", branch: gitCtx.branch });
   logger.info(`Incremental push: ${gitCtx.branch}`);
 
   return { commits };
@@ -202,7 +202,7 @@ export async function finalizeGitAutomation({ config, gitCtx, task, logger, sess
     logger.info(`Pushed branch: ${gitCtx.branch}`);
   }
 
-  let prUrl = session.becaria_pr_url || null;
+  let prUrl = session.ci_pr_url || null;
   if (config.git.auto_pr && !prUrl) {
     const body = buildPrBody({ task, stageResults });
     prUrl = await createPullRequest({
@@ -214,7 +214,7 @@ export async function finalizeGitAutomation({ config, gitCtx, task, logger, sess
     await addCheckpoint(session, { stage: "git-pr", branch: gitCtx.branch, pr: prUrl });
     logger.info("Pull request created");
   } else if (prUrl) {
-    logger.info(`PR already exists (BecarIA flow): ${prUrl}`);
+    logger.info(`PR already exists (CI flow): ${prUrl}`);
   }
 
   return { committed, branch: gitCtx.branch, prUrl, pr: prUrl, commits };

package/src/guards/output-guard.js

@@ -148,21 +148,4 @@ export function scanDiff(diff, config = {}) {
   return { pass: !hasCritical, violations };
 }
 
-/**
- * Run output guard on the current git diff.
- * This is the main entry point for the pipeline integration.
- */
-export async function runOutputGuard(config = {}, baseBranch = "main") {
-  const diffResult = await runCommand("git", ["diff", `origin/${baseBranch}...HEAD`]);
-  if (diffResult.exitCode !== 0) {
-    // Fallback: diff against HEAD~1
-    const fallback = await runCommand("git", ["diff", "HEAD~1"]);
-    if (fallback.exitCode !== 0) {
-      return { pass: true, violations: [], error: "Could not generate diff" };
-    }
-    return scanDiff(fallback.stdout, config);
-  }
-  return scanDiff(diffResult.stdout, config);
-}
-
 export { DESTRUCTIVE_PATTERNS, CREDENTIAL_PATTERNS, DEFAULT_PROTECTED_FILES };

package/src/mcp/handlers/direct-handlers.js

@@ -258,7 +258,7 @@ export async function handleReviewDirect(a, server, extra) {
   const logger = createLogger(config.output.log_level, "mcp");
 
   const reviewerRole = resolveRole(config, "reviewer");
-  await assertAgentsAvailable([reviewerRole.provider, config.reviewer_options?.fallback_reviewer]);
+  await assertAgentsAvailable([reviewerRole.provider]);
 
   const projectDir = await resolveProjectDir(server, a.projectDir);
   const runLog = createRunLog(projectDir);

package/src/mcp/handlers/run-handler.js

@@ -98,8 +98,7 @@ const PIPELINE_PROVIDER_ROLES = [
 
 function collectRequiredProviders(config) {
   const providers = [
-    resolveRole(config, "coder").provider,
-    config.reviewer_options?.fallback_reviewer
+    resolveRole(config, "coder").provider
   ];
   if (config.pipeline?.reviewer?.enabled !== false) {
     providers.push(resolveRole(config, "reviewer").provider);

package/src/mcp/sovereignty-guard.js

@@ -17,7 +17,7 @@ const ALLOWED_PARAMS = new Set([
   "enableTester", "enableSecurity", "enableImpeccable",
   "enableDiscover", "enableArchitect",
   "architectModel", "huFile",
-  "enableSerena", "enableBecaria",
+  "enableSerena", "enableCi",
   "reviewerFallback", "reviewerRetries",
   "mode", "maxIterations", "maxIterationMinutes", "maxTotalMinutes",
   "baseBranch", "baseRef", "methodology",

package/src/mcp/tools.js

@@ -79,7 +79,7 @@ export const tools = [
         architectModel: { type: "string" },
         huFile: { type: "string", description: "Path to YAML file with HU stories to certify before coding" },
         enableSerena: { type: "boolean" },
-        enableBecaria: { type: "boolean", description: "Enable BecarIA Gateway (early PR + dispatch comments/reviews)" },
+        enableCi: { type: "boolean", description: "Enable Karajan CI (early PR + dispatch comments/reviews)" },
         reviewerFallback: { type: "string" },
         reviewerRetries: { type: "number" },
         mode: { type: "string" },

package/src/orchestrator/brain-coordinator.js

@@ -0,0 +1,165 @@
+// Brain Coordinator: integrates Karajan Brain + 5 support modules into the pipeline.
+// Replaces ad-hoc role-to-role communication with a central intelligence.
+
+import * as queue from "./feedback-queue.js";
+import * as enrich from "./feedback-enrichment.js";
+import { verifyCoderOutput, VerificationTracker } from "./verification-gate.js";
+import { executeActions } from "./direct-actions.js";
+import { compressRoleOutput, measureCompression } from "./role-output-compressor.js";
+
+/**
+ * @typedef {Object} BrainContext
+ * @property {Object} feedbackQueue - structured feedback queue
+ * @property {VerificationTracker} verificationTracker - tracks coder changes
+ * @property {Object} compressionStats - token savings per role
+ * @property {boolean} enabled - whether brain coordination is active
+ */
+
+/**
+ * Create a new brain context for a pipeline session.
+ */
+export function createBrainContext({ enabled = false } = {}) {
+  return {
+    feedbackQueue: queue.createQueue(),
+    verificationTracker: new VerificationTracker(),
+    compressionStats: { totalSaved: 0, perRole: {} },
+    enabled
+  };
+}
+
+/**
+ * Check if brain coordination is enabled for this config.
+ */
+export function isBrainEnabled(config) {
+  return Boolean(config?.brain?.enabled) || Boolean(config?.pipeline?.brain?.enabled);
+}
+
+/**
+ * After a role completes, push its feedback to the queue and compress.
+ * Returns the compressed output for passing to next role.
+ */
+export function processRoleOutput(ctx, { roleName, output, iteration }) {
+  if (!ctx.enabled) return output;
+
+  // Compress for next-role context
+  const compressed = compressRoleOutput(roleName, output);
+  const stats = measureCompression(output, compressed);
+  ctx.compressionStats.totalSaved += stats.savedTokens;
+  ctx.compressionStats.perRole[roleName] = stats;
+
+  // Extract feedback entries from specific role outputs
+  const entries = extractFeedbackEntries(roleName, output, iteration);
+  if (entries.length > 0) {
+    queue.addEntries(ctx.feedbackQueue, entries);
+    enrich.enrichQueue(ctx.feedbackQueue);
+    queue.deduplicate(ctx.feedbackQueue);
+    queue.prioritize(ctx.feedbackQueue);
+  }
+
+  return compressed;
+}
+
+/**
+ * Extract structured feedback entries from a role's output.
+ */
+function extractFeedbackEntries(roleName, output, iteration) {
+  if (!output || typeof output !== "object") return [];
+
+  const entries = [];
+  if (roleName === "reviewer" && output.blocking_issues) {
+    for (const issue of output.blocking_issues) {
+      entries.push({
+        source: "reviewer",
+        severity: issue.severity || "medium",
+        description: issue.description || "",
+        file: issue.file || null,
+        line: issue.line || null,
+        suggestedFix: issue.suggested_fix || null,
+        id: issue.id || null,
+        iteration
+      });
+    }
+  } else if (roleName === "tester" && output.verdict === "fail") {
+    const missing = output.missing_scenarios || [];
+    for (const scenario of missing) {
+      entries.push({
+        source: "tester",
+        severity: "high",
+        category: "tests",
+        description: `Missing scenario: ${scenario}`,
+        iteration
+      });
+    }
+    if (output.coverage?.overall != null && output.coverage.overall < 80) {
+      entries.push({
+        source: "tester",
+        severity: "high",
+        category: "tests",
+        description: `Coverage below 80% (${output.coverage.overall}%)`,
+        iteration
+      });
+    }
+  } else if (roleName === "security" && output.verdict === "fail") {
+    for (const vuln of output.vulnerabilities || []) {
+      entries.push({
+        source: "security",
+        severity: vuln.severity || "high",
+        category: "security",
+        description: vuln.description || "",
+        file: vuln.file || null,
+        line: vuln.line || null,
+        suggestedFix: vuln.fix_suggestion || null,
+        iteration
+      });
+    }
+  }
+  return entries;
+}
+
+/**
+ * Before coder runs, format the feedback queue as an actionable prompt.
+ */
+export function buildCoderFeedbackPrompt(ctx) {
+  if (!ctx.enabled || ctx.feedbackQueue.entries.length === 0) return null;
+  return enrich.formatEnrichedForCoder(ctx.feedbackQueue.entries);
+}
+
+/**
+ * After coder runs, verify changes were made. Returns verification result.
+ */
+export function verifyCoderRan(ctx, { baseRef, projectDir }) {
+  if (!ctx.enabled) return { passed: true, filesChanged: 0, reason: "brain disabled" };
+  const result = verifyCoderOutput({ baseRef, projectDir });
+  ctx.verificationTracker.record(result);
+  return result;
+}
+
+/**
+ * Execute direct actions (npm install, gitignore updates, etc.).
+ */
+export async function runDirectActions(ctx, actions, { cwd } = {}) {
+  if (!ctx.enabled || !actions?.length) return [];
+  return executeActions(actions, { cwd });
+}
+
+/**
+ * Clear feedback queue after coder addresses it.
+ */
+export function clearFeedback(ctx) {
+  if (!ctx.enabled) return;
+  queue.clear(ctx.feedbackQueue);
+}
+
+/**
+ * Get a summary of brain activity for the session.
+ */
+export function summarize(ctx) {
+  if (!ctx.enabled) return null;
+  return {
+    feedbackQueueSize: ctx.feedbackQueue.entries.length,
+    queueCategories: queue.countByCategory(ctx.feedbackQueue),
+    consecutiveVerificationFailures: ctx.verificationTracker.consecutiveFailures,
+    compressionSaved: ctx.compressionStats.totalSaved,
+    compressionPerRole: ctx.compressionStats.perRole
+  };
+}

package/src/orchestrator/ci-integration.js

@@ -0,0 +1,139 @@
+/**
+ * CI/CD integration — early PR creation, incremental push, review dispatch.
+ * Extracted from orchestrator.js — self-contained feature, only active when ci.enabled.
+ */
+import { saveSession } from "../session-store.js";
+import { earlyPrCreation, incrementalPush } from "../git/automation.js";
+import { emitProgress, makeEvent } from "../utils/events.js";
+
+export async function tryCiComment({ config, session, logger, agent, body }) {
+  if (!config.ci?.enabled || !session.ci_pr_number) return;
+  try {
+    const { dispatchComment } = await import("../ci/dispatch.js");
+    const { detectRepo } = await import("../ci/repo.js");
+    const repo = await detectRepo();
+    if (repo) {
+      await dispatchComment({
+        repo, prNumber: session.ci_pr_number, agent,
+        body, ciConfig: config.ci
+      });
+    }
+  } catch { /* non-blocking */ }
+}
+
+function formatCommitList(commits) {
+  return commits.map((c) => `- \`${c.hash.slice(0, 7)}\` ${c.message}`).join("\n");
+}
+
+async function ciIncrementalPush({ config, session, gitCtx, task, logger, repo, dispatchComment }) {
+  const pushResult = await incrementalPush({ gitCtx, task, logger, session });
+  if (!pushResult) return;
+
+  const { accumulateCommit } = await import("../planning-game/pipeline-adapter.js");
+  for (const c of pushResult.commits) accumulateCommit(session, c);
+
+  session.ci_commits = [...(session.ci_commits ?? []), ...pushResult.commits];
+  await saveSession(session);
+
+  if (!repo) return;
+  const feedback = session.last_reviewer_feedback || "N/A";
+  await dispatchComment({
+    repo, prNumber: session.ci_pr_number, agent: "Coder",
+    body: `Issues fixed:\n${feedback}\n\nCommits:\n${formatCommitList(pushResult.commits)}`,
+    ciConfig: config.ci
+  });
+}
+
+async function ciCreateEarlyPr({ config, session, emitter, eventBase, gitCtx, task, logger, stageResults, i, repo, dispatchComment }) {
+  const earlyPr = await earlyPrCreation({ gitCtx, task, logger, session, stageResults });
+  if (!earlyPr) return;
+
+  const { accumulateCommit } = await import("../planning-game/pipeline-adapter.js");
+  for (const c of earlyPr.commits) accumulateCommit(session, c);
+
+  session.ci_pr_number = earlyPr.prNumber;
+  session.ci_pr_url = earlyPr.prUrl;
+  session.ci_commits = earlyPr.commits;
+  await saveSession(session);
+  emitProgress(emitter, makeEvent("ci:pr-created", { ...eventBase, stage: "ci" }, {
+    message: `Early PR created: #${earlyPr.prNumber}`,
+    detail: { prNumber: earlyPr.prNumber, prUrl: earlyPr.prUrl }
+  }));
+
+  if (!repo) return;
+  await dispatchComment({
+    repo, prNumber: earlyPr.prNumber, agent: "Coder",
+    body: `Iteration ${i} completed.\n\nCommits:\n${formatCommitList(earlyPr.commits)}`,
+    ciConfig: config.ci
+  });
+}
+
+export async function handleCiEarlyPrOrPush({ ciEnabled, config, session, emitter, eventBase, gitCtx, task, logger, stageResults, i }) {
+  if (!ciEnabled) return;
+
+  try {
+    const { dispatchComment } = await import("../ci/dispatch.js");
+    const { detectRepo } = await import("../ci/repo.js");
+    const repo = await detectRepo();
+
+    if (session.ci_pr_number) {
+      await ciIncrementalPush({ config, session, gitCtx, task, logger, repo, dispatchComment });
+    } else {
+      await ciCreateEarlyPr({ config, session, emitter, eventBase, gitCtx, task, logger, stageResults, i, repo, dispatchComment });
+    }
+  } catch (err) {
+    logger.warn(`CI early PR/push failed (non-blocking): ${err.message}`);
+  }
+}
+
+export function formatBlockingIssues(issues) {
+  return issues?.map((x) => `- ${x.id || "ISSUE"} [${x.severity || ""}] ${x.description}`).join("\n") || "";
+}
+
+function formatSuggestions(suggestions) {
+  return suggestions?.map((s) => {
+    const detail = typeof s === "string" ? s : `${s.id || ""} ${s.description || s}`;
+    return `- ${detail}`;
+  }).join("\n") || "";
+}
+
+function buildReviewCommentBody(review, i) {
+  const status = review.approved ? "APPROVED" : "REQUEST_CHANGES";
+  const blocking = formatBlockingIssues(review.blocking_issues);
+  const suggestions = formatSuggestions(review.non_blocking_suggestions);
+  let body = `Review iteration ${i}: ${status}`;
+  if (blocking) body += `\n\n**Blocking:**\n${blocking}`;
+  if (suggestions) body += `\n\n**Suggestions:**\n${suggestions}`;
+  return body;
+}
+
+export async function handleCiReviewDispatch({ ciEnabled, config, session, review, i, logger }) {
+  if (!ciEnabled || !session.ci_pr_number) return;
+
+  try {
+    const { dispatchReview, dispatchComment } = await import("../ci/dispatch.js");
+    const { detectRepo } = await import("../ci/repo.js");
+    const repo = await detectRepo();
+    if (!repo) return;
+
+    const bc = config.ci;
+    const reviewEvent = review.approved ? "APPROVE" : "REQUEST_CHANGES";
+    const reviewBody = review.approved
+      ? (review.summary || "Approved")
+      : (formatBlockingIssues(review.blocking_issues) || review.summary || "Changes requested");
+
+    await dispatchReview({
+      repo, prNumber: session.ci_pr_number,
+      event: reviewEvent, body: reviewBody, agent: "Reviewer", ciConfig: bc
+    });
+
+    await dispatchComment({
+      repo, prNumber: session.ci_pr_number, agent: "Reviewer",
+      body: buildReviewCommentBody(review, i), ciConfig: bc
+    });
+
+    logger.info(`CI: dispatched review for PR #${session.ci_pr_number}`);
+  } catch (err) {
+    logger.warn(`CI dispatch failed (non-blocking): ${err.message}`);
+  }
+}