karajan-code 1.50.0 → 1.50.1

package/README.md

@@ -243,7 +243,7 @@ Not nostalgia, not stubbornness. I've been using JavaScript since 1997, when Bre
 git clone https://github.com/manufosela/karajan-code.git
 cd karajan-code
 npm install
-npm test              # Run 2318 tests with Vitest
+npm test              # Run ~2473 tests with Vitest
 npm run validate      # Lint + test
 ```
 

package/docs/README.es.md

@@ -213,7 +213,7 @@ No es nostalgia ni cabezoneria. Es que llevo usando JavaScript desde 1997, cuand
 git clone https://github.com/manufosela/karajan-code.git
 cd karajan-code
 npm install
-npm test              # Ejecutar 2318 tests con Vitest
+npm test              # Ejecutar ~2473 tests con Vitest
 npm run validate      # Lint + test
 ```
 

package/package.json

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

package/src/orchestrator/preflight-checks.js

@@ -13,6 +13,7 @@ import { checkBinary } from "../utils/agent-detect.js";
 import { isSonarReachable, sonarUp } from "../sonar/manager.js";
 import { runCommand } from "../utils/process.js";
 import { emitProgress, makeEvent } from "../utils/events.js";
+import { msg, getLang } from "../utils/messages.js";
 import {
   resolveSonarHost,
   resolveSonarToken,
@@ -273,13 +274,14 @@ export async function runPreflightChecks({ config, logger, emitter, eventBase, r
 
   const hasErrors = result.errors.length > 0;
   const hasWarnings = result.warnings.length > 0;
+  const preflightLang = getLang(config);
   emitProgress(emitter, makeEvent("preflight:end", { ...eventBase, stage: "preflight" }, {
     status: hasErrors ? "fail" : hasWarnings ? "warn" : "ok",
     message: hasErrors
       ? `Preflight FAILED — ${result.errors.length} blocking issue(s)`
       : hasWarnings
         ? `Preflight completed with ${result.warnings.length} warning(s)`
-        : "Preflight passed — all checks OK",
+        : msg("preflight_passed", preflightLang),
     detail: { ...result, executorType: "local" }
   }));
 

package/src/orchestrator/solomon-escalation.js

@@ -1,6 +1,7 @@
 import { SolomonRole } from "../roles/solomon-role.js";
 import { addCheckpoint, pauseSession, saveSession } from "../session-store.js";
 import { emitProgress, makeEvent } from "../utils/events.js";
+import { msg, getLang } from "../utils/messages.js";
 
 /**
  * Build a human-readable escalation message from raw Solomon conflict data.
@@ -14,15 +15,16 @@ export function formatEscalationMessage(solomonResult, session) {
   const stage = solomonResult?.stage || "unknown";
   const solomonReason = solomonResult?.solomonReason || null;
   const history = solomonResult?.history || [];
+  const lang = getLang(session?.config_snapshot);
 
   const lines = [];
-  lines.push(`--- Conflict: ${stage} ---`);
+  lines.push(msg("solomon_conflict", lang, { stage }));
   lines.push("");
 
   // Extract reviewer/agent feedback from history
   const feedbackEntries = history.filter(entry => entry && typeof entry === "object");
   if (feedbackEntries.length > 0) {
-    lines.push("Reviewer feedback:");
+    lines.push(msg("solomon_feedback", lang));
     for (const entry of feedbackEntries) {
       const agent = entry.agent || "unknown";
       const feedback = entry.feedback || "No feedback provided";
@@ -42,7 +44,7 @@ export function formatEscalationMessage(solomonResult, session) {
 
   // Solomon's reason (if it tried and failed)
   if (solomonReason) {
-    lines.push(`Solomon could not resolve the conflict: ${solomonReason}`);
+    lines.push(`${msg("solomon_reason", lang)} ${solomonReason}`);
     lines.push("");
   }
 
@@ -50,16 +52,13 @@ export function formatEscalationMessage(solomonResult, session) {
   const iterationCount = solomonResult?.iterationCount;
   const maxIterations = solomonResult?.maxIterations;
   if (iterationCount !== undefined && maxIterations !== undefined) {
-    lines.push(`Iterations: ${iterationCount}/${maxIterations}`);
+    lines.push(msg("pipeline_iteration", lang, { current: iterationCount, max: maxIterations }));
     lines.push("");
   }
 
-  lines.push("Options:");
-  lines.push("  1. Accept coder's work as-is");
-  lines.push("  2. Retry with reviewer's feedback");
-  lines.push("  3. Stop the session");
+  lines.push(msg("solomon_options", lang));
   lines.push("");
-  lines.push("How should we proceed?");
+  lines.push(msg("solomon_proceed", lang));
 
   return lines.join("\n");
 }
@@ -161,12 +160,37 @@ export async function invokeSolomon({ config, logger, emitter, eventBase, stage,
   return { action: "continue", conditions: [], ruling };
 }
 
+export function parseEscalationAnswer(answer) {
+  if (!answer) return null;
+  const trimmed = answer.trim().toLowerCase();
+  // Option 1: Accept coder's work as-is
+  if (trimmed === "1" || trimmed === "accept" || trimmed === "yes" || trimmed === "sí" || trimmed === "si") {
+    return { action: "continue", humanGuidance: "Accept coder's work as-is" };
+  }
+  // Option 2: Retry with reviewer's feedback
+  if (trimmed === "2" || trimmed === "retry") {
+    return { action: "continue", humanGuidance: "Retry with reviewer feedback" };
+  }
+  // Option 3: Stop the session
+  if (trimmed === "3" || trimmed.startsWith("stop") || trimmed.startsWith("pause")) {
+    return { action: "stop" };
+  }
+  // Free-text: treat as human guidance (backward compat)
+  return { action: "continue", humanGuidance: answer.trim() };
+}
+
 export async function escalateToHuman({ askQuestion, session, emitter, eventBase, stage, conflict, iteration }) {
   const question = formatEscalationMessage({ ...conflict, stage }, session);
 
   if (askQuestion) {
     const answer = await askQuestion(question, { iteration, stage });
-    if (answer) {
+    const parsed = parseEscalationAnswer(answer);
+    if (parsed && parsed.action === "continue") {
+      return { action: "continue", humanGuidance: parsed.humanGuidance };
+    }
+    if (parsed && parsed.action === "stop") {
+      // Fall through to pause session
+    } else if (answer) {
       return { action: "continue", humanGuidance: answer };
     }
   }

package/src/orchestrator.js

@@ -31,6 +31,7 @@ import { classifyIntent } from "./guards/intent-guard.js";
 import { resolveReviewProfile } from "./review/profiles.js";
 import { CoderRole } from "./roles/coder-role.js";
 import { invokeSolomon } from "./orchestrator/solomon-escalation.js";
+import { msg, getLang } from "./utils/messages.js";
 import { PipelineContext } from "./orchestrator/pipeline-context.js";
 import { runTriageStage, runResearcherStage, runArchitectStage, runPlannerStage, runDiscoverStage, runHuReviewerStage } from "./orchestrator/pre-loop-stages.js";
 import { runCoderStage, runRefactorerStage, runTddCheckStage, runSonarStage, runSonarCloudStage, runReviewerStage } from "./orchestrator/iteration-stages.js";
@@ -402,8 +403,9 @@ async function handleCheckpoint({ checkpointDisabled, askQuestion, lastCheckpoin
     })
   );
 
+  const lang = getLang(config);
   const answer = await askQuestion(
-    `${checkpointMsg}\n\nOptions:\n1. Continue 5 more minutes\n2. Continue until done (no more checkpoints)\n3. Continue for N minutes (reply with the number)\n4. Stop now`
+    `${checkpointMsg}\n\n${msg("checkpoint_options", lang)}`
   );
 
   await addCheckpoint(session, { stage: "interactive-checkpoint", elapsed_minutes: Number(elapsedStr), answer });
@@ -429,7 +431,7 @@ async function handleCheckpoint({ checkpointDisabled, askQuestion, lastCheckpoin
   return parsed;
 }
 
-function parseCheckpointAnswer({ trimmedAnswer, checkpointDisabled, config }) {
+export function parseCheckpointAnswer({ trimmedAnswer, checkpointDisabled, config }) {
   if (!trimmedAnswer) {
     return { action: "continue_loop", checkpointDisabled, lastCheckpointAt: Date.now() };
   }
@@ -632,11 +634,23 @@ async function checkSolomonCriticalAlerts({ rulesResult, askQuestion, session, i
     .filter(a => a.severity === "critical")
     .map(a => a.message)
     .join("\n");
-  const answer = await askQuestion(
-    `Solomon detected critical issues:\n${alertSummary}\n\nShould I continue, pause, or revert?`,
-    { iteration: i, stage: "solomon" }
-  );
-  if (!answer || answer.toLowerCase().includes("pause") || answer.toLowerCase().includes("stop")) {
+  const question = [
+    "Solomon detected critical issues:",
+    alertSummary,
+    "",
+    "What should we do?",
+    "1 = Continue anyway",
+    "2 = Pause the session",
+    "3 = Stop the session",
+    "",
+    "Type 1, 2, or 3:"
+  ].join("\n");
+  const answer = await askQuestion(question, { iteration: i, stage: "solomon" });
+  const trimmed = (answer || "").trim().toLowerCase();
+  const shouldPause = !answer
+    || trimmed === "2" || trimmed === "3"
+    || trimmed.startsWith("pause") || trimmed.startsWith("stop");
+  if (shouldPause) {
     await pauseSession(session, {
       question: `Solomon supervisor paused: ${alertSummary}`,
       context: { iteration: i, stage: "solomon", alerts: rulesResult.alerts }
@@ -1280,11 +1294,13 @@ async function runSingleIteration(ctx) {
 
   const reviewerRetryCount = session.reviewer_retry_count || 0;
   const maxReviewerRetries = config.session.max_reviewer_retries ?? config.session.fail_fast_repeats;
+  const iterLang = getLang(config);
+  const iterMsg = msg("pipeline_iteration", iterLang, { current: i, max: config.max_iterations });
   emitProgress(emitter, makeEvent("iteration:start", { ...eventBase, stage: "iteration" }, {
-    message: `Iteration ${i}/${config.max_iterations}`,
+    message: iterMsg,
     detail: { iteration: i, maxIterations: config.max_iterations, reviewerRetryCount, maxReviewerRetries }
   }));
-  logger.info(`Iteration ${i}/${config.max_iterations}`);
+  logger.info(iterMsg);
 
   const crResult = await runCoderAndRefactorerStages({
     coderRoleInstance: ctx.coderRoleInstance, coderRole: ctx.coderRole, refactorerRole: ctx.refactorerRole,

package/src/planning-game/decomposition.js

@@ -4,6 +4,8 @@
  * recommends decomposition and user accepts.
  */
 
+import { msg } from "../utils/messages.js";
+
 export async function createDecompositionSubtasks({
   client,
   projectId,
@@ -66,9 +68,9 @@ export async function createDecompositionSubtasks({
   return created;
 }
 
-export function buildDecompositionQuestion(subtasks, parentCardId) {
+export function buildDecompositionQuestion(subtasks, parentCardId, lang = "en") {
   const lines = [
-    `Triage recommends decomposing this task into ${subtasks.length} subtasks:`,
+    msg("triage_decompose", lang, { count: subtasks.length }),
     ""
   ];
   for (let i = 0; i < subtasks.length; i++) {
@@ -76,10 +78,10 @@ export function buildDecompositionQuestion(subtasks, parentCardId) {
   }
   lines.push(
     "",
-    `Create these as linked cards in Planning Game (parent: ${parentCardId})?`,
-    "Each subtask will block the next one (sequential chain).",
+    msg("triage_create_cards", lang, { cardId: parentCardId }),
+    msg("triage_sequential", lang),
     "",
-    "Reply: yes / no"
+    msg("triage_reply", lang)
   );
   return lines.join("\n");
 }

package/src/planning-game/pipeline-adapter.js

@@ -13,6 +13,7 @@
 
 import { emitProgress, makeEvent } from "../utils/events.js";
 import { addCheckpoint, saveSession } from "../session-store.js";
+import { getLang } from "../utils/messages.js";
 
 /**
  * Attach the PG adapter to a pipeline emitter.
@@ -54,10 +55,13 @@ export async function handlePgDecomposition({ triageResult, pgTaskId, pgProject,
     const { buildDecompositionQuestion, createDecompositionSubtasks } = await import("./decomposition.js");
     const { createCard, relateCards, fetchCard } = await import("./client.js");
 
-    const question = buildDecompositionQuestion(triageResult.stageResult.subtasks, pgTaskId);
+    const lang = getLang(config);
+    const question = buildDecompositionQuestion(triageResult.stageResult.subtasks, pgTaskId, lang);
     const answer = await askQuestion(question);
 
-    if (answer && (answer.trim().toLowerCase() === "yes" || answer.trim().toLowerCase() === "sí" || answer.trim().toLowerCase() === "si")) {
+    const normalizedAnswer = (answer || "").trim().toLowerCase();
+    const isAccept = normalizedAnswer === "1" || normalizedAnswer === "yes" || normalizedAnswer === "sí" || normalizedAnswer === "si";
+    if (isAccept) {
       const parentCard = await fetchCard({ projectId: pgProject, cardId: pgTaskId }).catch(() => null);
       const createdSubtasks = await createDecompositionSubtasks({
         client: { createCard, relateCards },

package/src/utils/messages.js

@@ -0,0 +1,61 @@
+/**
+ * Centralized message catalog for pipeline UI strings.
+ * Supports i18n by resolving messages for the configured language.
+ * Falls back to English when a key or language is missing.
+ */
+
+const MESSAGES = {
+  en: {
+    triage_decompose: "Triage recommends decomposing this task into {count} subtasks:",
+    triage_create_cards: "Create these as linked cards in Planning Game (parent: {cardId})?",
+    triage_sequential: "Each subtask will block the next one (sequential chain).",
+    triage_reply: "Reply: yes / no",
+    solomon_conflict: "--- Conflict: {stage} ---",
+    solomon_feedback: "Reviewer feedback:",
+    solomon_reason: "Solomon could not resolve the conflict:",
+    solomon_options: "Options:\n  1. Accept coder's work as-is\n  2. Retry with reviewer's feedback\n  3. Stop the session",
+    solomon_proceed: "How should we proceed?",
+    checkpoint_continue: "Continue for {minutes} more minutes?",
+    checkpoint_options: "1. Continue 5 more minutes\n2. Continue until done (no more checkpoints)\n3. Continue for N minutes (reply with the number)\n4. Stop now",
+    preflight_passed: "Preflight passed — all checks OK",
+    pipeline_iteration: "Iteration {current}/{max}",
+  },
+  es: {
+    triage_decompose: "Triage recomienda descomponer esta tarea en {count} subtareas:",
+    triage_create_cards: "¿Crear estas como cards vinculadas en Planning Game (padre: {cardId})?",
+    triage_sequential: "Cada subtarea bloqueará la siguiente (cadena secuencial).",
+    triage_reply: "Responde: sí / no",
+    solomon_conflict: "--- Conflicto: {stage} ---",
+    solomon_feedback: "Feedback del reviewer:",
+    solomon_reason: "Solomon no pudo resolver el conflicto:",
+    solomon_options: "Opciones:\n  1. Aceptar el trabajo del coder tal cual\n  2. Reintentar con el feedback del reviewer\n  3. Parar la sesión",
+    solomon_proceed: "¿Cómo procedemos?",
+    checkpoint_continue: "¿Continuar {minutes} minutos más?",
+    checkpoint_options: "1. Continuar (5 min)\n2. Continuar hasta terminar\n3. Tiempo personalizado\n4. Parar",
+    preflight_passed: "Preflight superado — todas las comprobaciones OK",
+    pipeline_iteration: "Iteración {current}/{max}",
+  }
+};
+
+/**
+ * Resolve a message template by key and language, interpolating parameters.
+ * Falls back to English, then to the raw key if not found.
+ *
+ * @param {string} key - Message key (e.g. "solomon_conflict")
+ * @param {string} [lang="en"] - 2-letter language code
+ * @param {object} [params={}] - Interpolation values (e.g. {stage: "reviewer"})
+ * @returns {string}
+ */
+export function msg(key, lang = "en", params = {}) {
+  const template = MESSAGES[lang]?.[key] || MESSAGES.en[key] || key;
+  return template.replace(/\{(\w+)\}/g, (_, k) => params[k] ?? `{${k}}`);
+}
+
+/**
+ * Extract the language code from a Karajan config object.
+ * @param {object} [config] - Karajan config
+ * @returns {string} 2-letter language code
+ */
+export function getLang(config) {
+  return config?.language || "en";
+}