karajan-code 1.21.0 → 1.21.2

package/package.json

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

package/src/commands/architect.js

@@ -3,56 +3,53 @@ import { assertAgentsAvailable } from "../agents/availability.js";
 import { resolveRole } from "../config.js";
 import { buildArchitectPrompt, parseArchitectOutput } from "../prompts/architect.js";
 
-function formatArchitect(result) {
-  const lines = [];
-  lines.push(`## Architecture Design`);
-  lines.push(`**Verdict:** ${result.verdict || "unknown"}`, "");
+function formatLayers(layers, lines) {
+  lines.push("### Layers");
+  for (const l of layers) {
+    lines.push(typeof l === "string" ? `- ${l}` : `- **${l.name}**: ${l.responsibility || ""}`);
+  }
+  lines.push("");
+}
 
-  const arch = result.architecture;
-  if (arch) {
-    if (arch.type) lines.push(`**Type:** ${arch.type}`, "");
+function formatTradeoffs(tradeoffs, lines) {
+  lines.push("### Tradeoffs");
+  for (const t of tradeoffs) {
+    lines.push(`- **${t.decision}**: ${t.rationale || ""}`);
+    if (t.alternatives?.length) lines.push(`  Alternatives: ${t.alternatives.join(", ")}`);
+  }
+  lines.push("");
+}
 
-    if (arch.layers?.length) {
-      lines.push("### Layers");
-      for (const l of arch.layers) {
-        if (typeof l === "string") {
-          lines.push(`- ${l}`);
-        } else {
-          lines.push(`- **${l.name}**: ${l.responsibility || ""}`);
-        }
-      }
-      lines.push("");
-    }
+function formatApiContracts(contracts, lines) {
+  lines.push("### API Contracts");
+  for (const c of contracts) {
+    lines.push(`- \`${c.method || "GET"} ${c.endpoint}\``);
+  }
+  lines.push("");
+}
 
-    if (arch.patterns?.length) {
-      lines.push("### Patterns");
-      for (const p of arch.patterns) lines.push(`- ${p}`);
-      lines.push("");
-    }
+function formatArchitecture(arch, lines) {
+  if (arch.type) lines.push(`**Type:** ${arch.type}`, "");
+  if (arch.layers?.length) formatLayers(arch.layers, lines);
+  if (arch.patterns?.length) {
+    lines.push("### Patterns");
+    for (const p of arch.patterns) lines.push(`- ${p}`);
+    lines.push("");
+  }
+  if (arch.tradeoffs?.length) formatTradeoffs(arch.tradeoffs, lines);
+  if (arch.apiContracts?.length) formatApiContracts(arch.apiContracts, lines);
+}
 
-    if (arch.tradeoffs?.length) {
-      lines.push("### Tradeoffs");
-      for (const t of arch.tradeoffs) {
-        lines.push(`- **${t.decision}**: ${t.rationale || ""}`);
-        if (t.alternatives?.length) lines.push(`  Alternatives: ${t.alternatives.join(", ")}`);
-      }
-      lines.push("");
-    }
+function formatArchitect(result) {
+  const lines = [];
+  lines.push(`## Architecture Design`);
+  lines.push(`**Verdict:** ${result.verdict || "unknown"}`, "");
 
-    if (arch.apiContracts?.length) {
-      lines.push("### API Contracts");
-      for (const c of arch.apiContracts) {
-        lines.push(`- \`${c.method || "GET"} ${c.endpoint}\``);
-      }
-      lines.push("");
-    }
-  }
+  if (result.architecture) formatArchitecture(result.architecture, lines);
 
   if (result.questions?.length) {
     lines.push("### Clarification Questions");
-    for (const q of result.questions) {
-      lines.push(`- ${q.question || q}`);
-    }
+    for (const q of result.questions) lines.push(`- ${q.question || q}`);
     lines.push("");
   }
 

package/src/commands/discover.js

@@ -2,57 +2,61 @@ import { createAgent } from "../agents/index.js";
 import { assertAgentsAvailable } from "../agents/availability.js";
 import { resolveRole } from "../config.js";
 import { buildDiscoverPrompt, parseDiscoverOutput } from "../prompts/discover.js";
-import { parseMaybeJsonString } from "../review/parser.js";
 
-function formatDiscover(result, mode) {
-  const lines = [];
-  lines.push(`## Discovery (${mode})`);
-  lines.push(`**Verdict:** ${result.verdict || "unknown"}`, "");
-
-  if (result.gaps?.length) {
-    lines.push("## Gaps");
-    for (const g of result.gaps) {
-      const sev = g.severity ? ` [${g.severity}]` : "";
-      lines.push(`- ${g.description || g}${sev}`);
-      if (g.suggestedQuestion) lines.push(`  → ${g.suggestedQuestion}`);
-    }
-    lines.push("");
+function formatGaps(gaps, lines) {
+  lines.push("## Gaps");
+  for (const g of gaps) {
+    const sev = g.severity ? ` [${g.severity}]` : "";
+    lines.push(`- ${g.description || g}${sev}`);
+    if (g.suggestedQuestion) lines.push(`  → ${g.suggestedQuestion}`);
   }
+  lines.push("");
+}
 
-  if (result.momTestQuestions?.length) {
-    lines.push("## Mom Test Questions");
-    for (const q of result.momTestQuestions) {
-      lines.push(`- ${q.question || q}`);
-      if (q.rationale) lines.push(`  _${q.rationale}_`);
-    }
-    lines.push("");
+function formatMomTest(questions, lines) {
+  lines.push("## Mom Test Questions");
+  for (const q of questions) {
+    lines.push(`- ${q.question || q}`);
+    if (q.rationale) lines.push(`  _${q.rationale}_`);
   }
+  lines.push("");
+}
 
-  if (result.wendelChecklist?.length) {
-    lines.push("## Wendel Checklist");
-    for (const w of result.wendelChecklist) {
-      const icon = w.status === "pass" ? "✓" : w.status === "fail" ? "✗" : "?";
-      lines.push(`- [${icon}] ${w.condition}: ${w.justification || ""}`);
-    }
-    lines.push("");
+function formatWendel(checklist, lines) {
+  lines.push("## Wendel Checklist");
+  for (const w of checklist) {
+    const icon = w.status === "pass" ? "✓" : w.status === "fail" ? "✗" : "?";
+    lines.push(`- [${icon}] ${w.condition}: ${w.justification || ""}`);
   }
+  lines.push("");
+}
 
-  if (result.classification) {
-    lines.push("## Classification");
-    lines.push(`- Type: ${result.classification.type}`);
-    if (result.classification.adoptionRisk) lines.push(`- Adoption risk: ${result.classification.adoptionRisk}`);
-    if (result.classification.frictionEstimate) lines.push(`- Friction: ${result.classification.frictionEstimate}`);
-    lines.push("");
-  }
+function formatClassification(classification, lines) {
+  lines.push("## Classification");
+  lines.push(`- Type: ${classification.type}`);
+  if (classification.adoptionRisk) lines.push(`- Adoption risk: ${classification.adoptionRisk}`);
+  if (classification.frictionEstimate) lines.push(`- Friction: ${classification.frictionEstimate}`);
+  lines.push("");
+}
 
-  if (result.jtbds?.length) {
-    lines.push("## Jobs-to-be-Done");
-    for (const j of result.jtbds) {
-      lines.push(`- **${j.id || ""}**: ${j.functional || j}`);
-    }
-    lines.push("");
+function formatJtbds(jtbds, lines) {
+  lines.push("## Jobs-to-be-Done");
+  for (const j of jtbds) {
+    lines.push(`- **${j.id || ""}**: ${j.functional || j}`);
   }
+  lines.push("");
+}
+
+function formatDiscover(result, mode) {
+  const lines = [];
+  lines.push(`## Discovery (${mode})`);
+  lines.push(`**Verdict:** ${result.verdict || "unknown"}`, "");
 
+  if (result.gaps?.length) formatGaps(result.gaps, lines);
+  if (result.momTestQuestions?.length) formatMomTest(result.momTestQuestions, lines);
+  if (result.wendelChecklist?.length) formatWendel(result.wendelChecklist, lines);
+  if (result.classification) formatClassification(result.classification, lines);
+  if (result.jtbds?.length) formatJtbds(result.jtbds, lines);
   if (result.summary) lines.push(`---\n${result.summary}`);
   return lines.join("\n");
 }

package/src/config.js

@@ -141,6 +141,7 @@ const DEFAULTS = {
     max_reviewer_retries: 3,
     max_tester_retries: 1,
     max_security_retries: 1,
+    max_auto_resumes: 2,
     expiry_days: 30
   },
   failFast: {

package/src/mcp/server-handlers.js

@@ -171,6 +171,69 @@ export function buildAskQuestion(server) {
   };
 }
 
+const MAX_AUTO_RESUMES = 2;
+const NON_RECOVERABLE_CATEGORIES = new Set([
+  "config_error", "auth_error", "agent_missing", "branch_error", "git_error"
+]);
+
+async function attemptAutoResume({ err, config, logger, emitter, askQuestion, runLog }) {
+  const { category } = classifyError(err);
+  if (NON_RECOVERABLE_CATEGORIES.has(category)) return null;
+
+  // Find session ID from most recent session file
+  const { loadMostRecentSession } = await import("../session-store.js");
+  let session;
+  try {
+    session = await loadMostRecentSession();
+  } catch {
+    return null;
+  }
+  if (!session || !["failed", "stopped"].includes(session.status)) return null;
+
+  const maxRetries = config.session?.max_auto_resumes ?? MAX_AUTO_RESUMES;
+  const autoResumeCount = session.auto_resume_count || 0;
+  if (autoResumeCount >= maxRetries) {
+    runLog.logText(`[resilient] auto-resume limit reached (${maxRetries}), giving up`);
+    return null;
+  }
+
+  runLog.logText(`[resilient] run failed (${category}), auto-resuming (${autoResumeCount + 1}/${maxRetries})...`);
+  emitter.emit("progress", {
+    type: "resilient:auto_resume",
+    attempt: autoResumeCount + 1,
+    maxRetries,
+    errorCategory: category,
+    sessionId: session.id
+  });
+
+  // Increment counter and save before resuming
+  const { saveSession } = await import("../session-store.js");
+  session.auto_resume_count = autoResumeCount + 1;
+  await saveSession(session);
+
+  try {
+    const result = await resumeFlow({
+      sessionId: session.id,
+      config,
+      logger,
+      flags: {},
+      emitter,
+      askQuestion
+    });
+    const ok = !result.paused && (result.approved !== false);
+    runLog.logText(`[resilient] auto-resume ${ok ? "succeeded" : "finished"} — ok=${ok}`);
+    return { ok, ...result, autoResumed: true, autoResumeAttempt: autoResumeCount + 1 };
+  } catch (error) {
+    // Recursive: try again if still within limits
+    const nestedResult = await attemptAutoResume({
+      err: error, config, logger, emitter, askQuestion, runLog
+    });
+    if (nestedResult) return nestedResult;
+    runLog.logText(`[resilient] auto-resume failed: ${error.message}`);
+    return null;
+  }
+}
+
 export async function handleRunDirect(a, server, extra) {
   const config = await buildConfig(a);
   await assertNotOnBaseBranch(config);
@@ -209,6 +272,12 @@ export async function handleRunDirect(a, server, extra) {
     const result = await runFlow({ task: a.task, config, logger, flags: a, emitter, askQuestion, pgTaskId, pgProject });
     runLog.logText(`[kj_run] finished — ok=${!result.paused && (result.approved !== false)}`);
     return { ok: !result.paused && (result.approved !== false), ...result };
+  } catch (err) {
+    const autoResumeResult = await attemptAutoResume({
+      err, config, logger, emitter, askQuestion, runLog, progressNotifier, extra
+    });
+    if (autoResumeResult) return autoResumeResult;
+    throw err;
   } finally {
     runLog.close();
   }

package/src/orchestrator/iteration-stages.js

@@ -256,8 +256,14 @@ async function handleTddFailure({ tddEval, config, logger, emitter, eventBase, s
 
 export async function runTddCheckStage({ config, logger, emitter, eventBase, session, trackBudget, iteration, askQuestion }) {
   logger.setContext({ iteration, stage: "tdd" });
-  const tddDiff = await generateDiff({ baseRef: session.session_start_sha });
-  const untrackedFiles = await getUntrackedFiles();
+  let tddDiff, untrackedFiles;
+  try {
+    tddDiff = await generateDiff({ baseRef: session.session_start_sha });
+    untrackedFiles = await getUntrackedFiles();
+  } catch (err) {
+    logger.warn(`TDD diff generation failed: ${err.message}`);
+    return { action: "continue", stageResult: { ok: false, summary: `TDD check failed: ${err.message}` } };
+  }
   const tddEval = evaluateTddPolicy(tddDiff, config.development, untrackedFiles);
   await addCheckpoint(session, {
     stage: "tdd-policy",
@@ -366,7 +372,13 @@ export async function runSonarStage({ config, logger, emitter, eventBase, sessio
   const sonarRole = new SonarRole({ config, logger, emitter });
   await sonarRole.init({ iteration });
   const sonarStart = Date.now();
-  const sonarOutput = await sonarRole.run();
+  let sonarOutput;
+  try {
+    sonarOutput = await sonarRole.run();
+  } catch (err) {
+    logger.warn(`Sonar threw: ${err.message}`);
+    sonarOutput = { ok: false, result: { error: err.message }, summary: `Sonar error: ${err.message}` };
+  }
   trackBudget({ role: "sonar", provider: "sonar", result: sonarOutput, duration_ms: Date.now() - sonarStart });
   const sonarResult = sonarOutput.result;
 
@@ -438,7 +450,13 @@ export async function runSonarCloudStage({ config, logger, emitter, eventBase, s
 
   const { runSonarCloudScan } = await import("../sonar/cloud-scanner.js");
   const scanStart = Date.now();
-  const result = await runSonarCloudScan(config);
+  let result;
+  try {
+    result = await runSonarCloudScan(config);
+  } catch (err) {
+    logger.warn(`SonarCloud threw: ${err.message}`);
+    result = { ok: false, error: err.message };
+  }
   trackBudget({ role: "sonarcloud", provider: "sonarcloud", result: { ok: result.ok }, duration_ms: Date.now() - scanStart });
 
   await addCheckpoint(session, {
@@ -550,7 +568,13 @@ export async function runReviewerStage({ reviewerRole, config, logger, emitter,
     })
   );
 
-  const diff = await fetchReviewDiff(session, logger);
+  let diff;
+  try {
+    diff = await fetchReviewDiff(session, logger);
+  } catch (err) {
+    logger.warn(`Review diff generation failed: ${err.message}`);
+    return { approved: false, blocking_issues: [{ description: `Diff generation failed: ${err.message}` }], non_blocking_suggestions: [], summary: `Reviewer failed: cannot generate diff — ${err.message}`, confidence: 0 };
+  }
   const reviewerOnOutput = ({ stream, line }) => {
     emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "reviewer" }, {
       message: line,
@@ -575,6 +599,9 @@ export async function runReviewerStage({ reviewerRole, config, logger, emitter,
         trackBudget({ role: "reviewer", provider: reviewer, model: reviewerRole.model, result, duration_ms: Date.now() - reviewerStart });
       }
     });
+  } catch (err) {
+    logger.warn(`Reviewer threw: ${err.message}`);
+    reviewerExec = { execResult: { ok: false, error: err.message }, attempts: [{ reviewer: reviewerRole.provider, result: { ok: false, error: err.message } }] };
   } finally {
     reviewerStall.stop();
   }

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

@@ -16,7 +16,13 @@ export async function runTesterStage({ config, logger, emitter, eventBase, sessi
   const tester = new TesterRole({ config, logger, emitter });
   await tester.init({ task, iteration });
   const testerStart = Date.now();
-  const testerOutput = await tester.run({ task, diff });
+  let testerOutput;
+  try {
+    testerOutput = await tester.run({ task, diff });
+  } catch (err) {
+    logger.warn(`Tester threw: ${err.message}`);
+    testerOutput = { ok: false, summary: `Tester error: ${err.message}`, result: { error: err.message } };
+  }
   trackBudget({
     role: "tester",
     provider: config?.roles?.tester?.provider || coderRole.provider,
@@ -90,7 +96,13 @@ export async function runSecurityStage({ config, logger, emitter, eventBase, ses
   const security = new SecurityRole({ config, logger, emitter });
   await security.init({ task, iteration });
   const securityStart = Date.now();
-  const securityOutput = await security.run({ task, diff });
+  let securityOutput;
+  try {
+    securityOutput = await security.run({ task, diff });
+  } catch (err) {
+    logger.warn(`Security threw: ${err.message}`);
+    securityOutput = { ok: false, summary: `Security error: ${err.message}`, result: { error: err.message } };
+  }
   trackBudget({
     role: "security",
     provider: config?.roles?.security?.provider || coderRole.provider,

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

@@ -69,6 +69,9 @@ export async function runTriageStage({ config, logger, emitter, eventBase, sessi
   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();
   }
@@ -159,6 +162,9 @@ export async function runResearcherStage({ config, logger, emitter, eventBase, s
   let researchOutput;
   try {
     researchOutput = await researcher.run({ task: session.task, onOutput: researcherStall.onOutput });
+  } catch (err) {
+    logger.warn(`Researcher threw: ${err.message}`);
+    researchOutput = { ok: false, summary: `Researcher error: ${err.message}`, result: { error: err.message } };
   } finally {
     researcherStall.stop();
   }
@@ -281,6 +287,9 @@ export async function runArchitectStage({ config, logger, emitter, eventBase, se
       discoverResult,
       triageLevel
     });
+  } catch (err) {
+    logger.warn(`Architect threw: ${err.message}`);
+    architectOutput = { ok: false, summary: `Architect error: ${err.message}`, result: { error: err.message } };
   } finally {
     architectStall.stop();
   }
@@ -380,6 +389,9 @@ export async function runPlannerStage({ config, logger, emitter, eventBase, sess
   let planResult;
   try {
     planResult = await planRole.execute({ task, onOutput: plannerStall.onOutput });
+  } catch (err) {
+    logger.warn(`Planner threw: ${err.message}`);
+    planResult = { ok: false, result: { error: err.message }, summary: `Planner error: ${err.message}` };
   } finally {
     plannerStall.stop();
   }
@@ -453,6 +465,9 @@ export async function runDiscoverStage({ config, logger, emitter, eventBase, ses
   let discoverOutput;
   try {
     discoverOutput = await discover.run({ task: session.task, mode, onOutput: discoverStall.onOutput });
+  } catch (err) {
+    logger.warn(`Discover threw: ${err.message}`);
+    discoverOutput = { ok: false, summary: `Discover error: ${err.message}`, result: { error: err.message } };
   } finally {
     discoverStall.stop();
   }

package/src/orchestrator/reviewer-fallback.js

@@ -16,7 +16,13 @@ export async function runReviewerWithFallback({ reviewerName, config, logger, em
     const role = new ReviewerRole({ config: reviewerConfig, logger, emitter, createAgentFn: createAgent });
     await role.init();
     for (let attempt = 1; attempt <= retries + 1; attempt += 1) {
-      const execResult = await role.execute(reviewInput);
+      let execResult;
+      try {
+        execResult = await role.execute(reviewInput);
+      } catch (err) {
+        logger.warn(`Reviewer ${name} attempt ${attempt} threw: ${err.message}`);
+        execResult = { ok: false, result: { error: err.message }, summary: `Reviewer error: ${err.message}` };
+      }
       if (onAttemptResult) {
         await onAttemptResult({ reviewer: name, result: execResult.result });
       }

package/src/orchestrator/solomon-escalation.js

@@ -19,7 +19,16 @@ export async function invokeSolomon({ config, logger, emitter, eventBase, stage,
 
   const solomon = new SolomonRole({ config, logger, emitter });
   await solomon.init({ task: conflict.task || session.task, iteration });
-  const ruling = await solomon.run({ conflict });
+  let ruling;
+  try {
+    ruling = await solomon.run({ conflict });
+  } catch (err) {
+    logger.warn(`Solomon threw: ${err.message}`);
+    return escalateToHuman({
+      askQuestion, session, emitter, eventBase, stage, iteration,
+      conflict: { ...conflict, solomonReason: `Solomon error: ${err.message}` }
+    });
+  }
 
   emitProgress(
     emitter,

package/src/session-store.js

@@ -63,6 +63,24 @@ export async function pauseSession(session, { question, context: pauseContext })
   await saveSession(session);
 }
 
+export async function loadMostRecentSession() {
+  let entries;
+  try {
+    entries = await fs.readdir(SESSION_ROOT, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  const dirs = entries.filter(e => e.isDirectory()).map(e => e.name).sort();
+  for (let i = dirs.length - 1; i >= 0; i--) {
+    try {
+      return await loadSession(dirs[i]);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
 export async function resumeSessionWithAnswer(sessionId, answer) {
   const session = await loadSession(sessionId);
   if (session.status !== "paused") {

package/src/utils/run-log.js

@@ -183,13 +183,15 @@ export function readRunLog(projectDir, maxLines = 50) {
     const total = lines.length;
     const shown = lines.slice(-maxLines);
     const status = parseRunStatus(lines);
+    const MAX_LINE_CHARS = 2000;
+    const truncated = shown.map(l => l.length > MAX_LINE_CHARS ? l.slice(0, MAX_LINE_CHARS) + "… [truncated]" : l);
     return {
       ok: true,
       path: logPath,
       totalLines: total,
       status,
-      lines: shown,
-      summary: shown.join("\n")
+      lines: truncated,
+      summary: truncated.join("\n")
     };
   } catch (err) {
     return {