karajan-code 1.35.0 → 1.36.0

package/README.md

@@ -152,6 +152,7 @@ Use `kj roles show <role>` to inspect any template.
 Karajan auto-detects and auto-configures everything it can:
 
 - **TDD**: Detects test framework (vitest, jest, mocha) → auto-enables TDD
+- **Bootstrap gate**: Validates all prerequisites (git repo, remote, config, agents, SonarQube) before any tool runs. Fails hard with actionable fix instructions — never silently degrades
 - **SonarQube**: Auto-starts Docker container, generates config if missing
 - **Pipeline complexity**: Triage classifies task → trivial tasks skip reviewer loop
 - **Provider outages**: Retries on 500/502/503/504 with backoff (same as rate limits)
@@ -163,9 +164,9 @@ No per-project configuration required. If you want to customize, config is layer
 
 Because it should be.
 
-Karajan has **1847 tests** across 149 files. It runs on Node.js without a build step. You can read the source, understand it, fork it, and modify it without a TypeScript compiler between you and the code.
+Karajan has **1966 tests** across 157 files. It runs on Node.js without a build step. You can read the source, understand it, fork it, and modify it without a TypeScript compiler between you and the code.
 
-This is a deliberate choice, not a limitation. The tests are the type safety. The legibility is a feature. **52 releases in 23 days** — that velocity is possible precisely because vanilla JS with good tests lets you move fast without fear.
+This is a deliberate choice, not a limitation. The tests are the type safety. The legibility is a feature. **55 releases in 26 days** — that velocity is possible precisely because vanilla JS with good tests lets you move fast without fear.
 
 ## Recommended companions
 

package/docs/README.es.md

@@ -29,8 +29,9 @@ En lugar de ejecutar un agente de IA y revisar manualmente su output, `kj` encad
 
 **Caracteristicas principales:**
 - **Pipeline multi-agente** con 11 roles configurables
-- **4 agentes de IA soportados**: Claude, Codex, Gemini, Aider
-- **Servidor MCP** con 15 herramientas — usa `kj` desde Claude, Codex o cualquier host compatible con MCP sin salir de tu agente. [Ver configuracion MCP](#servidor-mcp)
+- **5 agentes de IA soportados**: Claude, Codex, Gemini, Aider, OpenCode
+- **Servidor MCP** con 20 herramientas — usa `kj` desde Claude, Codex o cualquier host compatible con MCP sin salir de tu agente. [Ver configuracion MCP](#servidor-mcp)
+- **Bootstrap obligatorio** — valida prerequisitos del entorno (git, remote, config, agentes, SonarQube) antes de cada ejecucion. Si algo falta, para con instrucciones claras
 - **TDD obligatorio** — se exigen cambios en tests cuando se modifican ficheros fuente
 - **Integracion con SonarQube** — analisis estatico con quality gates (requiere [Docker](#requisitos))
 - **Perfiles de revision** — standard, strict, relaxed, paranoid

package/package.json

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

package/src/agents/aider-agent.js

@@ -5,21 +5,28 @@ import { resolveBin } from "./resolve-bin.js";
 export class AiderAgent extends BaseAgent {
   async runTask(task) {
     const role = task.role || "coder";
-    const args = ["--yes", "--message", task.prompt];
     const model = this.getRoleModel(role);
-    if (model) args.push("--model", model);
-    const res = await runCommand(resolveBin("aider"), args, {
-      onOutput: task.onOutput,
-      silenceTimeoutMs: task.silenceTimeoutMs,
-      timeout: task.timeoutMs
-    });
-    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
+    const result = await this._exec(task, model);
+    if (!result.ok && model && this.isModelNotSupportedError(result)) {
+      this.logger?.warn(`Aider model "${model}" not supported — retrying with agent default`);
+      return this._exec(task, null);
+    }
+    return result;
   }
 
   async reviewTask(task) {
     const role = task.role || "reviewer";
-    const args = ["--yes", "--message", task.prompt];
     const model = this.getRoleModel(role);
+    const result = await this._exec(task, model);
+    if (!result.ok && model && this.isModelNotSupportedError(result)) {
+      this.logger?.warn(`Aider model "${model}" not supported — retrying with agent default`);
+      return this._exec(task, null);
+    }
+    return result;
+  }
+
+  async _exec(task, model) {
+    const args = ["--yes", "--message", task.prompt];
     if (model) args.push("--model", model);
     const res = await runCommand(resolveBin("aider"), args, {
       onOutput: task.onOutput,

package/src/agents/base-agent.js

@@ -1,3 +1,12 @@
+const MODEL_NOT_SUPPORTED_PATTERNS = [
+  /model.{0,30}is not supported/i,
+  /model.{0,30}not available/i,
+  /model.{0,30}does not exist/i,
+  /unsupported model/i,
+  /invalid model/i,
+  /model_not_found/i
+];
+
 export class BaseAgent {
   constructor(name, config, logger) {
     this.name = name;
@@ -24,4 +33,10 @@ export class BaseAgent {
     if (role === "reviewer") return false;
     return Boolean(this.config?.coder_options?.auto_approve);
   }
+
+  isModelNotSupportedError(result) {
+    const text = [result?.error, result?.output, result?.stderr, result?.stdout]
+      .filter(Boolean).join("\n");
+    return MODEL_NOT_SUPPORTED_PATTERNS.some(re => re.test(text));
+  }
 }

package/src/agents/claude-agent.js

@@ -35,6 +35,29 @@ function collectAssistantText(obj) {
     .map(block => block.text);
 }
 
+/**
+ * Extract usage metrics from stream-json/json NDJSON output.
+ * Looks for the "result" line which contains total_cost_usd,
+ * usage.input_tokens/output_tokens, and modelUsage.
+ * Returns an object with tokens_in, tokens_out, cost_usd, model or null if not found.
+ */
+export function extractUsageFromStreamJson(raw) {
+  const lines = (raw || "").split("\n").filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const obj = tryParseJson(lines[i]);
+    if (!obj || obj.type !== "result") continue;
+
+    const tokens_in = obj.usage?.input_tokens ?? 0;
+    const tokens_out = obj.usage?.output_tokens ?? 0;
+    const cost_usd = obj.total_cost_usd ?? undefined;
+    const modelUsage = obj.modelUsage;
+    const model = modelUsage ? Object.keys(modelUsage)[0] || null : null;
+
+    return { tokens_in, tokens_out, cost_usd, model };
+  }
+  return null;
+}
+
 /**
  * Extract the final text result from stream-json NDJSON output.
  * Each line is a JSON object. We collect assistant text content from
@@ -135,8 +158,28 @@ const ALLOWED_TOOLS = [
 export class ClaudeAgent extends BaseAgent {
   async runTask(task) {
     const role = task.role || "coder";
-    const args = ["-p", task.prompt, "--allowedTools", ...ALLOWED_TOOLS];
     const model = this.getRoleModel(role);
+    const result = await this._runTaskExec(task, model, role);
+    if (!result.ok && model && this.isModelNotSupportedError(result)) {
+      this.logger?.warn(`Claude model "${model}" not supported — retrying with agent default`);
+      return this._runTaskExec(task, null, role);
+    }
+    return result;
+  }
+
+  async reviewTask(task) {
+    const role = task.role || "reviewer";
+    const model = this.getRoleModel(role);
+    const result = await this._reviewTaskExec(task, model);
+    if (!result.ok && model && this.isModelNotSupportedError(result)) {
+      this.logger?.warn(`Claude model "${model}" not supported — retrying with agent default`);
+      return this._reviewTaskExec(task, null);
+    }
+    return result;
+  }
+
+  async _runTaskExec(task, model, role) {
+    const args = ["-p", task.prompt, "--allowedTools", ...ALLOWED_TOOLS];
     if (model) args.push("--model", model);
 
     // Use stream-json when onOutput is provided to get real-time feedback
@@ -150,7 +193,8 @@ export class ClaudeAgent extends BaseAgent {
       }));
       const raw = pickOutput(res);
       const output = extractTextFromStreamJson(raw);
-      return { ok: res.exitCode === 0, output, error: res.exitCode === 0 ? "" : raw, exitCode: res.exitCode };
+      const usage = extractUsageFromStreamJson(raw);
+      return { ok: res.exitCode === 0, output, error: res.exitCode === 0 ? "" : raw, exitCode: res.exitCode, ...usage };
     }
 
     // Without streaming, use json output to get structured response via stderr
@@ -158,12 +202,12 @@ export class ClaudeAgent extends BaseAgent {
     const res = await runCommand(resolveBin("claude"), args, cleanExecaOpts());
     const raw = pickOutput(res);
     const output = extractTextFromStreamJson(raw);
-    return { ok: res.exitCode === 0, output, error: res.exitCode === 0 ? "" : raw, exitCode: res.exitCode };
+    const usage = extractUsageFromStreamJson(raw);
+    return { ok: res.exitCode === 0, output, error: res.exitCode === 0 ? "" : raw, exitCode: res.exitCode, ...usage };
   }
 
-  async reviewTask(task) {
+  async _reviewTaskExec(task, model) {
     const args = ["-p", task.prompt, "--allowedTools", ...ALLOWED_TOOLS, "--output-format", "stream-json", "--verbose"];
-    const model = this.getRoleModel(task.role || "reviewer");
     if (model) args.push("--model", model);
     const res = await runCommand(resolveBin("claude"), args, cleanExecaOpts({
       onOutput: task.onOutput,
@@ -171,6 +215,7 @@ export class ClaudeAgent extends BaseAgent {
       timeout: task.timeoutMs
     }));
     const raw = pickOutput(res);
-    return { ok: res.exitCode === 0, output: raw, error: res.exitCode === 0 ? "" : raw, exitCode: res.exitCode };
+    const usage = extractUsageFromStreamJson(raw);
+    return { ok: res.exitCode === 0, output: raw, error: res.exitCode === 0 ? "" : raw, exitCode: res.exitCode, ...usage };
   }
 }

package/src/agents/codex-agent.js

@@ -2,27 +2,48 @@ import { BaseAgent } from "./base-agent.js";
 import { runCommand } from "../utils/process.js";
 import { resolveBin } from "./resolve-bin.js";
 
+/**
+ * Extract token usage from Codex CLI stdout.
+ * Codex prints "tokens used\n<number>" at the end, where number may have comma separators.
+ * Returns { tokens_out } with the total token count, or null if not found.
+ * Since Codex doesn't split input/output, we assign the total to tokens_out
+ * as a conservative estimate for cost calculation.
+ */
+export function extractCodexTokens(stdout) {
+  const match = (stdout || "").match(/tokens?\s+used\s*\n\s*([\d,]+)/i);
+  if (!match) return null;
+  const total = Number(match[1].replace(/,/g, ""));
+  if (!Number.isFinite(total) || total <= 0) return null;
+  return { tokens_in: 0, tokens_out: total };
+}
+
 export class CodexAgent extends BaseAgent {
   async runTask(task) {
     const role = task.role || "coder";
-    const args = ["exec"];
     const model = this.getRoleModel(role);
-    if (model) args.push("--model", model);
-    if (this.isAutoApproveEnabled(role)) args.push("--full-auto");
-    args.push("-");
-    const res = await runCommand(resolveBin("codex"), args, {
-      onOutput: task.onOutput,
-      silenceTimeoutMs: task.silenceTimeoutMs,
-      timeout: task.timeoutMs,
-      input: task.prompt
-    });
-    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
+    const result = await this._exec(task, model, role);
+    if (!result.ok && model && this.isModelNotSupportedError(result)) {
+      this.logger?.warn(`Codex model "${model}" not supported — retrying with agent default`);
+      return this._exec(task, null, role);
+    }
+    return result;
   }
 
   async reviewTask(task) {
+    const role = task.role || "reviewer";
+    const model = this.getRoleModel(role);
+    const result = await this._exec(task, model, role);
+    if (!result.ok && model && this.isModelNotSupportedError(result)) {
+      this.logger?.warn(`Codex model "${model}" not supported — retrying with agent default`);
+      return this._exec(task, null, role);
+    }
+    return result;
+  }
+
+  async _exec(task, model, role) {
     const args = ["exec"];
-    const model = this.getRoleModel(task.role || "reviewer");
     if (model) args.push("--model", model);
+    if (role !== "reviewer" && this.isAutoApproveEnabled(role)) args.push("--full-auto");
     args.push("-");
     const res = await runCommand(resolveBin("codex"), args, {
       onOutput: task.onOutput,
@@ -30,6 +51,7 @@ export class CodexAgent extends BaseAgent {
       timeout: task.timeoutMs,
       input: task.prompt
     });
-    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
+    const usage = extractCodexTokens(res.stdout);
+    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode, ...usage };
   }
 }

package/src/agents/gemini-agent.js

@@ -5,21 +5,29 @@ import { resolveBin } from "./resolve-bin.js";
 export class GeminiAgent extends BaseAgent {
   async runTask(task) {
     const role = task.role || "coder";
-    const args = ["-p", task.prompt];
     const model = this.getRoleModel(role);
-    if (model) args.push("--model", model);
-    const res = await runCommand(resolveBin("gemini"), args, {
-      onOutput: task.onOutput,
-      silenceTimeoutMs: task.silenceTimeoutMs,
-      timeout: task.timeoutMs
-    });
-    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
+    const result = await this._exec(task, model, "run");
+    if (!result.ok && model && this.isModelNotSupportedError(result)) {
+      this.logger?.warn(`Gemini model "${model}" not supported — retrying with agent default`);
+      return this._exec(task, null, "run");
+    }
+    return result;
   }
 
   async reviewTask(task) {
     const role = task.role || "reviewer";
-    const args = ["-p", task.prompt, "--output-format", "json"];
     const model = this.getRoleModel(role);
+    const result = await this._exec(task, model, "review");
+    if (!result.ok && model && this.isModelNotSupportedError(result)) {
+      this.logger?.warn(`Gemini model "${model}" not supported — retrying with agent default`);
+      return this._exec(task, null, "review");
+    }
+    return result;
+  }
+
+  async _exec(task, model, mode) {
+    const args = ["-p", task.prompt];
+    if (mode === "review") args.push("--output-format", "json");
     if (model) args.push("--model", model);
     const res = await runCommand(resolveBin("gemini"), args, {
       onOutput: task.onOutput,

package/src/agents/model-registry.js

@@ -49,15 +49,16 @@ export function buildDefaultPricingTable() {
 }
 
 // Auto-register built-in models
+// Names must match what each CLI accepts as --model argument
 registerModel("claude", { provider: "anthropic", pricing: { input_per_million: 3, output_per_million: 15 } });
-registerModel("claude/sonnet", { provider: "anthropic", pricing: { input_per_million: 3, output_per_million: 15 } });
-registerModel("claude/opus", { provider: "anthropic", pricing: { input_per_million: 15, output_per_million: 75 } });
-registerModel("claude/haiku", { provider: "anthropic", pricing: { input_per_million: 0.25, output_per_million: 1.25 } });
+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 } });
 registerModel("codex", { provider: "openai", pricing: { input_per_million: 1.5, output_per_million: 4 } });
-registerModel("codex/o4-mini", { provider: "openai", pricing: { input_per_million: 1.5, output_per_million: 4 } });
-registerModel("codex/o3", { provider: "openai", pricing: { input_per_million: 10, output_per_million: 40 } });
+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 } });
-registerModel("gemini/pro", { provider: "google", pricing: { input_per_million: 1.25, output_per_million: 5 } });
-registerModel("gemini/flash", { provider: "google", pricing: { input_per_million: 0.075, output_per_million: 0.3 } });
+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 } });
 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 } });

package/src/agents/opencode-agent.js

@@ -5,22 +5,29 @@ import { resolveBin } from "./resolve-bin.js";
 export class OpenCodeAgent extends BaseAgent {
   async runTask(task) {
     const role = task.role || "coder";
-    const args = ["run"];
     const model = this.getRoleModel(role);
-    if (model) args.push("--model", model);
-    args.push(task.prompt);
-    const res = await runCommand(resolveBin("opencode"), args, {
-      onOutput: task.onOutput,
-      silenceTimeoutMs: task.silenceTimeoutMs,
-      timeout: task.timeoutMs
-    });
-    return { ok: res.exitCode === 0, output: res.stdout, error: res.stderr, exitCode: res.exitCode };
+    const result = await this._exec(task, model, false);
+    if (!result.ok && model && this.isModelNotSupportedError(result)) {
+      this.logger?.warn(`OpenCode model "${model}" not supported — retrying with agent default`);
+      return this._exec(task, null, false);
+    }
+    return result;
   }
 
   async reviewTask(task) {
     const role = task.role || "reviewer";
-    const args = ["run", "--format", "json"];
     const model = this.getRoleModel(role);
+    const result = await this._exec(task, model, true);
+    if (!result.ok && model && this.isModelNotSupportedError(result)) {
+      this.logger?.warn(`OpenCode model "${model}" not supported — retrying with agent default`);
+      return this._exec(task, null, true);
+    }
+    return result;
+  }
+
+  async _exec(task, model, jsonFormat) {
+    const args = ["run"];
+    if (jsonFormat) args.push("--format", "json");
     if (model) args.push("--model", model);
     args.push(task.prompt);
     const res = await runCommand(resolveBin("opencode"), args, {

package/src/commands/doctor.js

@@ -1,5 +1,7 @@
 import { readFileSync } from "node:fs";
+import fs from "node:fs/promises";
 import { fileURLToPath } from "node:url";
+import os from "node:os";
 import path from "node:path";
 import { runCommand } from "../utils/process.js";
 import { exists } from "../utils/fs.js";
@@ -239,6 +241,101 @@ async function checkRuleFiles(config) {
   ];
 }
 
+/**
+ * Detect duplicate TOML table headers (e.g. [mcp_servers."karajan-mcp"] appearing twice).
+ * Full TOML parsing would require a dependency — this catches the most common config error.
+ */
+function findDuplicateTomlKeys(content) {
+  const tableHeaders = [];
+  const duplicates = [];
+  for (const line of content.split("\n")) {
+    const match = line.match(/^\s*\[([^\]]+)\]\s*$/);
+    if (match) {
+      const key = match[1].trim();
+      if (tableHeaders.includes(key)) {
+        duplicates.push(key);
+      } else {
+        tableHeaders.push(key);
+      }
+    }
+  }
+  return duplicates;
+}
+
+async function checkAgentConfigs() {
+  const checks = [];
+  const home = os.homedir();
+
+  // Claude: ~/.claude.json
+  const claudeJsonPath = path.join(home, ".claude.json");
+  try {
+    const raw = await fs.readFile(claudeJsonPath, "utf8");
+    JSON.parse(raw);
+    checks.push({ name: "agent-config:claude", label: "Agent config: claude (~/.claude.json)", ok: true, detail: "Valid JSON", fix: null });
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      // File doesn't exist — not an error, Claude may not be configured
+    } else {
+      checks.push({
+        name: "agent-config:claude",
+        label: "Agent config: claude (~/.claude.json)",
+        ok: false,
+        detail: `Invalid JSON: ${err.message.split("\n")[0]}`,
+        fix: "Fix the JSON syntax in ~/.claude.json. Common issues: trailing commas, missing quotes."
+      });
+    }
+  }
+
+  // Codex: ~/.codex/config.toml
+  const codexTomlPath = path.join(home, ".codex", "config.toml");
+  try {
+    const raw = await fs.readFile(codexTomlPath, "utf8");
+    const duplicates = findDuplicateTomlKeys(raw);
+    if (duplicates.length > 0) {
+      checks.push({
+        name: "agent-config:codex",
+        label: "Agent config: codex (~/.codex/config.toml)",
+        ok: false,
+        detail: `Duplicate TOML keys: ${duplicates.join(", ")}`,
+        fix: `Remove duplicate entries in ~/.codex/config.toml: ${duplicates.join(", ")}`
+      });
+    } else {
+      checks.push({ name: "agent-config:codex", label: "Agent config: codex (~/.codex/config.toml)", ok: true, detail: "Valid TOML (no duplicate keys)", fix: null });
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      checks.push({
+        name: "agent-config:codex",
+        label: "Agent config: codex (~/.codex/config.toml)",
+        ok: false,
+        detail: `Cannot read: ${err.message.split("\n")[0]}`,
+        fix: "Check file permissions on ~/.codex/config.toml"
+      });
+    }
+  }
+
+  // KJ config: ~/.karajan/kj.config.yml (validate YAML)
+  const kjConfigPath = getConfigPath();
+  try {
+    const raw = await fs.readFile(kjConfigPath, "utf8");
+    const yaml = await import("js-yaml");
+    yaml.default.load(raw);
+    checks.push({ name: "agent-config:karajan", label: "Agent config: karajan (kj.config.yml)", ok: true, detail: "Valid YAML", fix: null });
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      checks.push({
+        name: "agent-config:karajan",
+        label: "Agent config: karajan (kj.config.yml)",
+        ok: false,
+        detail: `Invalid YAML: ${err.message.split("\n")[0]}`,
+        fix: `Fix YAML syntax in ${kjConfigPath}. Run 'kj init' to regenerate if needed.`
+      });
+    }
+  }
+
+  return checks;
+}
+
 export async function runChecks({ config }) {
   const checks = [];
 
@@ -260,6 +357,7 @@ export async function runChecks({ config }) {
     checks.push(...await checkBecariaInfra(config));
   }
 
+  checks.push(...await checkAgentConfigs());
   checks.push(...await checkRuleFiles(config));
   checks.push(await checkRtk());
 

package/src/orchestrator/solomon-escalation.js

@@ -30,10 +30,17 @@ export async function invokeSolomon({ config, logger, emitter, eventBase, stage,
     });
   }
 
+  const solomonError = ruling.result?.error;
+  if (!ruling.ok && solomonError) {
+    logger.warn(`Solomon execution failed: ${solomonError}`);
+  }
+
   emitProgress(
     emitter,
     makeEvent("solomon:end", { ...eventBase, stage: "solomon" }, {
-      message: `Solomon ruling: ${ruling.result?.ruling || "unknown"}`,
+      message: ruling.ok
+        ? `Solomon ruling: ${ruling.result?.ruling || "unknown"}`
+        : `Solomon failed: ${(solomonError || ruling.summary || "unknown error").slice(0, 200)}`,
       detail: ruling.result
     })
   );
@@ -43,13 +50,15 @@ export async function invokeSolomon({ config, logger, emitter, eventBase, stage,
     iteration,
     ruling: ruling.result?.ruling,
     escalate: ruling.result?.escalate,
+    error: solomonError ? solomonError.slice(0, 500) : undefined,
     subtask: ruling.result?.subtask?.title || null
   });
 
   if (!ruling.ok) {
+    const reason = ruling.result?.escalate_reason || solomonError || ruling.summary;
     return escalateToHuman({
       askQuestion, session, emitter, eventBase, stage, iteration,
-      conflict: { ...conflict, solomonReason: ruling.result?.escalate_reason }
+      conflict: { ...conflict, solomonReason: reason }
     });
   }
 

package/src/roles/solomon-role.js

@@ -62,12 +62,28 @@ function buildPrompt({ conflict, task, instructions }) {
   const iterationCount = conflict?.iterationCount ?? "?";
   const maxIterations = conflict?.maxIterations ?? "?";
 
+  const isFirstRejection = conflict?.isFirstRejection ?? false;
+  const isRepeat = conflict?.isRepeat ?? false;
+
   sections.push(
     `## Conflict context`,
     `Stage: ${stage}`,
-    `Iterations exhausted: ${iterationCount}/${maxIterations}`
+    `Iterations exhausted: ${iterationCount}/${maxIterations}`,
+    `isFirstRejection: ${isFirstRejection}`,
+    `isRepeat: ${isRepeat}`
   );
 
+  if (conflict?.issueCategories) {
+    sections.push(`## Issue categories\n${JSON.stringify(conflict.issueCategories, null, 2)}`);
+  }
+
+  if (conflict?.blockingIssues?.length) {
+    const issueList = conflict.blockingIssues
+      .map((issue, i) => `${i + 1}. [${issue.severity || "unknown"}] ${issue.description || issue}`)
+      .join("\n");
+    sections.push(`## Blocking issues\n${issueList}`);
+  }
+
   if (task) {
     sections.push(`## Original task\n${task}`);
   }

package/src/utils/budget.js

@@ -40,18 +40,22 @@ export function extractUsageMetrics(result, defaultModel = null) {
     null;
 
   // If no real token data AND no explicit cost, estimate from prompt/output sizes.
-  // Estimation is opt-in: only triggered when result.promptSize is explicitly provided.
+  // Primary: uses result.promptSize when explicitly provided.
+  // Fallback: estimates from result.output or result.error text length.
   let estimated = false;
   let finalTokensIn = tokens_in;
   let finalTokensOut = tokens_out;
   const hasExplicitCost = cost_usd !== undefined && cost_usd !== null && cost_usd !== "";
-  if (!tokens_in && !tokens_out && !hasExplicitCost && result?.promptSize > 0) {
-    const promptSize = result.promptSize;
-    const outputSize = (result?.output || result?.summary || "").length;
-    const est = estimateTokens(promptSize, outputSize);
-    finalTokensIn = est.tokens_in;
-    finalTokensOut = est.tokens_out;
-    estimated = true;
+  if (!tokens_in && !tokens_out && !hasExplicitCost) {
+    const outputText = result?.output || result?.error || result?.summary || "";
+    const promptSize = result?.promptSize || 0;
+    const MIN_TEXT_FOR_ESTIMATION = 40;
+    if (promptSize > 0 || outputText.length >= MIN_TEXT_FOR_ESTIMATION) {
+      const est = estimateTokens(promptSize, outputText.length);
+      finalTokensIn = est.tokens_in;
+      finalTokensOut = est.tokens_out;
+      estimated = true;
+    }
   }
 
   return { tokens_in: finalTokensIn, tokens_out: finalTokensOut, cost_usd, model, estimated };

package/src/utils/model-selector.js

@@ -1,7 +1,7 @@
 const DEFAULT_MODEL_TIERS = {
-  claude: { trivial: "claude/haiku", simple: "claude/haiku", medium: "claude/sonnet", complex: "claude/opus" },
-  codex: { trivial: "codex/o4-mini", simple: "codex/o4-mini", medium: "codex/o4-mini", complex: "codex/o3" },
-  gemini: { trivial: "gemini/flash", simple: "gemini/flash", medium: "gemini/pro", complex: "gemini/pro" },
+  claude: { trivial: "haiku", simple: "haiku", medium: "sonnet", complex: "opus" },
+  codex: { trivial: "o4-mini", simple: "o4-mini", medium: "o4-mini", complex: "o3" },
+  gemini: { trivial: "gemini-2.0-flash", simple: "gemini-2.0-flash", medium: "gemini-2.5-pro", complex: "gemini-2.5-pro" },
   aider: { trivial: null, simple: null, medium: null, complex: null }
 };
 

package/src/utils/stall-detector.js

@@ -51,7 +51,7 @@ export function createStallDetector({
       lastCriticalWarnAt = now;
       emitProgress(emitter, makeEvent("agent:stall", { ...eventBase, stage }, {
         status: "critical",
-        message: `Agent ${provider} unresponsive for ${Math.round(silenceMs / 1000)}s — may be hung`,
+        message: `[${stage}] Agent ${provider} unresponsive for ${Math.round(silenceMs / 1000)}s — may be hung`,
         detail: {
           provider,
           silenceMs,
@@ -65,7 +65,7 @@ export function createStallDetector({
       lastStallWarnAt = now;
       emitProgress(emitter, makeEvent("agent:stall", { ...eventBase, stage }, {
         status: "warning",
-        message: `Agent ${provider} silent for ${Math.round(silenceMs / 1000)}s — still waiting`,
+        message: `[${stage}] Agent ${provider} silent for ${Math.round(silenceMs / 1000)}s — still waiting`,
         detail: {
           provider,
           silenceMs,
@@ -79,8 +79,8 @@ export function createStallDetector({
 
     emitProgress(emitter, makeEvent("agent:heartbeat", { ...eventBase, stage }, {
       message: silenceMs < stallTimeoutMs
-        ? `Agent ${provider} active — ${lineCount} lines, ${Math.round(elapsedMs / 1000)}s elapsed`
-        : `Agent ${provider} waiting — silent ${Math.round(silenceMs / 1000)}s, ${Math.round(elapsedMs / 1000)}s elapsed`,
+        ? `[${stage}] Agent ${provider} active — ${lineCount} lines, ${Math.round(elapsedMs / 1000)}s elapsed`
+        : `[${stage}] Agent ${provider} waiting — silent ${Math.round(silenceMs / 1000)}s, ${Math.round(elapsedMs / 1000)}s elapsed`,
       detail: {
         provider,
         elapsedMs,
@@ -96,7 +96,7 @@ export function createStallDetector({
       maxSilenceTriggered = true;
       emitProgress(emitter, makeEvent("agent:stall", { ...eventBase, stage }, {
         status: "fail",
-        message: `Agent ${provider} exceeded max silence (${Math.round(hardLimit / 1000)}s)`,
+        message: `[${stage}] Agent ${provider} exceeded max silence (${Math.round(hardLimit / 1000)}s)`,
         detail: {
           provider,
           silenceMs,

package/templates/kj.config.yml

@@ -34,6 +34,9 @@ development:
     - .spec.
 
 # SonarQube settings
+# Authentication: set token below, or KJ_SONAR_TOKEN env var,
+# or save admin credentials in ~/.karajan/sonar-credentials.json:
+#   {"user": "admin", "password": "your-password"}
 sonarqube:
   enabled: true
   host: http://localhost:9000