karajan-code 2.2.1 → 2.3.1

package/package.json

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

package/src/agents/model-registry.js

@@ -1,64 +1,114 @@
 const modelRegistry = new Map();
 
 export function registerModel(name, { provider, pricing, deprecated } = {}) {
-  if (!name || typeof name !== "string") {
-    throw new Error("Model name must be a non-empty string");
-  }
-  if (!pricing || typeof pricing.input_per_million !== "number" || typeof pricing.output_per_million !== "number") {
-    throw new Error(`Model "${name}" requires pricing with input_per_million and output_per_million`);
-  }
-  modelRegistry.set(name, {
-    provider: provider || name.split("/")[0],
-    pricing: { input_per_million: pricing.input_per_million, output_per_million: pricing.output_per_million },
-    deprecated: deprecated || null,
-  });
+	if (!name || typeof name !== "string") {
+		throw new Error("Model name must be a non-empty string");
+	}
+	if (!pricing || typeof pricing.input_per_million !== "number" || typeof pricing.output_per_million !== "number") {
+		throw new Error(`Model "${name}" requires pricing with input_per_million and output_per_million`);
+	}
+	modelRegistry.set(name, {
+		name,
+		provider: provider || name.split("/")[0],
+		pricing: { input_per_million: pricing.input_per_million, output_per_million: pricing.output_per_million },
+		deprecated: deprecated || null,
+	});
+}
+
+export function registerModelAlias(alias, target, { provider } = {}) {
+	const entry = modelRegistry.get(target);
+	if (!entry) {
+		throw new Error(`Target model "${target}" for alias "${alias}" not found`);
+	}
+	modelRegistry.set(alias, {
+		...entry,
+		name: alias,
+		provider: provider || entry.provider
+	});
 }
 
 export function getModelPricing(name) {
-  const entry = modelRegistry.get(name);
-  return entry ? { ...entry.pricing } : null;
+	const entry = modelRegistry.get(name);
+	return entry ? { ...entry.pricing } : null;
 }
 
 export function isModelDeprecated(name) {
-  const entry = modelRegistry.get(name);
-  if (!entry?.deprecated) return false;
-  return new Date(entry.deprecated) <= new Date();
+	const entry = modelRegistry.get(name);
+	if (!entry?.deprecated) return false;
+	return new Date(entry.deprecated) <= new Date();
 }
 
 export function getModelInfo(name) {
-  const entry = modelRegistry.get(name);
-  if (!entry) return null;
-  return { name, provider: entry.provider, pricing: { ...entry.pricing }, deprecated: entry.deprecated };
+	const entry = modelRegistry.get(name);
+	if (!entry) return null;
+	return { name: entry.name, provider: entry.provider, pricing: { ...entry.pricing }, deprecated: entry.deprecated };
 }
 
 export function getRegisteredModels() {
-  return [...modelRegistry.entries()].map(([name, entry]) => ({
-    name,
-    provider: entry.provider,
-    pricing: { ...entry.pricing },
-    deprecated: entry.deprecated,
-  }));
+	return [...modelRegistry.entries()].map(([name, entry]) => ({
+		name: entry.name,
+		provider: entry.provider,
+		pricing: { ...entry.pricing },
+		deprecated: entry.deprecated,
+	}));
 }
 
 export function buildDefaultPricingTable() {
-  const table = {};
-  for (const [name, entry] of modelRegistry) {
-    table[name] = { ...entry.pricing };
-  }
-  return table;
+	const table = {};
+	for (const [name, entry] of modelRegistry) {
+		table[name] = { ...entry.pricing };
+	}
+	return table;
 }
 
-// Auto-register built-in models
-// Names must match what each CLI accepts as --model argument
+/**
+ * Anthropic Claude Family
+ * Pricing & Info: https://platform.claude.com/docs/en/about-claude/pricing
+ */
+registerModel("claude-opus-4.6", { provider: "anthropic", pricing: { input_per_million: 5.0, output_per_million: 25.0 } });
+registerModel("claude-sonnet-4.6", { provider: "anthropic", pricing: { input_per_million: 3.0, output_per_million: 15.0 } });
+registerModel("claude-haiku-4.5", { provider: "anthropic", pricing: { input_per_million: 1.0, output_per_million: 5.0 } });
+
+// Default models & General aliases
 registerModel("claude", { provider: "anthropic", pricing: { input_per_million: 3, output_per_million: 15 } });
 registerModel("sonnet", { provider: "anthropic", pricing: { input_per_million: 3, output_per_million: 15 } });
 registerModel("opus", { provider: "anthropic", pricing: { input_per_million: 15, output_per_million: 75 } });
 registerModel("haiku", { provider: "anthropic", pricing: { input_per_million: 0.25, output_per_million: 1.25 } });
+
+/**
+ * OpenAI GPT Family
+ * Pricing: https://developers.openai.com/api/docs/pricing
+ */
+registerModel("gpt-5.4-standard", { provider: "openai", pricing: { input_per_million: 2.5, output_per_million: 15.0 } });
+registerModel("gpt-5.4-thinking", { provider: "openai", pricing: { input_per_million: 2.5, output_per_million: 15.0 } });
+registerModel("gpt-5.4-pro", { provider: "openai", pricing: { input_per_million: 30.0, output_per_million: 180.0 } });
+registerModel("gpt-5.4-mini", { provider: "openai", pricing: { input_per_million: 0.75, output_per_million: 4.5 } });
+
+// Default models & General aliases
 registerModel("codex", { provider: "openai", pricing: { input_per_million: 1.5, output_per_million: 4 } });
 registerModel("o4-mini", { provider: "openai", pricing: { input_per_million: 1.5, output_per_million: 4 } });
 registerModel("o3", { provider: "openai", pricing: { input_per_million: 10, output_per_million: 40 } });
-registerModel("gemini", { provider: "google", pricing: { input_per_million: 1.25, output_per_million: 5 } });
+
+/**
+ * Google Gemini Family
+ * Pricing: https://ai.google.dev/gemini-api/docs/pricing
+ */
+registerModel("gemini-3.1-pro-preview", { provider: "google", pricing: { input_per_million: 2.0, output_per_million: 12.0 } });
+registerModel("gemini-3.1-flash-lite", { provider: "google", pricing: { input_per_million: 0.25, output_per_million: 1.5 } });
+registerModel("gemini-3-flash-preview", { provider: "google", pricing: { input_per_million: 0.5, output_per_million: 3.0 } });
 registerModel("gemini-2.5-pro", { provider: "google", pricing: { input_per_million: 1.25, output_per_million: 5 } });
 registerModel("gemini-2.0-flash", { provider: "google", pricing: { input_per_million: 0.075, output_per_million: 0.3 } });
+
+// Default models & General aliases
+registerModelAlias("gemini", "gemini-2.5-pro");
+
+/**
+ * Other Providers & CLI Aliases
+ */
 registerModel("aider", { provider: "aider", pricing: { input_per_million: 3, output_per_million: 15 } });
 registerModel("opencode", { provider: "opencode", pricing: { input_per_million: 0, output_per_million: 0 } });
+
+// Common CLI Aliases (with provider overrides)
+registerModelAlias("aider/claude-3-7-sonnet", "claude-sonnet-4.6", { provider: "aider" });
+registerModelAlias("aider/gpt-4o", "gpt-5.4-standard", { provider: "aider" });
+registerModelAlias("opencode/minimax-m2.5", "opencode", { provider: "opencode" });

package/src/orchestrator/brain-coordinator.js

@@ -23,6 +23,7 @@ export function createBrainContext({ enabled = false } = {}) {
     feedbackQueue: queue.createQueue(),
     verificationTracker: new VerificationTracker(),
     compressionStats: { totalSaved: 0, perRole: {} },
+    extensionCount: 0,
     enabled
   };
 }
@@ -99,6 +100,16 @@ function extractFeedbackEntries(roleName, output, iteration) {
         iteration
       });
     }
+    // Catch-all: tester failed but no structured detail → still record the failure
+    if (entries.length === 0) {
+      entries.push({
+        source: "tester",
+        severity: "high",
+        category: "tests",
+        description: output.summary || "Tester failed (no structured detail available)",
+        iteration
+      });
+    }
   } else if (roleName === "security" && output.verdict === "fail") {
     for (const vuln of output.vulnerabilities || []) {
       entries.push({
@@ -112,6 +123,16 @@ function extractFeedbackEntries(roleName, output, iteration) {
         iteration
       });
     }
+    // Catch-all: security failed but no structured vulnerabilities → still record
+    if (entries.length === 0) {
+      entries.push({
+        source: "security",
+        severity: "high",
+        category: "security",
+        description: output.summary || "Security gate failed (no structured detail available)",
+        iteration
+      });
+    }
   }
   return entries;
 }

package/src/orchestrator/post-loop-stages.js

@@ -158,7 +158,7 @@ export async function runTesterStage({ config, logger, emitter, eventBase, sessi
   return { action: "ok", stageResult: { ok: true, summary: testerOutput.summary || "All tests passed" } };
 }
 
-export async function runSecurityStage({ config, logger, emitter, eventBase, session, coderRole, trackBudget, iteration, task, diff, askQuestion }) {
+export async function runSecurityStage({ config, logger, emitter, eventBase, session, coderRole, trackBudget, iteration, task, diff, askQuestion, brainCtx }) {
   logger.setContext({ iteration, stage: "security" });
   emitProgress(
     emitter,
@@ -209,6 +209,21 @@ export async function runSecurityStage({ config, logger, emitter, eventBase, ses
     const isCritical = criticalPatterns.some((p) => summary.includes(p));
 
     if (isCritical) {
+      // Brain: when enabled, skip Solomon — Brain handles via feedback queue
+      if (brainCtx?.enabled) {
+        logger.warn(`Brain: critical security finding — Brain will handle (Solomon bypassed): ${securityOutput.summary}`);
+        const { processRoleOutput } = await import("./brain-coordinator.js");
+        processRoleOutput(brainCtx, { roleName: "security", output: { verdict: "fail", summary: securityOutput.summary, critical: true }, iteration });
+        emitProgress(emitter, makeEvent("brain:security-critical", { ...eventBase, stage: "security" }, {
+          message: `Critical security finding — Brain handling: ${securityOutput.summary.slice(0, 200)}`,
+          detail: { summary: securityOutput.summary }
+        }));
+        return {
+          action: "continue",
+          stageResult: { ...securityOutput.result, summary: securityOutput.summary, provider: securityProvider }
+        };
+      }
+
       // Critical security issue — escalate to Solomon/human
       logger.warn(`Critical security finding — escalating: ${securityOutput.summary}`);
       const solomonResult = await invokeSolomon({

package/src/orchestrator/solomon-escalation.js

@@ -103,7 +103,7 @@ export async function invokeSolomon({ config, logger, emitter, eventBase, stage,
     : null;
 
   const solomon = new SolomonRole({ config, logger, emitter });
-  await solomon.init({ task: conflict.task || session.task, iteration });
+  await solomon.init({ task: conflict.task, iteration });
   let ruling;
   try {
     // Inject Solomon's own history so it doesn't repeat failed strategies

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

@@ -249,18 +249,28 @@ function handleSolomonAction(solomonResult, session, contextPrefix) {
   return null;
 }
 
-async function handleSolomonContinue(solomonResult, session, counterField) {
+async function handleSolomonContinue(solomonResult, session, counterField, brainCtx) {
   if (solomonResult.action !== "continue") return false;
   if (solomonResult.humanGuidance) {
     session.last_reviewer_feedback += `\nUser guidance: ${solomonResult.humanGuidance}`;
+    // Brain: also push user guidance into feedback queue when enabled
+    if (brainCtx?.enabled) {
+      const { processRoleOutput } = await import("../brain-coordinator.js");
+      processRoleOutput(brainCtx, { roleName: "solomon", output: { verdict: "continue", summary: solomonResult.humanGuidance }, iteration: 0 });
+    }
   }
   session[counterField] = 0;
   await saveSession(session);
   return true;
 }
 
-async function handleTddFailure({ tddEval, config, logger, emitter, eventBase, session, iteration, askQuestion }) {
+async function handleTddFailure({ tddEval, config, logger, emitter, eventBase, session, iteration, askQuestion, task, brainCtx }) {
   session.last_reviewer_feedback = tddEval.message;
+  // Brain: push TDD failure into feedback queue when enabled
+  if (brainCtx?.enabled) {
+    const { processRoleOutput } = await import("../brain-coordinator.js");
+    processRoleOutput(brainCtx, { roleName: "tdd", output: { verdict: "fail", summary: tddEval.message }, iteration });
+  }
   session.repeated_issue_count += 1;
   await saveSession(session);
 
@@ -268,6 +278,18 @@ async function handleTddFailure({ tddEval, config, logger, emitter, eventBase, s
     return { action: "continue" };
   }
 
+  // Brain: when enabled, skip Solomon — Brain handles via max_iterations
+  if (brainCtx?.enabled) {
+    logger.info("Brain: TDD sub-loop limit reached — Brain will handle via max_iterations (Solomon bypassed)");
+    emitProgress(emitter, makeEvent("brain:tdd-retry-limit", { ...eventBase, stage: "tdd" }, {
+      message: `TDD sub-loop limit reached (${session.repeated_issue_count}/${config.session.fail_fast_repeats}) — Brain handling`,
+      detail: { subloop: "tdd", retryCount: session.repeated_issue_count, reason: tddEval.reason }
+    }));
+    session.repeated_issue_count = 0;
+    await saveSession(session);
+    return { action: "continue" };
+  }
+
   emitProgress(
     emitter,
     makeEvent("solomon:escalate", { ...eventBase, stage: "tdd" }, {
@@ -280,7 +302,7 @@ async function handleTddFailure({ tddEval, config, logger, emitter, eventBase, s
     config, logger, emitter, eventBase, stage: "tdd", askQuestion, session, iteration,
     conflict: {
       stage: "tdd",
-      task: session.task,
+      task: task || session.task,
       iterationCount: session.repeated_issue_count,
       maxIterations: config.session.fail_fast_repeats,
       reason: tddEval.reason,
@@ -292,13 +314,13 @@ async function handleTddFailure({ tddEval, config, logger, emitter, eventBase, s
 
   const actionResult = handleSolomonAction(solomonResult, session, "tdd");
   if (actionResult) return actionResult;
-  const continued = await handleSolomonContinue(solomonResult, session, "repeated_issue_count");
+  const continued = await handleSolomonContinue(solomonResult, session, "repeated_issue_count", brainCtx);
   if (continued) return { action: "continue" };
 
   return { action: "continue" };
 }
 
-export async function runTddCheckStage({ config, logger, emitter, eventBase, session, trackBudget, iteration, askQuestion }) {
+export async function runTddCheckStage({ config, logger, emitter, eventBase, session, trackBudget, iteration, askQuestion, task, brainCtx }) {
   logger.setContext({ iteration, stage: "tdd" });
   let tddDiff, untrackedFiles;
   try {
@@ -335,7 +357,7 @@ export async function runTddCheckStage({ config, logger, emitter, eventBase, ses
   );
 
   if (!tddEval.ok) {
-    return handleTddFailure({ tddEval, config, logger, emitter, eventBase, session, iteration, askQuestion });
+    return handleTddFailure({ tddEval, config, logger, emitter, eventBase, session, iteration, askQuestion, task, brainCtx });
   }
 
   return { action: "ok" };

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

@@ -36,7 +36,7 @@ function buildReviewHistory(session) {
     .map(cp => ({ iteration: cp.iteration, note: cp.note || "" }));
 }
 
-async function handleReviewerStalledSolomon({ review, repeatCounts, repeatState, config, logger, emitter, eventBase, session, iteration, task, askQuestion, budgetSummary, repeatDetector }) {
+async function handleReviewerStalledSolomon({ review, repeatCounts, repeatState, config, logger, emitter, eventBase, session, iteration, task, askQuestion, budgetSummary, repeatDetector, brainCtx }) {
   // DETERMINISTIC GUARD: security issues NEVER go to Solomon — always return to coder
   const categories = categorizeIssues(review.blocking_issues);
   if (categories.security > 0) {
@@ -48,6 +48,22 @@ async function handleReviewerStalledSolomon({ review, repeatCounts, repeatState,
     return { review, solomonApproved: false };
   }
 
+  // Brain: when enabled, ALL paths go through Brain, not Solomon
+  if (brainCtx?.enabled) {
+    const logPrefix = repeatState.stalled
+      ? `Reviewer stalled (${repeatCounts.reviewer} repeats)`
+      : `Reviewer rejected (first rejection)`;
+    logger.info(`Brain: ${logPrefix} — Brain will handle (Solomon bypassed)`);
+    emitProgress(emitter, makeEvent("brain:escalate", { ...eventBase, stage: "reviewer" }, {
+      message: `${logPrefix} — Brain handling`,
+      detail: { repeats: repeatCounts.reviewer || 1, reason: repeatState.reason || "first_rejection" }
+    }));
+    // Push reviewer feedback into Brain queue
+    const { processRoleOutput } = await import("../brain-coordinator.js");
+    processRoleOutput(brainCtx, { roleName: "reviewer", output: review, iteration });
+    return { review, solomonApproved: false };
+  }
+
   const logPrefix = repeatState.stalled
     ? `Reviewer stalled (${repeatCounts.reviewer} repeats)`
     : `Reviewer rejected (first rejection)`;
@@ -156,22 +172,23 @@ async function handleReviewerRejection({ review, repeatDetector, config, logger,
     return handleReviewerStalledSolomon({
       review, repeatCounts, repeatState, config, logger, emitter,
       eventBase, session, iteration, task, askQuestion,
-      budgetSummary, repeatDetector
+      budgetSummary, repeatDetector, brainCtx
     });
   }
 
   // Solomon evaluates EVERY rejection
   const repeatCounts = repeatDetector.getRepeatCounts();
-  logger.info(`Reviewer rejected — Solomon evaluating ${review.blocking_issues.length} blocking issue(s)`);
-  emitProgress(emitter, makeEvent("solomon:evaluate", { ...eventBase, stage: "solomon" }, {
-    message: `Solomon evaluating reviewer rejection`,
+  const evaluateEventName = brainCtx?.enabled ? "brain:evaluate" : "solomon:evaluate";
+  logger.info(`Reviewer rejected — ${brainCtx?.enabled ? "Brain" : "Solomon"} evaluating ${review.blocking_issues.length} blocking issue(s)`);
+  emitProgress(emitter, makeEvent(evaluateEventName, { ...eventBase, stage: brainCtx?.enabled ? "brain" : "solomon" }, {
+    message: `${brainCtx?.enabled ? "Brain" : "Solomon"} evaluating reviewer rejection`,
     detail: { blockingCount: review.blocking_issues.length, isRepeat: repeatState.stalled }
   }));
 
   return handleReviewerStalledSolomon({
     review, repeatCounts, repeatState, config, logger, emitter,
     eventBase, session, iteration, task, askQuestion,
-    budgetSummary, repeatDetector
+    budgetSummary, repeatDetector, brainCtx
   });
 }
 

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

@@ -26,7 +26,19 @@ async function handleSonarStalled({ repeatDetector, logger, emitter, eventBase,
   return { action: "stalled", result: { approved: false, sessionId: session.id, reason: "stalled" } };
 }
 
-async function handleSonarRetryLimit({ config, logger, emitter, eventBase, session, iteration, askQuestion, task, maxSonarRetries, sonarResult }) {
+async function handleSonarRetryLimit({ config, logger, emitter, eventBase, session, iteration, askQuestion, task, maxSonarRetries, sonarResult, brainCtx }) {
+  // Brain: when enabled, skip Solomon — Brain handles via max_iterations
+  if (brainCtx?.enabled) {
+    logger.info("Brain: sonar retry limit reached — Brain will handle via max_iterations (Solomon bypassed)");
+    emitProgress(emitter, makeEvent("brain:sonar-retry-limit", { ...eventBase, stage: "sonar" }, {
+      message: `Sonar sub-loop limit reached (${session.sonar_retry_count}/${maxSonarRetries}) — Brain handling`,
+      detail: { subloop: "sonar", retryCount: session.sonar_retry_count, limit: maxSonarRetries, gateStatus: sonarResult.gateStatus }
+    }));
+    session.sonar_retry_count = 0;
+    await saveSession(session);
+    return { action: "continue" };
+  }
+
   emitProgress(
     emitter,
     makeEvent("solomon:escalate", { ...eventBase, stage: "sonar" }, {
@@ -64,7 +76,7 @@ async function handleSonarRetryLimit({ config, logger, emitter, eventBase, sessi
   return null;
 }
 
-async function handleSonarBlocking({ sonarResult, config, logger, emitter, eventBase, session, iteration, repeatDetector, budgetSummary, askQuestion, task }) {
+async function handleSonarBlocking({ sonarResult, config, logger, emitter, eventBase, session, iteration, repeatDetector, budgetSummary, askQuestion, task, brainCtx }) {
   // If the ONLY quality gate failure is coverage, treat as non-blocking warning
   if (sonarResult.conditions) {
     const failedConditions = sonarResult.conditions.filter(c => c.status === "ERROR");
@@ -88,20 +100,26 @@ async function handleSonarBlocking({ sonarResult, config, logger, emitter, event
     return handleSonarStalled({ repeatDetector, logger, emitter, eventBase, session, budgetSummary });
   }
 
-  session.last_reviewer_feedback = `Sonar gate blocking (${sonarResult.gateStatus}). Resolve critical findings first.`;
+  const summary = `Sonar gate blocking (${sonarResult.gateStatus}). Resolve critical findings first.`;
+  session.last_reviewer_feedback = summary;
+  // Brain: push sonar feedback into queue when enabled
+  if (brainCtx?.enabled) {
+    const { processRoleOutput } = await import("../brain-coordinator.js");
+    processRoleOutput(brainCtx, { roleName: "sonar", output: { verdict: "fail", summary }, iteration });
+  }
   session.sonar_retry_count = (session.sonar_retry_count || 0) + 1;
   await saveSession(session);
   const maxSonarRetries = config.session.max_sonar_retries ?? config.session.fail_fast_repeats;
 
   if (session.sonar_retry_count >= maxSonarRetries) {
-    const result = await handleSonarRetryLimit({ config, logger, emitter, eventBase, session, iteration, askQuestion, task, maxSonarRetries, sonarResult });
+    const result = await handleSonarRetryLimit({ config, logger, emitter, eventBase, session, iteration, askQuestion, task, maxSonarRetries, sonarResult, brainCtx });
     if (result) return result;
   }
 
   return { action: "continue" };
 }
 
-export async function runSonarStage({ config, logger, emitter, eventBase, session, trackBudget, iteration, repeatDetector, budgetSummary, sonarState, askQuestion, task }) {
+export async function runSonarStage({ config, logger, emitter, eventBase, session, trackBudget, iteration, repeatDetector, budgetSummary, sonarState, askQuestion, task, brainCtx }) {
   logger.setContext({ iteration, stage: "sonar" });
   emitProgress(
     emitter,
@@ -170,12 +188,22 @@ export async function runSonarStage({ config, logger, emitter, eventBase, sessio
       })
     );
 
+    // Brain: when enabled, skip Solomon for sonar errors — Brain handles via max_iterations
+    if (brainCtx?.enabled) {
+      logger.info("Brain: sonar error — Brain will handle (Solomon bypassed)");
+      emitProgress(emitter, makeEvent("brain:sonar-error", { ...eventBase, stage: "sonar" }, {
+        message: `Sonar error — Brain handling: ${errorMessage.slice(0, 200)}`,
+        detail: { error: errorMessage }
+      }));
+      return { action: "continue" };
+    }
+
     // Let Solomon decide: continue without sonar or stop
     const solomonResult = await invokeSolomon({
       config, logger, emitter, eventBase, stage: "sonar_error", askQuestion, session, iteration,
       conflict: {
         stage: "sonar_error",
-        task: session.task,
+        task,
         iterationCount: iteration,
         maxIterations: config.max_iterations,
         history: [{ agent: "sonar", feedback: errorMessage }]
@@ -223,7 +251,7 @@ export async function runSonarStage({ config, logger, emitter, eventBase, sessio
   );
 
   if (sonarResult.blocking) {
-    return handleSonarBlocking({ sonarResult, config, logger, emitter, eventBase, session, iteration, repeatDetector, budgetSummary, askQuestion, task });
+    return handleSonarBlocking({ sonarResult, config, logger, emitter, eventBase, session, iteration, repeatDetector, budgetSummary, askQuestion, task, brainCtx });
   }
 
   // Sonar passed — reset retry counter

package/src/orchestrator.js

@@ -351,7 +351,7 @@ async function handlePostLoopStages({ config, session, emitter, eventBase, coder
   if (securityEnabled) {
     const securityResult = await runSecurityStage({
       config, logger, emitter, eventBase, session, coderRole, trackBudget,
-      iteration: i, task, diff: postLoopDiff, askQuestion
+      iteration: i, task, diff: postLoopDiff, askQuestion, brainCtx
     });
     if (securityResult.action === "pause") return { action: "return", result: securityResult.result };
     if (securityResult.action === "continue") {
@@ -918,8 +918,8 @@ async function runGuardStages({ config, logger, emitter, eventBase, session, ite
   return { action: "ok" };
 }
 
-async function runQualityGateStages({ config, logger, emitter, eventBase, session, trackBudget, i, askQuestion, repeatDetector, budgetSummary, sonarState, task, stageResults, coderRole, pipelineFlags }) {
-  const tddResult = await runTddCheckStage({ config, logger, emitter, eventBase, session, trackBudget, iteration: i, askQuestion });
+async function runQualityGateStages({ config, logger, emitter, eventBase, session, trackBudget, i, askQuestion, repeatDetector, budgetSummary, sonarState, task, stageResults, coderRole, pipelineFlags, brainCtx }) {
+  const tddResult = await runTddCheckStage({ config, logger, emitter, eventBase, session, trackBudget, iteration: i, askQuestion, task, brainCtx });
   if (tddResult.action === "pause") return { action: "return", result: tddResult.result };
   if (tddResult.action === "continue") return { action: "continue" };
 
@@ -928,7 +928,7 @@ async function runQualityGateStages({ config, logger, emitter, eventBase, sessio
   if (config.sonarqube.enabled && !skipSonarForTaskType.has(effectiveTaskType)) {
     const sonarResult = await runSonarStage({
       config, logger, emitter, eventBase, session, trackBudget, iteration: i,
-      repeatDetector, budgetSummary, sonarState, askQuestion, task
+      repeatDetector, budgetSummary, sonarState, askQuestion, task, brainCtx
     });
     if (sonarResult.action === "stalled" || sonarResult.action === "pause") return { action: "return", result: sonarResult.result };
     if (sonarResult.action === "continue") return { action: "continue" };
@@ -1033,8 +1033,14 @@ async function handleMaxIterationsReached({ session, budgetSummary, emitter, eve
     }
 
     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`);
+      // Brain: correctness/test issues pending. Cap at MAX_EXTENSIONS to avoid infinite extensions.
+      const MAX_EXTENSIONS = 2;
+      if (brainCtx.extensionCount >= MAX_EXTENSIONS) {
+        logger.warn(`Brain: ${brainCtx.extensionCount} extensions exhausted with correctness issues still pending — escalating to human`);
+        return { paused: true, sessionId: session.id, question: `Brain exhausted ${MAX_EXTENSIONS} extensions with correctness/tests still pending. Manual intervention needed.`, context: "brain_extension_cap", pending };
+      }
+      brainCtx.extensionCount += 1;
+      logger.info(`Brain: max_iterations reached with ${entries.filter(e => ["correctness", "tests"].includes(e.category)).length} correctness issue(s) pending — extending iterations (extension ${brainCtx.extensionCount}/${MAX_EXTENSIONS})`);
       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) };
@@ -1311,7 +1317,10 @@ async function initFlowContext({ task, config, logger, emitter, askQuestion, pgT
 }
 
 async function runSingleIteration(ctx) {
-  const { config, logger, emitter, eventBase, session, task, iteration: i } = ctx;
+  // Use plannedTask (HU-scoped or planner-enriched) over the raw original task.
+  // When running per-HU sub-pipelines, plannedTask is the HU's text, not the full spec.
+  const { config, logger, emitter, eventBase, session, iteration: i } = ctx;
+  const task = ctx.plannedTask || ctx.task;
 
   const iterStart = Date.now();
   const ciEnabled = Boolean(config.ci?.enabled) && ctx.gitCtx?.enabled;
@@ -1341,7 +1350,7 @@ async function runSingleIteration(ctx) {
     config, logger, emitter, eventBase, session, trackBudget: ctx.trackBudget, i,
     askQuestion: ctx.askQuestion, repeatDetector: ctx.repeatDetector, budgetSummary: ctx.budgetSummary,
     sonarState: ctx.sonarState, task, stageResults: ctx.stageResults, coderRole: ctx.coderRole,
-    pipelineFlags: ctx.pipelineFlags
+    pipelineFlags: ctx.pipelineFlags, brainCtx: ctx.brainCtx
   });
   if (qgResult.action === "return" || qgResult.action === "continue") return qgResult;
 
@@ -1604,7 +1613,7 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
         const securityResult = await runSecurityStage({
           config: ctx.config, logger, emitter, eventBase: ctx.eventBase, session: ctx.session,
           coderRole: ctx.coderRole, trackBudget: ctx.trackBudget,
-          iteration: 1, task: ctx.plannedTask, diff: postLoopDiff, askQuestion
+          iteration: 1, task: ctx.plannedTask, diff: postLoopDiff, askQuestion, brainCtx: ctx.brainCtx
         });
         if (securityResult.stageResult) analysisStageResults.security = securityResult.stageResult;
       }

package/src/utils/budget.js

@@ -100,6 +100,7 @@ export class BudgetTracker {
     const hasExplicitCost = cost_usd !== undefined && cost_usd !== null && cost_usd !== "";
     const modelName = model || provider || null;
     const computedCost = calculateUsageCostUsd({
+      provider: provider,
       model: modelName,
       tokens_in: safeTokensIn,
       tokens_out: safeTokensOut,

package/src/utils/pricing.js

@@ -2,9 +2,20 @@ import { buildDefaultPricingTable } from "../agents/model-registry.js";
 
 export const DEFAULT_MODEL_PRICING = buildDefaultPricingTable();
 
-export function calculateUsageCostUsd({ model, tokens_in, tokens_out, pricing }) {
+export function calculateUsageCostUsd({ provider, model, tokens_in, tokens_out, pricing }) {
   const table = pricing || DEFAULT_MODEL_PRICING;
-  const entry = table[model] || null;
+  
+  let entry = table[model];
+
+  if (!entry && provider && model) {
+    entry = table[`${provider}/${model}`];
+  }
+
+  if (!entry && model && model.includes("/")) {
+    const [, actualModel] = model.split("/");
+    entry = table[actualModel];
+  }
+
   if (!entry) return 0;
 
   const inputCost = (tokens_in * entry.input_per_million) / 1_000_000;