karajan-code 1.49.0 → 1.50.1

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

@@ -0,0 +1,137 @@
+/**
+ * Triage stage logic.
+ * Extracted from pre-loop-stages.js for maintainability.
+ */
+
+import { TriageRole } from "../../roles/triage-role.js";
+import { addCheckpoint } from "../../session-store.js";
+import { emitProgress, makeEvent } from "../../utils/events.js";
+import { selectModelsForRoles } from "../../utils/model-selector.js";
+import { createStallDetector } from "../../utils/stall-detector.js";
+
+const ROLE_NAMES = ["planner", "researcher", "architect", "refactorer", "reviewer", "tester", "security", "impeccable"];
+
+function buildRoleOverrides(recommendedRoles, pipelineConfig) {
+  const overrides = {};
+  for (const role of ROLE_NAMES) {
+    overrides[`${role}Enabled`] = recommendedRoles.has(role) || Boolean(pipelineConfig[role]?.enabled);
+  }
+  return overrides;
+}
+
+function applyModelSelection(triageOutput, config, emitter, eventBase) {
+  if (!triageOutput.ok || !config?.model_selection?.enabled) return null;
+  const level = triageOutput.result?.level;
+  if (!level) return null;
+
+  const { modelOverrides, reasoning } = selectModelsForRoles({ level, config });
+  for (const [role, model] of Object.entries(modelOverrides)) {
+    if (config.roles?.[role] && !config.roles[role].model) {
+      config.roles[role].model = model;
+    }
+  }
+  const modelSelection = { modelOverrides, reasoning };
+  emitProgress(
+    emitter,
+    makeEvent("model-selection:applied", { ...eventBase, stage: "triage" }, {
+      message: "Smart model selection applied",
+      detail: modelSelection
+    })
+  );
+  return modelSelection;
+}
+
+export async function runTriageStage({ config, logger, emitter, eventBase, session, coderRole, trackBudget }) {
+  logger.setContext({ iteration: 0, stage: "triage" });
+
+  const triageProvider = config?.roles?.triage?.provider || coderRole.provider;
+  emitProgress(
+    emitter,
+    makeEvent("triage:start", { ...eventBase, stage: "triage" }, {
+      message: "Triage classifying task complexity",
+      detail: { provider: triageProvider, executorType: "agent" }
+    })
+  );
+
+  const triageOnOutput = ({ stream, line }) => {
+    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "triage" }, {
+      message: line,
+      detail: { stream, agent: triageProvider }
+    }));
+  };
+  const triageStall = createStallDetector({
+    onOutput: triageOnOutput, emitter, eventBase, stage: "triage", provider: triageProvider
+  });
+
+  const triage = new TriageRole({ config, logger, emitter });
+  await triage.init({ task: session.task, sessionId: session.id, iteration: 0 });
+  const triageStart = Date.now();
+  let triageOutput;
+  try {
+    triageOutput = await triage.run({ task: session.task, onOutput: triageStall.onOutput });
+  } catch (err) {
+    logger.warn(`Triage threw: ${err.message}`);
+    triageOutput = { ok: false, summary: `Triage error: ${err.message}`, result: { error: err.message } };
+  } finally {
+    triageStall.stop();
+  }
+  trackBudget({
+    role: "triage",
+    provider: config?.roles?.triage?.provider || coderRole.provider,
+    model: config?.roles?.triage?.model || coderRole.model,
+    result: triageOutput,
+    duration_ms: Date.now() - triageStart
+  });
+
+  await addCheckpoint(session, {
+    stage: "triage",
+    iteration: 0,
+    ok: triageOutput.ok,
+    provider: config?.roles?.triage?.provider || coderRole.provider,
+    model: config?.roles?.triage?.model || coderRole.model || null
+  });
+
+  const recommendedRoles = new Set(triageOutput.result?.roles || []);
+  const roleOverrides = triageOutput.ok
+    ? buildRoleOverrides(recommendedRoles, config.pipeline || {})
+    : {};
+
+  const shouldDecompose = triageOutput.result?.shouldDecompose || false;
+  const subtasks = triageOutput.result?.subtasks || [];
+
+  const stageResult = {
+    ok: triageOutput.ok,
+    level: triageOutput.result?.level || null,
+    roles: Array.from(recommendedRoles),
+    reasoning: triageOutput.result?.reasoning || null,
+    taskType: triageOutput.result?.taskType || "sw",
+    shouldDecompose,
+    subtasks
+  };
+
+  const modelSelection = applyModelSelection(triageOutput, config, emitter, eventBase);
+  if (modelSelection) {
+    stageResult.modelSelection = modelSelection;
+  }
+
+  if (shouldDecompose && subtasks.length > 0) {
+    emitProgress(
+      emitter,
+      makeEvent("triage:decompose", { ...eventBase, stage: "triage" }, {
+        message: `Task decomposition recommended: ${subtasks.length} subtask${subtasks.length === 1 ? "" : "s"}`,
+        detail: { shouldDecompose, subtasks }
+      })
+    );
+  }
+
+  emitProgress(
+    emitter,
+    makeEvent("triage:end", { ...eventBase, stage: "triage" }, {
+      status: triageOutput.ok ? "ok" : "fail",
+      message: triageOutput.ok ? "Triage completed" : `Triage failed: ${triageOutput.summary}`,
+      detail: { ...stageResult, provider: triageProvider, executorType: "agent" }
+    })
+  );
+
+  return { roleOverrides, stageResult };
+}

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