karajan-code 2.0.0 → 2.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "karajan-code",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Local multi-agent coding orchestrator with TDD, SonarQube, and code review pipeline",
   "type": "module",
   "license": "AGPL-3.0",

package/src/commands/board.js

@@ -34,14 +34,21 @@ export async function startBoard(port = 4000) {
   const karajanHome = getKarajanHome();
   fs.mkdirSync(karajanHome, { recursive: true });
 
-  const child = spawn("node", [serverPath], {
+  // Use process.execPath (absolute path to current node binary) instead of "node".
+  // Fixes ENOENT on nvm setups where `node` is not in the spawned process's PATH.
+  const child = spawn(process.execPath, [serverPath], {
     env: { ...process.env, PORT: String(port) },
     detached: true,
     stdio: "ignore",
     cwd: BOARD_DIR
   });
+  // Swallow spawn errors so an HU Board failure never crashes the pipeline.
+  child.on("error", () => { /* non-blocking — caller logs via tryAutoStartBoard catch */ });
   child.unref();
 
+  if (!child.pid) {
+    throw new Error("Failed to spawn HU Board server");
+  }
   fs.writeFileSync(PID_FILE, String(child.pid));
   return { ok: true, alreadyRunning: false, pid: child.pid, url: `http://localhost:${port}` };
 }

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,

package/src/orchestrator/pipeline-context.js

@@ -46,6 +46,9 @@ export class PipelineContext {
     // Planned task (may differ from original task after planner)
     this.plannedTask = null;
 
+    // Karajan Brain runtime context (feedback queue, verification tracker, compression stats)
+    this.brainCtx = null;
+
     // Timing
     this.startedAt = null;
   }

package/src/orchestrator/stages/coder-stage.js

@@ -16,7 +16,7 @@ import { invokeSolomon } from "../solomon-escalation.js";
 import { detectRateLimit } from "../../utils/rate-limit-detector.js";
 import { createStallDetector } from "../../utils/stall-detector.js";
 
-export async function runCoderStage({ coderRoleInstance, coderRole, config, logger, emitter, eventBase, session, plannedTask, trackBudget, iteration }) {
+export async function runCoderStage({ coderRoleInstance, coderRole, config, logger, emitter, eventBase, session, plannedTask, trackBudget, iteration, brainCtx }) {
   logger.setContext({ iteration, stage: "coder" });
   emitProgress(
     emitter,
@@ -26,6 +26,17 @@ export async function runCoderStage({ coderRoleInstance, coderRole, config, logg
     })
   );
 
+  // Brain: if enabled and queue has entries, use enriched feedback instead of flat string
+  let reviewerFeedback = session.last_reviewer_feedback;
+  if (brainCtx?.enabled) {
+    const { buildCoderFeedbackPrompt } = await import("../brain-coordinator.js");
+    const enriched = buildCoderFeedbackPrompt(brainCtx);
+    if (enriched) {
+      reviewerFeedback = enriched;
+      logger.info(`Brain: using enriched feedback (${brainCtx.feedbackQueue.entries.length} entries)`);
+    }
+  }
+
   const coderOnOutput = ({ stream, line }) => {
     emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "coder" }, {
       message: line,
@@ -40,7 +51,7 @@ export async function runCoderStage({ coderRoleInstance, coderRole, config, logg
   try {
     coderExecResult = await coderRoleInstance.execute({
       task: plannedTask,
-      reviewerFeedback: session.last_reviewer_feedback,
+      reviewerFeedback,
       sonarSummary: session.last_sonar_summary,
       deferredContext: buildDeferredContext(session.deferred_issues),
       onOutput: coderStall.onOutput
@@ -123,14 +134,48 @@ export async function runCoderStage({ coderRoleInstance, coderRole, config, logg
     throw new Error(`Coder failed: ${details}`);
   }
 
-  await addCheckpoint(session, { stage: "coder", iteration, note: "Coder applied changes", provider: coderRole.provider, model: coderRole.model || null });
+  // Measure files changed so stale detection (solomon-rules) has accurate data
+  let filesChanged = 0;
+  try {
+    const { verifyCoderOutput } = await import("../verification-gate.js");
+    const verif = verifyCoderOutput({
+      baseRef: session.session_start_sha,
+      projectDir: config.projectDir || process.cwd()
+    });
+    filesChanged = verif.filesChanged || 0;
+  } catch { /* ignore verification errors */ }
+
+  await addCheckpoint(session, { stage: "coder", iteration, note: "Coder applied changes", provider: coderRole.provider, model: coderRole.model || null, filesChanged });
   emitProgress(
     emitter,
     makeEvent("coder:end", { ...eventBase, stage: "coder" }, {
       message: "Coder completed",
-      detail: { provider: coderRole.provider, executorType: "agent" }
+      detail: { provider: coderRole.provider, executorType: "agent", filesChanged }
     })
   );
+
+  // Brain: verify coder produced real changes + clear feedback queue (now addressed)
+  if (brainCtx?.enabled) {
+    const { verifyCoderRan, clearFeedback } = await import("../brain-coordinator.js");
+    const result = verifyCoderRan(brainCtx, {
+      baseRef: session.session_start_sha,
+      projectDir: config.projectDir || process.cwd()
+    });
+    const maxFailures = config.brain?.max_consecutive_verification_failures ?? 2;
+    if (!result.passed) {
+      logger.warn(`Brain verification: coder made 0 changes (consecutive failures: ${brainCtx.verificationTracker.consecutiveFailures}/${maxFailures})`);
+      emitProgress(emitter, makeEvent("brain:verification", { ...eventBase, stage: "coder" }, {
+        message: `Brain: coder produced no changes (${brainCtx.verificationTracker.consecutiveFailures}/${maxFailures} consecutive failures)`,
+        detail: { filesChanged: result.filesChanged, consecutiveFailures: brainCtx.verificationTracker.consecutiveFailures }
+      }));
+      if (brainCtx.verificationTracker.consecutiveFailures >= maxFailures) {
+        await markSessionStatus(session, "stalled");
+        throw new Error(`Brain: ${maxFailures} consecutive coder iterations with 0 file changes — pipeline stalled`);
+      }
+    } else {
+      clearFeedback(brainCtx);
+    }
+  }
 }
 
 export async function runRefactorerStage({ refactorerRole, config, logger, emitter, eventBase, session, plannedTask, trackBudget, iteration }) {

package/src/orchestrator/stages/reviewer-stage.js

@@ -117,12 +117,38 @@ async function handleReviewerStalledSolomon({ review, repeatCounts, repeatState,
   return { review, stalled: true, stalledResult: { approved: false, sessionId: session.id, reason: "stalled" } };
 }
 
-async function handleReviewerRejection({ review, repeatDetector, config, logger, emitter, eventBase, session, iteration, task, askQuestion, budgetSummary }) {
+async function handleReviewerRejection({ review, repeatDetector, config, logger, emitter, eventBase, session, iteration, task, askQuestion, budgetSummary, brainCtx }) {
   repeatDetector.addIteration([], review.blocking_issues);
   const repeatState = repeatDetector.isStalled();
 
   const solomonEnabled = Boolean(config.pipeline?.solomon?.enabled);
 
+  // Brain: if enabled and bypass_solomon_on_correctness, push issues to queue and skip Solomon
+  // for non-style rejections. Solomon is still consulted on genuine dilemmas (style-only, deadlock).
+  if (brainCtx?.enabled && config.brain?.bypass_solomon_on_correctness !== false) {
+    const cats = categorizeIssues(review.blocking_issues);
+    const nonStyleIssues = cats.security + cats.correctness + cats.tests;
+    const styleIssues = cats.style;
+    // Only bypass if there ARE non-style issues (correctness, tests, security, or "other" is correctness)
+    // If it's style-only, let Solomon evaluate whether to override
+    if (nonStyleIssues > 0 || cats.other > 0) {
+      const { processRoleOutput } = await import("../brain-coordinator.js");
+      processRoleOutput(brainCtx, { roleName: "reviewer", output: review, iteration });
+      logger.info(`Brain: reviewer rejected with ${nonStyleIssues} non-style issue(s) — bypassing Solomon, returning to coder`);
+      emitProgress(emitter, makeEvent("brain:bypass-solomon", { ...eventBase, stage: "reviewer" }, {
+        message: `Brain: ${nonStyleIssues} non-style issue(s) — sending to coder without Solomon`,
+        detail: { categories: cats, queueSize: brainCtx.feedbackQueue.entries.length }
+      }));
+      // Persist flat feedback for compat with non-Brain flow
+      session.last_reviewer_feedback = review.blocking_issues
+        .map((x, idx) => `R-${idx + 1} [${x.severity || "medium"}]: ${x.description}`)
+        .join("\n");
+      await saveSession(session);
+      return null; // null = continue to next iteration (coder fixes)
+    }
+    logger.info("Brain: reviewer rejected with style-only issues — consulting Solomon for dilemma");
+  }
+
   // When Solomon is disabled, only act on stalls (legacy behavior)
   if (!solomonEnabled) {
     if (!repeatState.stalled) return null;
@@ -159,7 +185,7 @@ export async function fetchReviewDiff(session, logger) {
   return generateDiff({ baseRef: session.session_start_sha, stageNewFiles: true });
 }
 
-export async function runReviewerStage({ reviewerRole, config, logger, emitter, eventBase, session, trackBudget, iteration, reviewRules, task, repeatDetector, budgetSummary, askQuestion }) {
+export async function runReviewerStage({ reviewerRole, config, logger, emitter, eventBase, session, trackBudget, iteration, reviewRules, task, repeatDetector, budgetSummary, askQuestion, brainCtx }) {
   logger.setContext({ iteration, stage: "reviewer" });
   emitProgress(
     emitter,
@@ -326,13 +352,19 @@ export async function runReviewerStage({ reviewerRole, config, logger, emitter,
     });
   }
 
+  // Feedback signature for stale detection: concatenated issue descriptions
+  const feedbackSignature = review.blocking_issues
+    .map(x => (x.description || "").slice(0, 120))
+    .join("|") || "approved";
+
   await addCheckpoint(session, {
     stage: "reviewer",
     iteration,
     approved: review.approved,
     blocking_issues: review.blocking_issues.length,
     provider: reviewerRole.provider,
-    model: reviewerRole.model || null
+    model: reviewerRole.model || null,
+    note: feedbackSignature
   });
 
   emitProgress(
@@ -353,7 +385,7 @@ export async function runReviewerStage({ reviewerRole, config, logger, emitter,
   );
 
   if (!review.approved) {
-    const rejectionResult = await handleReviewerRejection({ review, repeatDetector, config, logger, emitter, eventBase, session, iteration, task, askQuestion, budgetSummary });
+    const rejectionResult = await handleReviewerRejection({ review, repeatDetector, config, logger, emitter, eventBase, session, iteration, task, askQuestion, budgetSummary, brainCtx });
     if (rejectionResult) return rejectionResult;
   }
 

package/src/orchestrator.js

@@ -210,7 +210,7 @@ function emitSolomonAlerts(alerts, emitter, eventBase, logger) {
   }
 }
 
-async function handleSolomonCheck({ config, session, emitter, eventBase, logger, task, i, askQuestion, ciEnabled, blockingIssues }) {
+async function handleSolomonCheck({ config, session, emitter, eventBase, logger, task, i, askQuestion, ciEnabled, blockingIssues, brainCtx }) {
   if (config.pipeline?.solomon?.enabled === false) return { action: "continue" };
 
   try {
@@ -220,8 +220,45 @@ async function handleSolomonCheck({ config, session, emitter, eventBase, logger,
 
     if (rulesResult.alerts.length > 0) {
       emitSolomonAlerts(rulesResult.alerts, emitter, eventBase, logger);
-      const pauseResult = await checkSolomonCriticalAlerts({ rulesResult, askQuestion, session, i });
-      if (pauseResult) return pauseResult;
+      // Brain gateway: when Brain is the orchestrator, rule alerts are telemetry.
+      // On critical alerts Brain consults Solomon (AI judge). Only if Solomon can't
+      // resolve does Brain escalate to human. Solomon-rules never prompts directly.
+      if (!brainCtx?.enabled) {
+        const pauseResult = await checkSolomonCriticalAlerts({ rulesResult, askQuestion, session, i });
+        if (pauseResult) return pauseResult;
+      } else if (rulesResult.hasCritical) {
+        const criticalAlerts = rulesResult.alerts.filter(a => a.severity === "critical");
+        brainCtx.ruleAlerts = brainCtx.ruleAlerts || [];
+        brainCtx.ruleAlerts.push(...criticalAlerts);
+        logger.info(`Brain: ${criticalAlerts.length} critical rule alert(s) — consulting Solomon`);
+
+        const { invokeSolomon } = await import("./orchestrator/solomon-escalation.js");
+        const alertSummary = criticalAlerts.map(a => a.message).join("; ");
+        const solomonOpinion = await invokeSolomon({
+          config, logger, emitter, eventBase, stage: "brain-dilemma", askQuestion, session, iteration: i,
+          conflict: {
+            stage: "brain-dilemma",
+            task,
+            iterationCount: i,
+            maxIterations: config.max_iterations,
+            dilemma: `Brain detected critical rule alerts: ${alertSummary}. Should we continue iterating, pause for human, or stop?`,
+            ruleAlerts: criticalAlerts,
+            blockingIssues: blockingIssues || [],
+            history: (session.checkpoints || []).filter(cp => cp.stage === "reviewer").slice(-5).map(cp => ({ iteration: cp.iteration, feedback: cp.note || "" }))
+          }
+        });
+
+        if (solomonOpinion.action === "pause") {
+          logger.info("Brain: Solomon advised pause — escalating to human");
+          return { action: "return", result: { paused: true, sessionId: session.id, question: solomonOpinion.question || `Brain+Solomon paused: ${alertSummary}`, context: "brain_solomon_dilemma" } };
+        }
+        if (solomonOpinion.action === "approve") {
+          logger.info("Brain: Solomon advised proceeding — treating as approved");
+          return { action: "continue", approved: true };
+        }
+        // action === "continue" | "subtask" | fallback → Brain continues the loop
+        logger.info(`Brain: Solomon said '${solomonOpinion.action}' — continuing loop`);
+      }
     }
 
     if (ciEnabled && session.ci_pr_number) {
@@ -661,8 +698,8 @@ async function runPreLoopStages({ config, logger, emitter, eventBase, session, f
   return { plannedTask, updatedConfig };
 }
 
-async function runCoderAndRefactorerStages({ coderRoleInstance, coderRole, refactorerRole, pipelineFlags, config, logger, emitter, eventBase, session, plannedTask, trackBudget, i }) {
-  const coderResult = await runCoderStage({ coderRoleInstance, coderRole, config, logger, emitter, eventBase, session, plannedTask, trackBudget, iteration: i });
+async function runCoderAndRefactorerStages({ coderRoleInstance, coderRole, refactorerRole, pipelineFlags, config, logger, emitter, eventBase, session, plannedTask, trackBudget, i, brainCtx }) {
+  const coderResult = await runCoderStage({ coderRoleInstance, coderRole, config, logger, emitter, eventBase, session, plannedTask, trackBudget, iteration: i, brainCtx });
   if (coderResult?.action === "pause") return { action: "return", result: coderResult.result };
   const coderStandby = await handleStandbyResult({ stageResult: coderResult, session, emitter, eventBase, i, stage: "coder", logger, config });
   if (coderStandby.handled) {
@@ -795,7 +832,7 @@ async function runQualityGateStages({ config, logger, emitter, eventBase, sessio
   return { action: "ok" };
 }
 
-async function runReviewerGateStage({ pipelineFlags, reviewerRole, config, logger, emitter, eventBase, session, trackBudget, i, reviewRules, task, repeatDetector, budgetSummary, askQuestion }) {
+async function runReviewerGateStage({ pipelineFlags, reviewerRole, config, logger, emitter, eventBase, session, trackBudget, i, reviewRules, task, repeatDetector, budgetSummary, askQuestion, brainCtx }) {
   if (!pipelineFlags.reviewerEnabled) {
     return {
       action: "ok",
@@ -805,7 +842,7 @@ async function runReviewerGateStage({ pipelineFlags, reviewerRole, config, logge
 
   const reviewerResult = await runReviewerStage({
     reviewerRole, config, logger, emitter, eventBase, session, trackBudget,
-    iteration: i, reviewRules, task, repeatDetector, budgetSummary, askQuestion
+    iteration: i, reviewRules, task, repeatDetector, budgetSummary, askQuestion, brainCtx
   });
   if (reviewerResult.action === "pause") return { action: "return", result: reviewerResult.result };
   const revStandby = await handleStandbyResult({ stageResult: reviewerResult, session, emitter, eventBase, i, stage: "reviewer", logger, config, askQuestion });
@@ -1014,6 +1051,13 @@ async function initFlowContext({ task, config, logger, emitter, askQuestion, pgT
   ctx.session = await initializeSession({ task, config, flags, pgTaskId, pgProject });
   ctx.eventBase.sessionId = ctx.session.id;
 
+  // Karajan Brain: initialize runtime context (opt-in via config.brain.enabled)
+  const { createBrainContext, isBrainEnabled } = await import("./orchestrator/brain-coordinator.js");
+  ctx.brainCtx = createBrainContext({ enabled: isBrainEnabled(config) });
+  if (ctx.brainCtx.enabled) {
+    logger.info("Karajan Brain enabled — feedback queue, verification, compression active");
+  }
+
   const { initPgAdapter } = await import("./planning-game/pipeline-adapter.js");
   const pgAdapterResult = await initPgAdapter({ session: ctx.session, config, logger, pgTaskId, pgProject });
   ctx.pgCard = pgAdapterResult.pgCard;
@@ -1094,7 +1138,7 @@ async function runSingleIteration(ctx) {
   const crResult = await runCoderAndRefactorerStages({
     coderRoleInstance: ctx.coderRoleInstance, coderRole: ctx.coderRole, refactorerRole: ctx.refactorerRole,
     pipelineFlags: ctx.pipelineFlags, config, logger, emitter, eventBase, session,
-    plannedTask: ctx.plannedTask, trackBudget: ctx.trackBudget, i
+    plannedTask: ctx.plannedTask, trackBudget: ctx.trackBudget, i, brainCtx: ctx.brainCtx
   });
   if (crResult.action === "return" || crResult.action === "retry") return crResult;
 
@@ -1117,7 +1161,8 @@ async function runSingleIteration(ctx) {
   const revResult = await runReviewerGateStage({
     pipelineFlags: ctx.pipelineFlags, reviewerRole: ctx.reviewerRole, config, logger, emitter, eventBase,
     session, trackBudget: ctx.trackBudget, i, reviewRules: ctx.reviewRules, task,
-    repeatDetector: ctx.repeatDetector, budgetSummary: ctx.budgetSummary, askQuestion: ctx.askQuestion
+    repeatDetector: ctx.repeatDetector, budgetSummary: ctx.budgetSummary, askQuestion: ctx.askQuestion,
+    brainCtx: ctx.brainCtx
   });
   if (revResult.action === "return" || revResult.action === "retry") return revResult;
   const review = revResult.review;
@@ -1143,7 +1188,7 @@ async function runSingleIteration(ctx) {
 
   const solomonResult = await handleSolomonCheck({
     config, session, emitter, eventBase, logger, task, i, askQuestion: ctx.askQuestion,
-    ciEnabled, blockingIssues: review?.blocking_issues
+    ciEnabled, blockingIssues: review?.blocking_issues, brainCtx: ctx.brainCtx
   });
   if (solomonResult.action === "pause") return { action: "return", result: solomonResult.result };