karajan-code 2.0.1 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "karajan-code",
-  "version": "2.0.1",
+  "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/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,7 +10,7 @@ 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";
@@ -37,12 +37,7 @@ 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 }
-    }));
-  };
+  const coderOnOutput = (payload) => emitAgentOutput(emitter, eventBase, "coder", coderRole.provider, payload);
   const coderStall = createStallDetector({
     onOutput: coderOnOutput, emitter, eventBase, stage: "coder", provider: coderRole.provider
   });
@@ -187,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";
@@ -226,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
   });

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,12 +209,12 @@ 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}`);
   }
 }
 
@@ -313,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) {
@@ -327,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) {
@@ -346,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) {
@@ -494,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);
@@ -663,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();
@@ -870,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" };
@@ -883,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,
@@ -898,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}`;
@@ -1074,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;
 
@@ -1199,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;
   }
@@ -1320,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") {
@@ -1358,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 }
+  }));
+}