karajan-code 2.0.0 → 2.0.2

package/package.json

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

package/src/agents/claude-agent.js

@@ -116,18 +116,45 @@ function extractTextFromStreamJson(raw) {
  * Create a wrapping onOutput that parses stream-json lines and forwards
  * meaningful content (assistant text, tool usage) to the original callback.
  */
+function summarizeToolCall(name, input = {}) {
+  // Produce concise human-readable action line from tool_use block
+  const rel = (p) => String(p || "").replace(process.cwd() + "/", "");
+  switch (name) {
+    case "Read": return `Read ${rel(input.file_path)}`;
+    case "Write": return `Write ${rel(input.file_path)}`;
+    case "Edit": return `Edit ${rel(input.file_path)}`;
+    case "MultiEdit": return `MultiEdit ${rel(input.file_path)} (${(input.edits || []).length} edits)`;
+    case "NotebookEdit": return `NotebookEdit ${rel(input.notebook_path)}`;
+    case "Glob": return `Glob ${input.pattern || ""}`.trim();
+    case "Grep": return `Grep "${(input.pattern || "").slice(0, 60)}"${input.path ? ` in ${rel(input.path)}` : ""}`;
+    case "Bash": {
+      const cmd = String(input.command || "").replace(/\s+/g, " ").slice(0, 100);
+      return `Bash $ ${cmd}`;
+    }
+    case "TodoWrite": return `Todo ${(input.todos || []).length} items`;
+    case "WebFetch": return `WebFetch ${input.url || ""}`;
+    case "WebSearch": return `WebSearch "${(input.query || "").slice(0, 60)}"`;
+    case "Task": return `Agent: ${input.subagent_type || "?"} — ${(input.description || "").slice(0, 60)}`;
+    default: return `${name}${Object.keys(input).length > 0 ? " (…)" : ""}`;
+  }
+}
+
 function createStreamJsonFilter(onOutput) {
   if (!onOutput) return null;
   return ({ stream, line }) => {
     try {
       const obj = JSON.parse(line);
-      // Forward assistant text messages
+      // Forward assistant content
       if (obj.type === "assistant" && obj.message?.content) {
         for (const block of obj.message.content) {
           if (block.type === "text" && block.text) {
-            onOutput({ stream, line: block.text.slice(0, 200) });
+            // Only emit first line of text for brevity
+            const firstLine = block.text.split("\n")[0].trim().slice(0, 120);
+            if (firstLine) onOutput({ stream, line: firstLine, kind: "text" });
           } else if (block.type === "tool_use") {
-            onOutput({ stream, line: `[tool: ${block.name}]` });
+            onOutput({ stream, line: summarizeToolCall(block.name, block.input), kind: "tool" });
+          } else if (block.type === "thinking" && block.thinking) {
+            onOutput({ stream, line: `thinking: ${block.thinking.slice(0, 80).replace(/\s+/g, " ")}…`, kind: "thinking" });
           }
         }
         return;
@@ -135,9 +162,9 @@ function createStreamJsonFilter(onOutput) {
       // Forward result
       if (obj.type === "result") {
         const summary = typeof obj.result === "string"
-          ? obj.result.slice(0, 200)
+          ? obj.result.split("\n")[0].slice(0, 120)
           : "result received";
-        onOutput({ stream, line: `[result] ${summary}` });
+        onOutput({ stream, line: `done: ${summary}` });
         return;
       }
     } catch { /* not JSON, forward raw */ }

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/architect-stage.js

@@ -7,7 +7,7 @@ import { ArchitectRole } from "../../roles/architect-role.js";
 import { createAgent } from "../../agents/index.js";
 import { createArchitectADRs } from "../../planning-game/architect-adrs.js";
 import { addCheckpoint } from "../../session-store.js";
-import { emitProgress, makeEvent } from "../../utils/events.js";
+import { emitProgress, makeEvent, emitAgentOutput } from "../../utils/events.js";
 import { createStallDetector } from "../../utils/stall-detector.js";
 
 async function handleArchitectClarification({ architectOutput, askQuestion, config, logger, emitter, eventBase, session, architectOnOutput, architectProvider, coderRole, researchContext, discoverResult, triageLevel, trackBudget }) {
@@ -77,12 +77,7 @@ export async function runArchitectStage({ config, logger, emitter, eventBase, se
       detail: { architect: architectProvider, provider: architectProvider, executorType: "agent" }
     })
   );
-  const architectOnOutput = ({ stream, line }) => {
-    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "architect" }, {
-      message: line,
-      detail: { stream, agent: architectProvider }
-    }));
-  };
+  const architectOnOutput = (payload) => emitAgentOutput(emitter, eventBase, "architect", architectProvider, payload);
   const architectStall = createStallDetector({
     onOutput: architectOnOutput, emitter, eventBase, stage: "architect", provider: architectProvider
   });

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

@@ -10,13 +10,13 @@ import { addCheckpoint, markSessionStatus, saveSession } from "../../session-sto
 import { generateDiff, getUntrackedFiles } from "../../review/diff-generator.js";
 import { evaluateTddPolicy } from "../../review/tdd-policy.js";
 import { buildDeferredContext } from "../../review/scope-filter.js";
-import { emitProgress, makeEvent } from "../../utils/events.js";
+import { emitProgress, makeEvent, emitAgentOutput } from "../../utils/events.js";
 import { runCoderWithFallback } from "../agent-fallback.js";
 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,12 +26,18 @@ export async function runCoderStage({ coderRoleInstance, coderRole, config, logg
     })
   );
 
-  const coderOnOutput = ({ stream, line }) => {
-    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "coder" }, {
-      message: line,
-      detail: { stream, agent: coderRole.provider }
-    }));
-  };
+  // 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 = (payload) => emitAgentOutput(emitter, eventBase, "coder", coderRole.provider, payload);
   const coderStall = createStallDetector({
     onOutput: coderOnOutput, emitter, eventBase, stage: "coder", provider: coderRole.provider
   });
@@ -40,7 +46,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 +129,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 }) {
@@ -142,12 +182,7 @@ export async function runRefactorerStage({ refactorerRole, config, logger, emitt
       detail: { refactorer: refactorerRole.provider, provider: refactorerRole.provider, executorType: "agent" }
     })
   );
-  const refactorerOnOutput = ({ stream, line }) => {
-    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "refactorer" }, {
-      message: line,
-      detail: { stream, agent: refactorerRole.provider }
-    }));
-  };
+  const refactorerOnOutput = (payload) => emitAgentOutput(emitter, eventBase, "refactorer", refactorerRole.provider, payload);
   const refactorerStall = createStallDetector({
     onOutput: refactorerOnOutput, emitter, eventBase, stage: "refactorer", provider: refactorerRole.provider
   });

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

@@ -6,7 +6,7 @@
 import { PlannerRole } from "../../roles/planner-role.js";
 import { createAgent } from "../../agents/index.js";
 import { addCheckpoint, markSessionStatus } from "../../session-store.js";
-import { emitProgress, makeEvent } from "../../utils/events.js";
+import { emitProgress, makeEvent, emitAgentOutput } from "../../utils/events.js";
 import { parsePlannerOutput } from "../../prompts/planner.js";
 import { createStallDetector } from "../../utils/stall-detector.js";
 
@@ -21,12 +21,7 @@ export async function runPlannerStage({ config, logger, emitter, eventBase, sess
     })
   );
 
-  const plannerOnOutput = ({ stream, line }) => {
-    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "planner" }, {
-      message: line,
-      detail: { stream, agent: plannerRole.provider }
-    }));
-  };
+  const plannerOnOutput = (payload) => emitAgentOutput(emitter, eventBase, "planner", plannerRole.provider, payload);
   const plannerStall = createStallDetector({
     onOutput: plannerOnOutput, emitter, eventBase, stage: "planner", provider: plannerRole.provider
   });

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

@@ -5,7 +5,7 @@
 
 import { ResearcherRole } from "../../roles/researcher-role.js";
 import { addCheckpoint } from "../../session-store.js";
-import { emitProgress, makeEvent } from "../../utils/events.js";
+import { emitProgress, makeEvent, emitAgentOutput } from "../../utils/events.js";
 import { createStallDetector } from "../../utils/stall-detector.js";
 
 export async function runResearcherStage({ config, logger, emitter, eventBase, session, coderRole, trackBudget }) {
@@ -20,12 +20,7 @@ export async function runResearcherStage({ config, logger, emitter, eventBase, s
     })
   );
 
-  const researcherOnOutput = ({ stream, line }) => {
-    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "researcher" }, {
-      message: line,
-      detail: { stream, agent: researcherProvider }
-    }));
-  };
+  const researcherOnOutput = (payload) => emitAgentOutput(emitter, eventBase, "researcher", researcherProvider, payload);
   const researcherStall = createStallDetector({
     onOutput: researcherOnOutput, emitter, eventBase, stage: "researcher", provider: researcherProvider
   });

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

@@ -7,7 +7,7 @@ import { addCheckpoint, markSessionStatus, saveSession } from "../../session-sto
 import { generateDiff } from "../../review/diff-generator.js";
 import { validateReviewResult } from "../../review/schema.js";
 import { filterReviewScope, buildDeferredContext } from "../../review/scope-filter.js";
-import { emitProgress, makeEvent } from "../../utils/events.js";
+import { emitProgress, makeEvent, emitAgentOutput } from "../../utils/events.js";
 import { runReviewerWithFallback } from "../reviewer-fallback.js";
 import { invokeSolomon } from "../solomon-escalation.js";
 import { detectRateLimit } from "../../utils/rate-limit-detector.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,
@@ -200,12 +226,7 @@ export async function runReviewerStage({ reviewerRole, config, logger, emitter,
     };
   }
 
-  const reviewerOnOutput = ({ stream, line }) => {
-    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "reviewer" }, {
-      message: line,
-      detail: { stream, agent: reviewerRole.provider }
-    }));
-  };
+  const reviewerOnOutput = (payload) => emitAgentOutput(emitter, eventBase, "reviewer", reviewerRole.provider, payload);
   const reviewerStall = createStallDetector({
     onOutput: reviewerOnOutput, emitter, eventBase, stage: "reviewer", provider: reviewerRole.provider
   });
@@ -326,13 +347,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 +380,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/stages/triage-stage.js

@@ -5,7 +5,7 @@
 
 import { TriageRole } from "../../roles/triage-role.js";
 import { addCheckpoint } from "../../session-store.js";
-import { emitProgress, makeEvent } from "../../utils/events.js";
+import { emitProgress, makeEvent, emitAgentOutput } from "../../utils/events.js";
 import { selectModelsForRoles } from "../../utils/model-selector.js";
 import { createStallDetector } from "../../utils/stall-detector.js";
 
@@ -53,12 +53,7 @@ export async function runTriageStage({ config, logger, emitter, eventBase, sessi
     })
   );
 
-  const triageOnOutput = ({ stream, line }) => {
-    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "triage" }, {
-      message: line,
-      detail: { stream, agent: triageProvider }
-    }));
-  };
+  const triageOnOutput = (payload) => emitAgentOutput(emitter, eventBase, "triage", triageProvider, payload);
   const triageStall = createStallDetector({
     onOutput: triageOnOutput, emitter, eventBase, stage: "triage", provider: triageProvider
   });

package/src/orchestrator.js

@@ -71,14 +71,20 @@ export const parseCheckpointAnswer = _parseCheckpointAnswer;
 
 // PG card "In Progress" logic moved to src/planning-game/pipeline-adapter.js → initPgAdapter()
 
-async function runPlanningPhases({ config, logger, emitter, eventBase, session, stageResults, pipelineFlags, coderRole, trackBudget, task, askQuestion }) {
+async function runPlanningPhases({ config, logger, emitter, eventBase, session, stageResults, pipelineFlags, coderRole, trackBudget, task, askQuestion, brainCtx }) {
   let researchContext = null;
   let plannedTask = task;
 
+  // Brain: track compression across pre-loop roles
+  const brainCompress = brainCtx?.enabled
+    ? (await import("./orchestrator/brain-coordinator.js")).processRoleOutput
+    : null;
+
   if (pipelineFlags.researcherEnabled) {
     const researcherResult = await runResearcherStage({ config, logger, emitter, eventBase, session, coderRole, trackBudget });
     researchContext = researcherResult.researchContext;
     stageResults.researcher = researcherResult.stageResult;
+    if (brainCompress) brainCompress(brainCtx, { roleName: "researcher", output: researcherResult.stageResult, iteration: 0 });
   }
 
   // --- Architect (between researcher and planner) ---
@@ -93,6 +99,7 @@ async function runPlanningPhases({ config, logger, emitter, eventBase, session,
     });
     architectContext = architectResult.architectContext;
     stageResults.architect = architectResult.stageResult;
+    if (brainCompress) brainCompress(brainCtx, { roleName: "architect", output: architectResult.stageResult, iteration: 0 });
   }
 
   const triageDecomposition = stageResults.triage?.shouldDecompose ? stageResults.triage.subtasks : null;
@@ -101,6 +108,7 @@ async function runPlanningPhases({ config, logger, emitter, eventBase, session,
     const plannerResult = await runPlannerStage({ config, logger, emitter, eventBase, session, plannerRole, researchContext, architectContext, triageDecomposition, trackBudget });
     plannedTask = plannerResult.plannedTask;
     stageResults.planner = plannerResult.stageResult;
+    if (brainCompress) brainCompress(brainCtx, { roleName: "planner", output: plannerResult.stageResult, iteration: 0 });
 
     await tryCiComment({
       config, session, logger,
@@ -201,16 +209,16 @@ async function handleStandbyResult({ stageResult, session, emitter, eventBase, i
 
 function emitSolomonAlerts(alerts, emitter, eventBase, logger) {
   for (const alert of alerts) {
-    emitProgress(emitter, makeEvent("solomon:alert", { ...eventBase, stage: "solomon" }, {
+    emitProgress(emitter, makeEvent("brain:rules-alert", { ...eventBase, stage: "brain" }, {
       status: alert.severity === "critical" ? "fail" : "warn",
       message: alert.message,
       detail: alert.detail
     }));
-    logger.warn(`Solomon alert [${alert.rule}]: ${alert.message}`);
+    logger.warn(`Rules alert [${alert.rule}]: ${alert.message}`);
   }
 }
 
-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 +228,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) {
@@ -276,7 +321,7 @@ async function checkSolomonCriticalAlerts({ rulesResult, askQuestion, session, i
 }
 
 
-async function handlePostLoopStages({ config, session, emitter, eventBase, coderRole, trackBudget, i, task, stageResults, ciEnabled, testerEnabled, securityEnabled, askQuestion, logger }) {
+async function handlePostLoopStages({ config, session, emitter, eventBase, coderRole, trackBudget, i, task, stageResults, ciEnabled, testerEnabled, securityEnabled, askQuestion, logger, brainCtx }) {
   const postLoopDiff = await generateDiff({ baseRef: session.session_start_sha });
 
   if (testerEnabled) {
@@ -290,6 +335,11 @@ async function handlePostLoopStages({ config, session, emitter, eventBase, coder
       session.last_reviewer_feedback = `Tester FAILED — fix these issues:\n${summary}`;
       await saveSession(session);
       if (testerResult.stageResult) stageResults.tester = testerResult.stageResult;
+      // Brain: push tester failure into feedback queue + compress for next coder iteration
+      if (brainCtx?.enabled) {
+        const { processRoleOutput } = await import("./orchestrator/brain-coordinator.js");
+        processRoleOutput(brainCtx, { roleName: "tester", output: testerResult.stageResult, iteration: i });
+      }
       return { action: "continue" };
     }
     if (testerResult.stageResult) {
@@ -309,6 +359,11 @@ async function handlePostLoopStages({ config, session, emitter, eventBase, coder
       session.last_reviewer_feedback = `Security FAILED — fix these issues:\n${summary}`;
       await saveSession(session);
       if (securityResult.stageResult) stageResults.security = securityResult.stageResult;
+      // Brain: push security findings into feedback queue + compress for next coder iteration
+      if (brainCtx?.enabled) {
+        const { processRoleOutput } = await import("./orchestrator/brain-coordinator.js");
+        processRoleOutput(brainCtx, { roleName: "security", output: securityResult.stageResult, iteration: i });
+      }
       return { action: "continue" };
     }
     if (securityResult.stageResult) {
@@ -457,7 +512,7 @@ async function handleReviewerRetryAndSolomon({ config, session, emitter, eventBa
 }
 
 
-async function runPreLoopStages({ config, logger, emitter, eventBase, session, flags, pipelineFlags, coderRole, trackBudget, task, askQuestion, pgTaskId, pgProject, stageResults }) {
+async function runPreLoopStages({ config, logger, emitter, eventBase, session, flags, pipelineFlags, coderRole, trackBudget, task, askQuestion, pgTaskId, pgProject, stageResults, brainCtx }) {
   // --- HU Reviewer (first stage, before everything else, opt-in) ---
   const huFile = flags.huFile || null;
   if (flags.enableHuReviewer !== undefined) pipelineFlags.huReviewerEnabled = Boolean(flags.enableHuReviewer);
@@ -626,7 +681,7 @@ async function runPreLoopStages({ config, logger, emitter, eventBase, session, f
   }
 
   // --- Researcher → Planner ---
-  const { plannedTask } = await runPlanningPhases({ config: updatedConfig, logger, emitter, eventBase, session, stageResults, pipelineFlags, coderRole, trackBudget, task, askQuestion });
+  const { plannedTask } = await runPlanningPhases({ config: updatedConfig, logger, emitter, eventBase, session, stageResults, pipelineFlags, coderRole, trackBudget, task, askQuestion, brainCtx });
 
   // --- Update .gitignore with stack-specific entries based on planner/architect output ---
   const projectDir = updatedConfig.projectDir || process.cwd();
@@ -661,8 +716,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 +850,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 +860,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 });
@@ -833,11 +888,11 @@ async function runReviewerGateStage({ pipelineFlags, reviewerRole, config, logge
   return { action: "ok", review: reviewerResult.review };
 }
 
-async function handleApprovedReview({ config, session, emitter, eventBase, coderRole, trackBudget, i, task, stageResults, pipelineFlags, askQuestion, logger, gitCtx, budgetSummary, pgCard, pgProject, review, rtkTracker }) {
+async function handleApprovedReview({ config, session, emitter, eventBase, coderRole, trackBudget, i, task, stageResults, pipelineFlags, askQuestion, logger, gitCtx, budgetSummary, pgCard, pgProject, review, rtkTracker, brainCtx }) {
   session.reviewer_retry_count = 0;
   const postLoopResult = await handlePostLoopStages({
     config, session, emitter, eventBase, coderRole, trackBudget, i, task, stageResults,
-    ciEnabled: Boolean(config.ci?.enabled), testerEnabled: pipelineFlags.testerEnabled, securityEnabled: pipelineFlags.securityEnabled, askQuestion, logger
+    ciEnabled: Boolean(config.ci?.enabled), testerEnabled: pipelineFlags.testerEnabled, securityEnabled: pipelineFlags.securityEnabled, askQuestion, logger, brainCtx
   });
   if (postLoopResult.action === "return") return { action: "return", result: postLoopResult.result };
   if (postLoopResult.action === "continue") return { action: "continue" };
@@ -846,8 +901,72 @@ async function handleApprovedReview({ config, session, emitter, eventBase, coder
   return { action: "return", result };
 }
 
-async function handleMaxIterationsReached({ session, budgetSummary, emitter, eventBase, config, stageResults, logger, askQuestion, task, rtkTracker }) {
+async function handleMaxIterationsReached({ session, budgetSummary, emitter, eventBase, config, stageResults, logger, askQuestion, task, rtkTracker, brainCtx }) {
   const budget = budgetSummary();
+
+  // Brain-owned decision: max_iterations is guidance, not a hard rule.
+  // Brain evaluates the feedback queue state to decide extend / finalize / escalate.
+  // Solomon is only consulted if Brain cannot decide on its own.
+  if (brainCtx?.enabled) {
+    const entries = brainCtx.feedbackQueue?.entries || [];
+    const pending = entries.map(e => ({ source: e.source, category: e.category, severity: e.severity, description: e.description }));
+    const hasSecurity = entries.some(e => e.category === "security" || e.source === "security");
+    const hasCorrectness = entries.some(e => ["correctness", "tests"].includes(e.category));
+    const hasStyleOnly = entries.length > 0 && !hasSecurity && !hasCorrectness;
+
+    if (hasSecurity) {
+      // Brain: security issues unresolved → cannot finalize, escalate
+      logger.warn(`Brain: max_iterations reached with ${entries.filter(e => e.category === "security" || e.source === "security").length} unresolved security issue(s) — cannot finalize`);
+      return { paused: true, sessionId: session.id, question: "Brain: unresolved security issues at max_iterations. Review manually or extend pipeline.", context: "brain_security_block", pending };
+    }
+
+    if (hasCorrectness) {
+      // Brain: correctness/test issues pending → extend iterations (Brain's decision, not a rule)
+      logger.info(`Brain: max_iterations reached with ${entries.filter(e => ["correctness", "tests"].includes(e.category)).length} correctness issue(s) pending — extending iterations`);
+      session.reviewer_retry_count = 0;
+      await saveSession(session);
+      return { approved: false, sessionId: session.id, reason: "max_iterations_extended", extraIterations: Math.ceil(config.max_iterations / 2) };
+    }
+
+    if (entries.length === 0) {
+      // Brain: no pending feedback → last reviewer approved, finalize
+      logger.info("Brain: max_iterations reached with clean feedback queue — finalizing as approved");
+      return { approved: true, sessionId: session.id, reason: "brain_approved" };
+    }
+
+    // hasStyleOnly: genuine dilemma → Brain consults Solomon
+    logger.info(`Brain: max_iterations with ${entries.length} style-only issue(s) — consulting Solomon on dilemma`);
+    const { invokeSolomon: invokeSolomonAI } = await import("./orchestrator/solomon-escalation.js");
+    const solomonResult = await invokeSolomonAI({
+      config, logger, emitter, eventBase, stage: "max_iterations", askQuestion, session,
+      iteration: config.max_iterations,
+      conflict: {
+        stage: "brain-max-iterations",
+        task,
+        iterationCount: config.max_iterations,
+        maxIterations: config.max_iterations,
+        budget_usd: budget?.total_cost_usd || 0,
+        dilemma: `Max iterations reached with ${entries.length} style-only issue(s) pending. Accept as-is or request more work?`,
+        pendingIssues: pending,
+        history: [{ agent: "pipeline", feedback: session.last_reviewer_feedback || "Max iterations reached" }]
+      }
+    });
+    // Brain applies Solomon's decision
+    if (solomonResult.action === "approve") {
+      logger.info("Brain: Solomon advised approve for style-only pending — finalizing");
+      return { approved: true, sessionId: session.id, reason: "brain_solomon_approved" };
+    }
+    if (solomonResult.action === "continue") {
+      return { approved: false, sessionId: session.id, reason: "max_iterations_extended", extraIterations: solomonResult.extraIterations || Math.ceil(config.max_iterations / 2) };
+    }
+    if (solomonResult.action === "pause") {
+      return { paused: true, sessionId: session.id, question: solomonResult.question, context: "brain_solomon_dilemma" };
+    }
+    // Fallback: escalate to human
+    return { paused: true, sessionId: session.id, question: `Brain+Solomon cannot resolve: ${entries.length} pending issue(s) at max_iterations`, context: "max_iterations" };
+  }
+
+  // Legacy path (Brain disabled): original Solomon-driven flow
   const solomonResult = await invokeSolomon({
     config, logger, emitter, eventBase, stage: "max_iterations", askQuestion, session,
     iteration: config.max_iterations,
@@ -861,13 +980,11 @@ async function handleMaxIterationsReached({ session, budgetSummary, emitter, eve
     }
   });
 
-  // Solomon approved the work — treat as successful completion
   if (solomonResult.action === "approve") {
     logger.info("Solomon approved coder's work at max_iterations checkpoint");
     return { approved: true, sessionId: session.id, reason: "solomon_approved" };
   }
 
-  // Solomon says continue — extend iterations
   if (solomonResult.action === "continue") {
     if (solomonResult.humanGuidance) {
       session.last_reviewer_feedback = `Solomon guidance: ${solomonResult.humanGuidance}`;
@@ -1014,6 +1131,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;
@@ -1030,7 +1154,7 @@ async function initFlowContext({ task, config, logger, emitter, askQuestion, pgT
   ctx.stageResults = {};
   ctx.sonarState = { issuesInitial: null, issuesFinal: null };
 
-  const preLoopResult = await runPreLoopStages({ config, logger, emitter, eventBase: ctx.eventBase, session: ctx.session, flags, pipelineFlags: ctx.pipelineFlags, coderRole: ctx.coderRole, trackBudget: ctx.trackBudget, task, askQuestion, pgTaskId, pgProject, stageResults: ctx.stageResults });
+  const preLoopResult = await runPreLoopStages({ config, logger, emitter, eventBase: ctx.eventBase, session: ctx.session, flags, pipelineFlags: ctx.pipelineFlags, coderRole: ctx.coderRole, trackBudget: ctx.trackBudget, task, askQuestion, pgTaskId, pgProject, stageResults: ctx.stageResults, brainCtx: ctx.brainCtx });
   ctx.plannedTask = preLoopResult.plannedTask;
   ctx.config = preLoopResult.updatedConfig;
 
@@ -1094,7 +1218,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 +1241,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 +1268,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 };
 
@@ -1154,7 +1279,7 @@ async function runSingleIteration(ctx) {
       config, session, emitter, eventBase, coderRole: ctx.coderRole, trackBudget: ctx.trackBudget, i, task,
       stageResults: ctx.stageResults, pipelineFlags: ctx.pipelineFlags, askQuestion: ctx.askQuestion, logger,
       gitCtx: ctx.gitCtx, budgetSummary: ctx.budgetSummary, pgCard: ctx.pgCard, pgProject: ctx.pgProject, review,
-      rtkTracker: ctx.rtkTracker
+      rtkTracker: ctx.rtkTracker, brainCtx: ctx.brainCtx
     });
     if (approvedResult.action === "return" || approvedResult.action === "continue") return approvedResult;
   }
@@ -1275,7 +1400,7 @@ async function runIterationLoop(ctx, { task: loopTask, askQuestion, emitter, log
   }
 
   // Solomon decides whether to extend iterations or stop
-  const maxIterResult = await handleMaxIterationsReached({ session: ctx.session, budgetSummary: ctx.budgetSummary, emitter, eventBase: ctx.eventBase, config: ctx.config, stageResults: ctx.stageResults, logger, askQuestion, task: loopTask, rtkTracker: ctx.rtkTracker });
+  const maxIterResult = await handleMaxIterationsReached({ session: ctx.session, budgetSummary: ctx.budgetSummary, emitter, eventBase: ctx.eventBase, config: ctx.config, stageResults: ctx.stageResults, logger, askQuestion, task: loopTask, rtkTracker: ctx.rtkTracker, brainCtx: ctx.brainCtx });
 
   // Solomon said "continue" — extend iterations and keep going
   if (maxIterResult.reason === "max_iterations_extended") {
@@ -1313,7 +1438,7 @@ async function runIterationLoop(ctx, { task: loopTask, askQuestion, emitter, log
     }
 
     // Extended iterations also exhausted — final Solomon call
-    const finalResult = await handleMaxIterationsReached({ session: ctx.session, budgetSummary: ctx.budgetSummary, emitter, eventBase: ctx.eventBase, config: ctx.config, stageResults: ctx.stageResults, logger, askQuestion, task: loopTask, rtkTracker: ctx.rtkTracker });
+    const finalResult = await handleMaxIterationsReached({ session: ctx.session, budgetSummary: ctx.budgetSummary, emitter, eventBase: ctx.eventBase, config: ctx.config, stageResults: ctx.stageResults, logger, askQuestion, task: loopTask, rtkTracker: ctx.rtkTracker, brainCtx: ctx.brainCtx });
     return finalResult;
   }
 

package/src/utils/display.js

@@ -45,6 +45,7 @@ const ICONS = {
   "solomon:escalate": "\u26a0\ufe0f",
   "coder:standby": "\u23f3",
   "coder:standby_heartbeat": "\u23f3",
+  "agent:heartbeat": "\u23f3",
   "coder:standby_resume": "\u25b6\ufe0f",
   "budget:update": "\ud83d\udcb8",
   "iteration:end": "\u23f1\ufe0f",
@@ -84,7 +85,8 @@ const BAR = `${ANSI.dim}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u
 
 export function printHeader({ task, config }) {
   const version = DISPLAY_VERSION;
-  printBanner(version);
+  // Force banner: caller already gates on !jsonMode, so if we're here it's a human-readable run
+  printBanner(version, { force: true });
   console.log(`${ANSI.bold}Task:${ANSI.reset} ${task}`);
   console.log(
     `${ANSI.bold}Coder:${ANSI.reset} ${config.roles?.coder?.provider || config.coder} ${ANSI.dim}|${ANSI.reset} ${ANSI.bold}Reviewer:${ANSI.reset} ${config.roles?.reviewer?.provider || config.reviewer}`
@@ -437,6 +439,15 @@ const EVENT_HANDLERS = {
     console.log(`  \u251c\u2500 ${ANSI.yellow}${icon} Standby: ${remaining}s remaining${ANSI.reset}`);
   },
 
+  "agent:heartbeat": (event, icon) => {
+    const d = event.detail || {};
+    const provider = d.provider || "?";
+    const elapsed = d.elapsedMs ? Math.round(d.elapsedMs / 1000) : 0;
+    const silent = d.silenceMs ? Math.round(d.silenceMs / 1000) : 0;
+    const status = d.status === "waiting" ? `${ANSI.yellow}waiting (silent ${silent}s)` : `${ANSI.green}working`;
+    console.log(`  \u251c\u2500 ${ANSI.dim}${icon} ${provider} ${status}${ANSI.dim} — ${elapsed}s elapsed${ANSI.reset}`);
+  },
+
   "coder:standby_resume": (event, icon) => {
     console.log(`  \u251c\u2500 ${ANSI.green}${icon} Cooldown expired \u2014 resuming with ${event.detail?.coder || event.detail?.provider || "?"}${ANSI.reset}`);
   },
@@ -593,12 +604,16 @@ const EVENT_HANDLERS = {
     console.log(`  \u251c\u2500 ${ANSI.green}\ud83d\ude80 CI PR created: ${url}${ANSI.reset}`);
   },
 
-  "solomon:alert": (event) => {
-    console.log(`  \u251c\u2500 ${ANSI.yellow}\u2696\ufe0f Solomon alert: ${event.message || "conflict detected"}${ANSI.reset}`);
+  "brain:rules-alert": (event) => {
+    console.log(`  \u251c\u2500 ${ANSI.yellow}\u26a0\ufe0f  Rules alert: ${event.message || "anomaly detected"}${ANSI.reset}`);
   },
 
   "agent:output": (event) => {
     console.log(`  \u2502 ${ANSI.dim}${event.message}${ANSI.reset}`);
+  },
+
+  "agent:action": (event) => {
+    console.log(`  \u2502 ${ANSI.dim}\u2937 ${event.message}${ANSI.reset}`);
   }
 };
 
@@ -608,7 +623,6 @@ const EVENT_HANDLERS = {
 const QUIET_SUPPRESSED = new Set([
   "agent:output",
   "agent:stall",
-  "agent:heartbeat",
   "pipeline:simplify",
   "pipeline:analysis-only",
   "policies:resolved",

package/src/utils/events.js

@@ -21,3 +21,15 @@ export function makeEvent(type, base, extra = {}) {
     timestamp: new Date().toISOString()
   };
 }
+
+/**
+ * Standard agent output emitter. Routes tool invocations to agent:action
+ * (visible in quiet mode) and everything else to agent:output (verbose only).
+ */
+export function emitAgentOutput(emitter, eventBase, stage, provider, { stream, line, kind }) {
+  const eventType = kind === "tool" ? "agent:action" : "agent:output";
+  emitProgress(emitter, makeEvent(eventType, { ...eventBase, stage }, {
+    message: line,
+    detail: { stream, agent: provider, kind }
+  }));
+}