karajan-code 2.0.1 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "karajan-code",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "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/config.js

@@ -45,6 +45,7 @@ const DEFAULTS = {
   },
   review_mode: "standard",
   max_iterations: 5,
+  hu_max_iterations: 3,
   max_budget_usd: null,
   review_rules: "./.karajan/review-rules.md",
   coder_rules: "./.karajan/coder-rules.md",

package/src/git/hu-automation.js

@@ -0,0 +1,138 @@
+/**
+ * Per-HU git automation: branch, commit, push, PR per HU story.
+ * Called from the HU sub-pipeline wrapper in orchestrator.js.
+ */
+import { commitAll, pushBranch, createPullRequest, hasChanges } from "../utils/git.js";
+import { runCommand } from "../utils/process.js";
+
+/**
+ * Build a git-safe branch name for an HU story.
+ * @param {string} prefix - e.g. "feat/"
+ * @param {object} story - HU story {id, title}
+ * @returns {string}
+ */
+export function buildHuBranchName(prefix, story) {
+  const baseSlug = String(story.title || story.id || "hu")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40);
+  return `${prefix}${story.id}-${baseSlug}`;
+}
+
+/**
+ * Resolve the base branch for a given HU based on its dependencies.
+ * If it has no blocked_by, uses config.base_branch.
+ * If it has parents, uses the last-created parent branch (assumes parents ran first).
+ *
+ * @param {object} story - the HU story
+ * @param {Map<string,string>} huBranches - map of huId → branchName (already created)
+ * @param {string} baseBranch - config.base_branch fallback
+ * @returns {string} base branch name
+ */
+export function resolveHuBase(story, huBranches, baseBranch) {
+  const parents = story.blocked_by || [];
+  if (parents.length === 0) return baseBranch;
+  // Walk parents in reverse order of declaration to find the most recent one
+  for (let i = parents.length - 1; i >= 0; i--) {
+    const parentBranch = huBranches.get(parents[i]);
+    if (parentBranch) return parentBranch;
+  }
+  return baseBranch;
+}
+
+/**
+ * Create a branch for an HU starting from its resolved base.
+ * Returns the branch name created (or null if git automation is disabled).
+ *
+ * @param {object} params
+ * @param {object} params.story
+ * @param {Map} params.huBranches
+ * @param {object} params.config
+ * @param {object} params.logger
+ * @returns {Promise<string|null>}
+ */
+export async function prepareHuBranch({ story, huBranches, config, logger }) {
+  if (!config.git?.auto_commit && !config.git?.auto_push && !config.git?.auto_pr) {
+    return null;
+  }
+  const baseBranch = resolveHuBase(story, huBranches, config.base_branch || "main");
+  const prefix = config.git?.branch_prefix || "feat/";
+  const branchName = buildHuBranchName(prefix, story);
+
+  // Checkout from the resolved base. Use `git checkout -B` to overwrite if rerun.
+  const res = await runCommand("git", ["checkout", "-B", branchName, baseBranch], {});
+  if (res.exitCode !== 0) {
+    logger.warn(`HU git: failed to create branch ${branchName} from ${baseBranch}: ${res.stderr}`);
+    return null;
+  }
+  huBranches.set(story.id, branchName);
+  logger.info(`HU ${story.id}: branch '${branchName}' from '${baseBranch}'`);
+  return branchName;
+}
+
+/**
+ * After an HU is approved, commit its changes and optionally push + create PR.
+ *
+ * @param {object} params
+ * @param {object} params.story
+ * @param {string} params.branchName
+ * @param {object} params.config
+ * @param {object} params.logger
+ * @returns {Promise<{committed: boolean, pushed: boolean, prUrl: string|null}>}
+ */
+export async function finalizeHuCommit({ story, branchName, config, logger }) {
+  const result = { committed: false, pushed: false, prUrl: null };
+  if (!branchName) return result;
+
+  const changed = await hasChanges();
+  if (!changed) {
+    logger.info(`HU ${story.id}: no changes to commit`);
+    return result;
+  }
+
+  const title = story.title || story.id;
+  const commitMsg = `feat(${story.id}): ${title}`;
+  if (config.git?.auto_commit) {
+    const commitRes = await commitAll(commitMsg);
+    if (commitRes) {
+      result.committed = true;
+      logger.info(`HU ${story.id}: committed on '${branchName}'`);
+    }
+  }
+
+  if (config.git?.auto_push && result.committed) {
+    try {
+      await pushBranch(branchName);
+      result.pushed = true;
+      logger.info(`HU ${story.id}: pushed '${branchName}'`);
+    } catch (err) {
+      logger.warn(`HU ${story.id}: push failed: ${err.message}`);
+    }
+  }
+
+  if (config.git?.auto_pr && result.pushed) {
+    try {
+      const prBody = [
+        `## HU ${story.id}: ${title}`,
+        "",
+        story.certified?.text || "",
+        "",
+        "### Acceptance criteria",
+        ...(story.acceptance_criteria || []).map(c => `- ${c}`)
+      ].join("\n");
+      const url = await createPullRequest({
+        baseBranch: config.base_branch || "main",
+        branch: branchName,
+        title: commitMsg,
+        body: prBody
+      });
+      result.prUrl = url;
+      logger.info(`HU ${story.id}: PR created ${url}`);
+    } catch (err) {
+      logger.warn(`HU ${story.id}: PR creation failed: ${err.message}`);
+    }
+  }
+
+  return result;
+}

package/src/hu/auto-generator.js

@@ -0,0 +1,163 @@
+/**
+ * HU Auto-Generator — converts triage subtasks (+ researcher/architect context)
+ * into a certified HU batch ready for hu-sub-pipeline execution.
+ *
+ * Input: original task, triage subtasks, detected stack, researcher/architect context.
+ * Output: HU batch with setup HU (when needed), task HUs with per-HU task_type,
+ *         and a dependency graph (setup blocks everything; remaining linear by default).
+ */
+
+/**
+ * Classify a subtask into a Karajan task_type.
+ * Maps free-text subtask descriptions to {infra|sw|add-tests|doc|refactor|nocode}.
+ */
+export function classifyTaskType(text) {
+  if (!text || typeof text !== "string") return "sw";
+  const t = text.toLowerCase();
+  // Order matters: no-code beats infra (Zapier/Notion setups are no-code, not infra)
+  if (/\b(no-code|nocode|zapier|make\.com|airtable|notion)\b/.test(t)) return "nocode";
+  if (/\b(setup|install|init(?:ialize|iate)?|configure|scaffold|bootstrap)\b/.test(t)) return "infra";
+  if (/\b(docker|ci\/cd|pipeline|deploy|workflow\.yml|github actions?)\b/.test(t)) return "infra";
+  if (/\b(tests?|coverage|spec|vitest|jest|mocha|playwright)\b/.test(t) && !/\b(component|feature|endpoint)\b/.test(t)) return "add-tests";
+  if (/\b(readme|docs?|documentation|guide|tutorial)\b/.test(t)) return "doc";
+  if (/\b(refactor|cleanup|reorganiz|restructure|extract)\b/.test(t)) return "refactor";
+  return "sw";
+}
+
+/**
+ * Decide whether a setup HU is needed.
+ * Needed when: project is new OR stack hints suggest new dependencies.
+ */
+export function needsSetupHu({ isNewProject = false, stackHints = [], subtasks = [] }) {
+  if (isNewProject) return true;
+  if (stackHints.length > 0) return true;
+  // Subtasks mentioning a framework/tool suggest fresh setup
+  const setupKeywords = /\b(npm init|package\.json|workspace|monorepo|vite|vitest|express|astro|next\.js|nestjs)\b/i;
+  return subtasks.some(s => setupKeywords.test(s));
+}
+
+/**
+ * Build the setup HU story from stack hints + subtasks.
+ */
+function buildSetupHu({ stackHints, subtasks, originalTask }) {
+  const hintList = stackHints.length > 0
+    ? stackHints.map(h => `- ${h}`).join("\n")
+    : "- Detect required dependencies from task and install them";
+  const certifiedText = [
+    `**Setup project infrastructure and dependencies.**`,
+    ``,
+    `Original goal: ${originalTask}`,
+    ``,
+    `**Scope:**`,
+    `- Initialize project structure (package.json, workspaces if monorepo)`,
+    `- Install all dependencies required by the task`,
+    `- Configure tooling (test framework, linter, build tool)`,
+    `- Create .env.example with all required env vars`,
+    `- Verify install works (npm install, npm run test --run)`,
+    ``,
+    `**Stack hints:**`,
+    hintList
+  ].join("\n");
+  return {
+    id: "HU-01",
+    title: "Setup project infrastructure",
+    task_type: "infra",
+    status: "certified",
+    blocked_by: [],
+    certified: { text: certifiedText },
+    acceptance_criteria: [
+      "Project builds without errors (npm install succeeds)",
+      "Test framework is installed and 'npm test' runs (even with 0 tests)",
+      "All declared dependencies match what the task requires",
+      ".env.example exists with documented variables"
+    ]
+  };
+}
+
+/**
+ * Build a task HU story from a subtask description.
+ */
+function buildTaskHu({ id, subtask, originalTask, blockedBy }) {
+  const taskType = classifyTaskType(subtask);
+  const certifiedText = [
+    `**${subtask}**`,
+    ``,
+    `Part of: ${originalTask}`,
+    ``,
+    `**Scope:** implement this subtask only. Do not touch unrelated subtasks.`
+  ].join("\n");
+  return {
+    id,
+    title: subtask.length > 80 ? subtask.slice(0, 77) + "..." : subtask,
+    task_type: taskType,
+    status: "certified",
+    blocked_by: blockedBy,
+    certified: { text: certifiedText },
+    acceptance_criteria: [
+      `Subtask '${subtask}' is implemented`,
+      `Unit tests cover the new code (where applicable)`,
+      `No regressions in existing functionality`
+    ]
+  };
+}
+
+/**
+ * Main entry point: generate a certified HU batch from triage output.
+ *
+ * @param {object} input
+ * @param {string} input.originalTask - the user's raw task
+ * @param {string[]} input.subtasks - triage.subtasks array
+ * @param {string[]} [input.stackHints] - detected stack keywords (e.g. ["nodejs", "vitest"])
+ * @param {boolean} [input.isNewProject] - true when projectDir is empty/fresh
+ * @param {string} [input.researcherContext] - researcher output (optional, used for better HU text)
+ * @param {string} [input.architectContext] - architect output (optional, used for dep graph)
+ * @returns {{ stories: object[], total: number, certified: number, generated: true }}
+ */
+export function generateHuBatch({
+  originalTask,
+  subtasks = [],
+  stackHints = [],
+  isNewProject = false,
+  researcherContext = null,
+  architectContext = null
+}) {
+  if (!originalTask || typeof originalTask !== "string") {
+    throw new Error("generateHuBatch: originalTask is required");
+  }
+  if (!Array.isArray(subtasks) || subtasks.length === 0) {
+    throw new Error("generateHuBatch: subtasks array is required");
+  }
+
+  const stories = [];
+  const needsSetup = needsSetupHu({ isNewProject, stackHints, subtasks });
+  let nextId = 1;
+
+  if (needsSetup) {
+    stories.push(buildSetupHu({ stackHints, subtasks, originalTask }));
+    nextId = 2;
+  }
+
+  // Task HUs: linear dependency chain after setup (conservative default).
+  // Architect context could later inform parallel-safe groupings.
+  const setupId = needsSetup ? "HU-01" : null;
+  let previousId = setupId;
+  for (const subtask of subtasks) {
+    const id = `HU-${String(nextId).padStart(2, "0")}`;
+    const blockedBy = [];
+    if (setupId) blockedBy.push(setupId);
+    // Conservative: also depend on previous task HU to enforce linear execution.
+    // Later phases can relax this with architect-informed graph.
+    if (previousId && previousId !== setupId) blockedBy.push(previousId);
+    stories.push(buildTaskHu({ id, subtask, originalTask, blockedBy }));
+    previousId = id;
+    nextId += 1;
+  }
+
+  return {
+    stories,
+    total: stories.length,
+    certified: stories.length,
+    generated: true,
+    source: { triage_subtasks: subtasks.length, researcher: Boolean(researcherContext), architect: Boolean(architectContext) }
+  };
+}

package/src/orchestrator/hu-sub-pipeline.js

@@ -120,7 +120,7 @@ async function runSingleHu({ storyId, batch, batchSessionId, runIterationFn, emi
   }));
 
   try {
-    const iterResult = await runIterationFn(huTask);
+    const iterResult = await runIterationFn(huTask, story);
     const approved = Boolean(iterResult?.approved);
 
     // --- Transition to reviewing (post-coder, pre-reviewer evaluation) ---

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,12 +681,17 @@ 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();
   await updateGitignoreForStack(projectDir, { stageResults, task, logger });
 
+  // --- Auto-HU: when triage recommended decomposition and no manual huFile, generate HU batch ---
+  await maybeGenerateAutoHuBatch({
+    flags, stageResults, task, plannedTask, logger, emitter, eventBase, projectDir, session
+  });
+
   // --- Auto-install skills based on task + planner output + project detection ---
   // Runs AFTER triage and planner so that the planned task text (which includes
   // planner output like implementation steps) is available for keyword detection.
@@ -698,6 +721,87 @@ async function runPreLoopStages({ config, logger, emitter, eventBase, session, f
   return { plannedTask, updatedConfig };
 }
 
+/**
+ * Auto-generate HU batch from triage decomposition when no manual huFile is present.
+ * Runs after researcher/architect/planner so that context is available for better HUs.
+ * Sets stageResults.huReviewer so needsSubPipeline picks it up later.
+ */
+async function maybeGenerateAutoHuBatch({ flags, stageResults, task, plannedTask, logger, emitter, eventBase, projectDir, session }) {
+  // Skip if user passed a manual hu-file
+  if (flags?.huFile) return;
+  // Skip if hu-reviewer already produced a batch (manual enable + PG stories)
+  if (stageResults.huReviewer) return;
+  // Need triage decomposition recommendation
+  const shouldDecompose = stageResults.triage?.shouldDecompose;
+  const subtasks = stageResults.triage?.subtasks;
+  if (!shouldDecompose || !Array.isArray(subtasks) || subtasks.length < 2) return;
+
+  const { generateHuBatch } = await import("./hu/auto-generator.js");
+
+  // Detect if project is new: empty dir or only .git/.karajan/.gitignore
+  let isNewProject = false;
+  try {
+    const fs = await import("node:fs/promises");
+    const entries = await fs.readdir(projectDir);
+    const relevant = entries.filter(e => !e.startsWith(".git") && e !== ".karajan" && e !== ".gitignore");
+    isNewProject = relevant.length === 0;
+  } catch { /* ignore */ }
+
+  // Extract stack hints from planner + architect output
+  const stackHints = [];
+  const combined = `${stageResults.planner?.plan || ""} ${stageResults.architect?.architecture ? JSON.stringify(stageResults.architect.architecture) : ""} ${task}`.toLowerCase();
+  const stackKeywords = ["express", "vite", "vitest", "jest", "next", "astro", "react", "vue", "svelte", "fastapi", "django", "spring", "gin", "nestjs", "monorepo", "workspaces"];
+  for (const kw of stackKeywords) {
+    if (combined.includes(kw)) stackHints.push(kw);
+  }
+
+  const batch = generateHuBatch({
+    originalTask: task,
+    subtasks,
+    stackHints,
+    isNewProject,
+    researcherContext: stageResults.researcher?.summary || null,
+    architectContext: stageResults.architect?.architecture ? JSON.stringify(stageResults.architect.architecture) : null
+  });
+
+  // Persist batch to HU store so hu-sub-pipeline can update story status via saveHuBatch.
+  // Use session.id as batchSessionId.
+  const batchSessionId = `auto-${session.id}`;
+  try {
+    const fs = await import("node:fs/promises");
+    const path = await import("node:path");
+    const { getKarajanHome } = await import("./utils/paths.js");
+    const huDir = path.join(getKarajanHome(), "hu", batchSessionId);
+    await fs.mkdir(huDir, { recursive: true });
+    const persistBatch = {
+      session_id: batchSessionId,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      stories: batch.stories
+    };
+    await fs.writeFile(path.join(huDir, "batch.json"), JSON.stringify(persistBatch, null, 2));
+  } catch (err) {
+    logger.warn(`Auto-HU: failed to persist batch (${err.message}) — sub-pipeline will use in-memory fallback`);
+  }
+
+  // Wrap in format compatible with needsSubPipeline + runHuSubPipeline
+  stageResults.huReviewer = {
+    ok: true,
+    stories: batch.stories,
+    total: batch.total,
+    certified: batch.certified,
+    batchSessionId,
+    auto_generated: true,
+    source: batch.source
+  };
+
+  logger.info(`Auto-HU: generated ${batch.total} stories (${batch.source.triage_subtasks} subtasks${isNewProject ? ", new project" : ""}${stackHints.length ? `, stack: ${stackHints.join(",")}` : ""})`);
+  emitProgress(emitter, makeEvent("hu:auto-generated", { ...eventBase, stage: "hu-auto-gen" }, {
+    message: `Auto-generated ${batch.total} HU(s) from triage decomposition`,
+    detail: { total: batch.total, subtasks: batch.source.triage_subtasks, isNewProject, stackHints }
+  }));
+}
+
 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 };
@@ -870,11 +974,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 +987,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 +1066,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 +1240,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 +1365,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 +1486,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 +1524,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;
   }
 
@@ -1452,9 +1618,33 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
         detail: { total: ctx.stageResults.huReviewer.total, certified: ctx.stageResults.huReviewer.certified }
       }));
 
+      // Per-HU pipeline: focused max_iterations, fresh Brain state, own git branch.
+      const originalMaxIterations = ctx.config.max_iterations;
+      const huMaxIterations = ctx.config.hu_max_iterations ?? 3;
+      const huBranches = new Map();
+      const { prepareHuBranch, finalizeHuCommit } = await import("./git/hu-automation.js");
       const subPipelineResult = await runHuSubPipeline({
         huReviewerResult: ctx.stageResults.huReviewer,
-        runIterationFn: async (huTask) => runIterationLoop(ctx, { task: huTask, askQuestion, emitter, logger }),
+        runIterationFn: async (huTask, story) => {
+          ctx.config.max_iterations = huMaxIterations;
+          if (ctx.brainCtx?.enabled) {
+            ctx.brainCtx.extensionCount = 0;
+            const { createBrainContext } = await import("./orchestrator/brain-coordinator.js");
+            const fresh = createBrainContext({ enabled: true });
+            ctx.brainCtx.feedbackQueue = fresh.feedbackQueue;
+            ctx.brainCtx.verificationTracker = fresh.verificationTracker;
+          }
+          const branchName = await prepareHuBranch({ story, huBranches, config: ctx.config, logger });
+          try {
+            const result = await runIterationLoop(ctx, { task: huTask, askQuestion, emitter, logger });
+            if (result?.approved) {
+              await finalizeHuCommit({ story, branchName, config: ctx.config, logger });
+            }
+            return result;
+          } finally {
+            ctx.config.max_iterations = originalMaxIterations;
+          }
+        },
         emitter,
         eventBase: ctx.eventBase,
         logger,

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 }
+  }));
+}