karajan-code 1.21.1 → 1.22.0

package/package.json

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

package/src/agents/host-agent.js

@@ -0,0 +1,38 @@
+/**
+ * Host Agent — delegates task execution to the MCP host AI via elicitation.
+ *
+ * Instead of spawning a subprocess, returns the prompt to the host AI
+ * (Claude, Codex, etc.) for direct execution. The host has full access
+ * to the codebase and tools — no subprocess overhead.
+ *
+ * Used when: the MCP host IS the same agent configured for a role.
+ */
+
+import { BaseAgent } from "./base-agent.js";
+
+export class HostAgent extends BaseAgent {
+  constructor(config, logger, { askHost }) {
+    super("host", config, logger);
+    this._askHost = askHost;
+  }
+
+  async runTask(task) {
+    const { prompt, onOutput } = task;
+
+    if (!this._askHost) {
+      return { ok: false, output: "", error: "Host agent has no askHost callback" };
+    }
+
+    if (onOutput) onOutput({ stream: "info", line: "[host-agent] Delegating to host AI..." });
+
+    const answer = await this._askHost(prompt);
+
+    if (!answer) {
+      return { ok: false, output: "", error: "Host AI declined or returned no response" };
+    }
+
+    if (onOutput) onOutput({ stream: "info", line: "[host-agent] Host AI completed task" });
+
+    return { ok: true, output: answer, exitCode: 0 };
+  }
+}

package/src/mcp/orphan-guard.js

@@ -22,6 +22,53 @@ export function setupOrphanGuard({ intervalMs = DEFAULT_INTERVAL_MS, exitFn = ()
   return { timer, parentPid };
 }
 
+const DEFAULT_MEMORY_CHECK_MS = 30_000;
+const DEFAULT_WARN_HEAP_MB = 512;
+const DEFAULT_CRITICAL_HEAP_MB = 768;
+
+export function setupMemoryWatchdog({
+  intervalMs = DEFAULT_MEMORY_CHECK_MS,
+  warnHeapMb = DEFAULT_WARN_HEAP_MB,
+  criticalHeapMb = DEFAULT_CRITICAL_HEAP_MB,
+  onWarn = null,
+  onCritical = null,
+  exitFn = () => process.exit(1)
+} = {}) {
+  const warnBytes = warnHeapMb * 1024 * 1024;
+  const criticalBytes = criticalHeapMb * 1024 * 1024;
+  let warned = false;
+
+  const timer = setInterval(() => {
+    const { heapUsed, rss } = process.memoryUsage();
+
+    if (heapUsed >= criticalBytes) {
+      if (global.gc) {
+        try { global.gc(); } catch { /* --expose-gc not set */ }
+        const after = process.memoryUsage().heapUsed;
+        if (after < criticalBytes) return; // GC freed enough
+      }
+      const msg = `Memory critical: heap ${(heapUsed / 1024 / 1024).toFixed(0)}MB / rss ${(rss / 1024 / 1024).toFixed(0)}MB — exiting to prevent OOM`;
+      if (onCritical) onCritical(msg);
+      else process.stderr.write(`[karajan-mcp] ${msg}\n`);
+      clearInterval(timer);
+      exitFn();
+      return;
+    }
+
+    if (heapUsed >= warnBytes && !warned) {
+      warned = true;
+      const msg = `Memory warning: heap ${(heapUsed / 1024 / 1024).toFixed(0)}MB / rss ${(rss / 1024 / 1024).toFixed(0)}MB (critical at ${criticalHeapMb}MB)`;
+      if (onWarn) onWarn(msg);
+      else process.stderr.write(`[karajan-mcp] ${msg}\n`);
+    } else if (heapUsed < warnBytes) {
+      warned = false;
+    }
+  }, intervalMs);
+  timer.unref();
+
+  return { timer };
+}
+
 export function setupVersionWatcher({ pkgPath, currentVersion, exitFn = () => process.exit(0) } = {}) {
   if (!pkgPath) return null;
 

package/src/mcp/server-handlers.js

@@ -287,22 +287,36 @@ export async function handleResumeDirect(a, server, extra) {
   const config = await buildConfig(a);
   const logger = createLogger(config.output.log_level, "mcp");
 
+  const projectDir = await resolveProjectDir(server);
+  const runLog = createRunLog(projectDir);
+  runLog.logText(`[kj_resume] started — session="${a.sessionId}"`);
+
   const emitter = new EventEmitter();
   emitter.on("progress", buildProgressHandler(server));
+  emitter.on("progress", (event) => runLog.logEvent(event));
   const progressNotifier = buildProgressNotifier(extra);
   if (progressNotifier) emitter.on("progress", progressNotifier);
 
   const askQuestion = buildAskQuestion(server);
-  const result = await resumeFlow({
-    sessionId: a.sessionId,
-    answer: a.answer || null,
-    config,
-    logger,
-    flags: a,
-    emitter,
-    askQuestion
-  });
-  return { ok: true, ...result };
+  try {
+    const result = await resumeFlow({
+      sessionId: a.sessionId,
+      answer: a.answer || null,
+      config,
+      logger,
+      flags: a,
+      emitter,
+      askQuestion
+    });
+    const ok = !result.paused && (result.approved !== false);
+    runLog.logText(`[kj_resume] finished — ok=${ok}`);
+    return { ok, ...result };
+  } catch (err) {
+    runLog.logText(`[kj_resume] failed: ${err.message}`);
+    throw err;
+  } finally {
+    runLog.close();
+  }
 }
 
 function buildDirectEmitter(server, runLog, extra) {

package/src/mcp/server.js

@@ -50,9 +50,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
 });
 
 // --- Orphan process protection + version watcher ---
-import { setupOrphanGuard, setupVersionWatcher } from "./orphan-guard.js";
+import { setupOrphanGuard, setupVersionWatcher, setupMemoryWatchdog } from "./orphan-guard.js";
 setupOrphanGuard();
 setupVersionWatcher({ pkgPath: PKG_PATH, currentVersion: LOADED_VERSION });
+setupMemoryWatchdog();
 
 const transport = new StdioServerTransport();
 await mcpServer.connect(transport);

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/orchestrator.js

@@ -958,14 +958,45 @@ async function handleApprovedReview({ config, session, emitter, eventBase, coder
   return { action: "return", result };
 }
 
-async function handleMaxIterationsReached({ session, budgetSummary, emitter, eventBase, config, stageResults }) {
+async function handleMaxIterationsReached({ session, budgetSummary, emitter, eventBase, config, stageResults, logger, askQuestion, task }) {
+  // Escalate to Solomon / human before giving up
+  const solomonResult = await invokeSolomon({
+    config, logger, emitter, eventBase, stage: "max_iterations", askQuestion, session,
+    iteration: config.max_iterations,
+    conflict: {
+      stage: "max_iterations",
+      task,
+      iterationCount: config.max_iterations,
+      maxIterations: config.max_iterations,
+      history: [{ agent: "pipeline", feedback: session.last_reviewer_feedback || "Max iterations reached without reviewer approval" }]
+    }
+  });
+
+  if (solomonResult.action === "continue") {
+    if (solomonResult.humanGuidance) {
+      session.last_reviewer_feedback = `User guidance: ${solomonResult.humanGuidance}`;
+    }
+    session.reviewer_retry_count = 0;
+    await saveSession(session);
+    return { approved: false, sessionId: session.id, reason: "max_iterations_extended", humanGuidance: solomonResult.humanGuidance };
+  }
+
+  if (solomonResult.action === "pause") {
+    return { paused: true, sessionId: session.id, question: solomonResult.question, context: "max_iterations" };
+  }
+
+  if (solomonResult.action === "subtask") {
+    return { paused: true, sessionId: session.id, subtask: solomonResult.subtask, context: "max_iterations_subtask" };
+  }
+
+  // Solomon also couldn't resolve — fail
   session.budget = budgetSummary();
   await markSessionStatus(session, "failed");
   emitProgress(
     emitter,
     makeEvent("session:end", { ...eventBase, stage: "done" }, {
       status: "fail",
-      message: "Max iterations reached",
+      message: "Max iterations reached (Solomon could not resolve)",
       detail: { approved: false, reason: "max_iterations", iterations: config.max_iterations, stages: stageResults, budget: budgetSummary() }
     })
   );
@@ -978,7 +1009,7 @@ async function initFlowContext({ task, config, logger, emitter, askQuestion, pgT
   const refactorerRole = resolveRole(config, "refactorer");
   const pipelineFlags = resolvePipelineFlags(config);
   const repeatDetector = new RepeatDetector({ threshold: getRepeatThreshold(config) });
-  const coderRoleInstance = new CoderRole({ config, logger, emitter, createAgentFn: createAgent });
+  const coderRoleInstance = new CoderRole({ config, logger, emitter, createAgentFn: createAgent, askHost: askQuestion });
   const startedAt = Date.now();
   const eventBase = { sessionId: null, iteration: 0, stage: null, startedAt };
   const { budgetTracker, budgetLimit, budgetSummary, trackBudget } = createBudgetManager({ config, emitter, eventBase });
@@ -1109,7 +1140,7 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
     if (iterResult.action === "retry") { i -= 1; }
   }
 
-  return handleMaxIterationsReached({ session: ctx.session, budgetSummary: ctx.budgetSummary, emitter, eventBase: ctx.eventBase, config, stageResults: ctx.stageResults });
+  return handleMaxIterationsReached({ session: ctx.session, budgetSummary: ctx.budgetSummary, emitter, eventBase: ctx.eventBase, config, stageResults: ctx.stageResults, logger, askQuestion, task });
 }
 
 export async function resumeFlow({ sessionId, answer, config, logger, flags = {}, emitter = null, askQuestion = null }) {
@@ -1162,5 +1193,10 @@ export async function resumeFlow({ sessionId, answer, config, logger, flags = {}
   await saveSession(session);
 
   // Re-run the flow with the existing session context
-  return runFlow({ task, config: sessionConfig, logger, flags, emitter, askQuestion });
+  try {
+    return await runFlow({ task, config: sessionConfig, logger, flags, emitter, askQuestion });
+  } catch (err) {
+    await markSessionStatus(session, "failed");
+    throw err;
+  }
 }

package/src/roles/coder-role.js

@@ -1,6 +1,8 @@
 import { BaseRole } from "./base-role.js";
 import { createAgent as defaultCreateAgent } from "../agents/index.js";
 import { buildCoderPrompt } from "../prompts/coder.js";
+import { isHostAgent } from "../utils/agent-detect.js";
+import { HostAgent } from "../agents/host-agent.js";
 
 function resolveProvider(config) {
   return (
@@ -11,9 +13,10 @@ function resolveProvider(config) {
 }
 
 export class CoderRole extends BaseRole {
-  constructor({ config, logger, emitter = null, createAgentFn = null }) {
+  constructor({ config, logger, emitter = null, createAgentFn = null, askHost = null }) {
     super({ name: "coder", config, logger, emitter });
     this._createAgent = createAgentFn || defaultCreateAgent;
+    this._askHost = askHost;
   }
 
   async execute(input) {
@@ -22,7 +25,14 @@ export class CoderRole extends BaseRole {
       : input || {};
 
     const provider = resolveProvider(this.config);
-    const agent = this._createAgent(provider, this.config, this.logger);
+    const useHost = this._askHost && isHostAgent(provider);
+    const agent = useHost
+      ? new HostAgent(this.config, this.logger, { askHost: this._askHost })
+      : this._createAgent(provider, this.config, this.logger);
+
+    if (useHost) {
+      this.logger.info(`Host-as-coder: delegating to host AI (skipping ${provider} subprocess)`);
+    }
 
     const prompt = buildCoderPrompt({
       task: task || this.context?.task || "",

package/src/session-store.js

@@ -83,8 +83,9 @@ export async function loadMostRecentSession() {
 
 export async function resumeSessionWithAnswer(sessionId, answer) {
   const session = await loadSession(sessionId);
-  if (session.status !== "paused") {
-    throw new Error(`Session ${sessionId} is not paused (status: ${session.status})`);
+  const resumable = new Set(["paused", "running", "failed", "stopped"]);
+  if (!resumable.has(session.status)) {
+    throw new Error(`Session ${sessionId} cannot be resumed (status: ${session.status})`);
   }
   const pausedState = session.paused_state;
   if (!pausedState) {

package/src/utils/agent-detect.js

@@ -30,4 +30,25 @@ export async function detectAvailableAgents() {
   return results;
 }
 
+/**
+ * Detect which AI agent is the current MCP host (if any).
+ * Returns the agent name ("claude", "codex", etc.) or null if not inside an agent.
+ */
+export function detectHostAgent() {
+  if (process.env.CLAUDECODE === "1" || process.env.CLAUDE_CODE === "1") return "claude";
+  if (process.env.CODEX_CLI === "1" || process.env.CODEX === "1") return "codex";
+  if (process.env.GEMINI_CLI === "1") return "gemini";
+  if (process.env.OPENCODE === "1") return "opencode";
+  return null;
+}
+
+/**
+ * Check if a given provider matches the current host agent.
+ * When true, we can skip subprocess spawning and delegate to the host.
+ */
+export function isHostAgent(provider) {
+  const host = detectHostAgent();
+  return host !== null && host === provider;
+}
+
 export { KNOWN_AGENTS };