karajan-code 1.2.2 → 1.2.3

package/README.md

@@ -11,7 +11,7 @@
 <p align="center">
   <a href="https://www.npmjs.com/package/karajan-code"><img src="https://img.shields.io/npm/v/karajan-code.svg" alt="npm version"></a>
   <a href="https://github.com/manufosela/karajan-code/actions"><img src="https://github.com/manufosela/karajan-code/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
-  <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License"></a>
+  <a href="https://www.gnu.org/licenses/agpl-3.0"><img src="https://img.shields.io/badge/license-AGPL--3.0-blue.svg" alt="License"></a>
   <a href="https://nodejs.org"><img src="https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg" alt="Node.js"></a>
 </p>
 
@@ -441,5 +441,5 @@ npm run validate      # Lint + test
 
 - [Changelog](CHANGELOG.md)
 - [Security Policy](SECURITY.md)
-- [License (MIT)](LICENSE)
+- [License (AGPL-3.0)](LICENSE)
 - [Issues](https://github.com/manufosela/karajan-code/issues)

package/docs/README.es.md

@@ -11,7 +11,7 @@
 <p align="center">
   <a href="https://www.npmjs.com/package/karajan-code"><img src="https://img.shields.io/npm/v/karajan-code.svg" alt="npm version"></a>
   <a href="https://github.com/manufosela/karajan-code/actions"><img src="https://github.com/manufosela/karajan-code/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
-  <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License"></a>
+  <a href="https://www.gnu.org/licenses/agpl-3.0"><img src="https://img.shields.io/badge/license-AGPL--3.0-blue.svg" alt="License"></a>
   <a href="https://nodejs.org"><img src="https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg" alt="Node.js"></a>
 </p>
 
@@ -240,5 +240,5 @@ npm run validate      # Lint + test
 
 - [Changelog](../CHANGELOG.md)
 - [Politica de seguridad](../SECURITY.md)
-- [Licencia (MIT)](../LICENSE)
+- [Licencia (AGPL-3.0)](../LICENSE)
 - [Issues](https://github.com/manufosela/karajan-code/issues)

package/package.json

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

package/src/agents/availability.js

@@ -1,20 +1,14 @@
 import { runCommand } from "../utils/process.js";
 import { resolveBin } from "./resolve-bin.js";
-
-const AGENT_META = {
-  codex: { bin: "codex", installUrl: "https://developers.openai.com/codex/cli" },
-  claude: { bin: "claude", installUrl: "https://docs.anthropic.com/en/docs/claude-code" },
-  gemini: { bin: "gemini", installUrl: "https://github.com/google-gemini/gemini-cli" },
-  aider: { bin: "aider", installUrl: "https://aider.chat/docs/install.html" }
-};
+import { getAgentMeta } from "./index.js";
 
 export async function assertAgentsAvailable(agentNames = []) {
   const unique = [...new Set(agentNames.filter(Boolean))];
   const missing = [];
 
   for (const name of unique) {
-    const meta = AGENT_META[name];
-    if (!meta) continue;
+    const meta = getAgentMeta(name);
+    if (!meta || !meta.bin) continue;
     const res = await runCommand(resolveBin(meta.bin), ["--version"]);
     if (res.exitCode !== 0) {
       missing.push({ name, ...meta });

package/src/agents/index.js

@@ -3,17 +3,38 @@ import { CodexAgent } from "./codex-agent.js";
 import { GeminiAgent } from "./gemini-agent.js";
 import { AiderAgent } from "./aider-agent.js";
 
+const agentRegistry = new Map();
+
+export function registerAgent(name, AgentClass, meta = {}) {
+  if (!name || typeof name !== "string") {
+    throw new Error("Agent name must be a non-empty string");
+  }
+  agentRegistry.set(name, { AgentClass, meta });
+}
+
+export function getAvailableAgents() {
+  return [...agentRegistry.entries()].map(([name, { AgentClass, meta }]) => ({
+    name,
+    AgentClass,
+    ...meta,
+  }));
+}
+
+export function getAgentMeta(name) {
+  const entry = agentRegistry.get(name);
+  return entry ? { ...entry.meta } : null;
+}
+
 export function createAgent(agentName, config, logger) {
-  switch (agentName) {
-    case "claude":
-      return new ClaudeAgent(agentName, config, logger);
-    case "codex":
-      return new CodexAgent(agentName, config, logger);
-    case "gemini":
-      return new GeminiAgent(agentName, config, logger);
-    case "aider":
-      return new AiderAgent(agentName, config, logger);
-    default:
-      throw new Error(`Unsupported agent: ${agentName}`);
+  const entry = agentRegistry.get(agentName);
+  if (!entry) {
+    throw new Error(`Unsupported agent: ${agentName}`);
   }
+  return new entry.AgentClass(agentName, config, logger);
 }
+
+// Auto-register built-in agents with CLI metadata
+registerAgent("claude", ClaudeAgent, { bin: "claude", installUrl: "https://docs.anthropic.com/en/docs/claude-code" });
+registerAgent("codex", CodexAgent, { bin: "codex", installUrl: "https://developers.openai.com/codex/cli" });
+registerAgent("gemini", GeminiAgent, { bin: "gemini", installUrl: "https://github.com/google-gemini/gemini-cli" });
+registerAgent("aider", AiderAgent, { bin: "aider", installUrl: "https://aider.chat/docs/install.html" });

package/src/agents/model-registry.js

@@ -0,0 +1,62 @@
+const modelRegistry = new Map();
+
+export function registerModel(name, { provider, pricing, deprecated } = {}) {
+  if (!name || typeof name !== "string") {
+    throw new Error("Model name must be a non-empty string");
+  }
+  if (!pricing || typeof pricing.input_per_million !== "number" || typeof pricing.output_per_million !== "number") {
+    throw new Error(`Model "${name}" requires pricing with input_per_million and output_per_million`);
+  }
+  modelRegistry.set(name, {
+    provider: provider || name.split("/")[0],
+    pricing: { input_per_million: pricing.input_per_million, output_per_million: pricing.output_per_million },
+    deprecated: deprecated || null,
+  });
+}
+
+export function getModelPricing(name) {
+  const entry = modelRegistry.get(name);
+  return entry ? { ...entry.pricing } : null;
+}
+
+export function isModelDeprecated(name) {
+  const entry = modelRegistry.get(name);
+  if (!entry || !entry.deprecated) return false;
+  return new Date(entry.deprecated) <= new Date();
+}
+
+export function getModelInfo(name) {
+  const entry = modelRegistry.get(name);
+  if (!entry) return null;
+  return { name, provider: entry.provider, pricing: { ...entry.pricing }, deprecated: entry.deprecated };
+}
+
+export function getRegisteredModels() {
+  return [...modelRegistry.entries()].map(([name, entry]) => ({
+    name,
+    provider: entry.provider,
+    pricing: { ...entry.pricing },
+    deprecated: entry.deprecated,
+  }));
+}
+
+export function buildDefaultPricingTable() {
+  const table = {};
+  for (const [name, entry] of modelRegistry) {
+    table[name] = { ...entry.pricing };
+  }
+  return table;
+}
+
+// Auto-register built-in models
+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("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("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("aider", { provider: "aider", pricing: { input_per_million: 3, output_per_million: 15 } });

package/src/mcp/orphan-guard.js

@@ -0,0 +1,21 @@
+const DEFAULT_INTERVAL_MS = 5000;
+
+export function setupOrphanGuard({ intervalMs = DEFAULT_INTERVAL_MS, exitFn = () => process.exit(0) } = {}) {
+  const parentPid = process.ppid;
+
+  const timer = setInterval(() => {
+    try {
+      process.kill(parentPid, 0);
+    } catch {
+      clearInterval(timer);
+      exitFn();
+    }
+  }, intervalMs);
+  timer.unref();
+
+  process.stdin.on("end", exitFn);
+  process.stdin.on("close", exitFn);
+  process.on("SIGHUP", exitFn);
+
+  return { timer, parentPid };
+}

package/src/mcp/server.js

@@ -33,5 +33,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
   }
 });
 
+// --- Orphan process protection ---
+import { setupOrphanGuard } from "./orphan-guard.js";
+setupOrphanGuard();
+
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/src/orchestrator/iteration-stages.js

@@ -0,0 +1,404 @@
+import { createAgent } from "../agents/index.js";
+import { RefactorerRole } from "../roles/refactorer-role.js";
+import { SonarRole } from "../roles/sonar-role.js";
+import { addCheckpoint, markSessionStatus, saveSession, pauseSession } from "../session-store.js";
+import { generateDiff } from "../review/diff-generator.js";
+import { evaluateTddPolicy } from "../review/tdd-policy.js";
+import { validateReviewResult } from "../review/schema.js";
+import { emitProgress, makeEvent } from "../utils/events.js";
+import { runReviewerWithFallback } from "./reviewer-fallback.js";
+import { invokeSolomon } from "./solomon-escalation.js";
+
+export async function runCoderStage({ coderRoleInstance, coderRole, config, logger, emitter, eventBase, session, plannedTask, trackBudget, iteration }) {
+  logger.setContext({ iteration, stage: "coder" });
+  emitProgress(
+    emitter,
+    makeEvent("coder:start", { ...eventBase, stage: "coder" }, {
+      message: `Coder (${coderRole.provider}) running`,
+      detail: { coder: coderRole.provider }
+    })
+  );
+
+  const coderOnOutput = ({ stream, line }) => {
+    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "coder" }, {
+      message: line,
+      detail: { stream, agent: coderRole.provider }
+    }));
+  };
+  const coderStart = Date.now();
+  const coderExecResult = await coderRoleInstance.execute({
+    task: plannedTask,
+    reviewerFeedback: session.last_reviewer_feedback,
+    sonarSummary: session.last_sonar_summary,
+    onOutput: coderOnOutput
+  });
+  trackBudget({ role: "coder", provider: coderRole.provider, model: coderRole.model, result: coderExecResult.result, duration_ms: Date.now() - coderStart });
+
+  if (!coderExecResult.ok) {
+    await markSessionStatus(session, "failed");
+    const details = coderExecResult.result?.error || coderExecResult.summary || "unknown error";
+    emitProgress(
+      emitter,
+      makeEvent("coder:end", { ...eventBase, stage: "coder" }, {
+        status: "fail",
+        message: `Coder failed: ${details}`
+      })
+    );
+    throw new Error(`Coder failed: ${details}`);
+  }
+
+  await addCheckpoint(session, { stage: "coder", iteration, note: "Coder applied changes" });
+  emitProgress(
+    emitter,
+    makeEvent("coder:end", { ...eventBase, stage: "coder" }, {
+      message: "Coder completed"
+    })
+  );
+}
+
+export async function runRefactorerStage({ refactorerRole, config, logger, emitter, eventBase, session, plannedTask, trackBudget, iteration }) {
+  logger.setContext({ iteration, stage: "refactorer" });
+  emitProgress(
+    emitter,
+    makeEvent("refactorer:start", { ...eventBase, stage: "refactorer" }, {
+      message: `Refactorer (${refactorerRole.provider}) running`,
+      detail: { refactorer: refactorerRole.provider }
+    })
+  );
+  const refRole = new RefactorerRole({ config, logger, emitter, createAgentFn: createAgent });
+  await refRole.init();
+  const refactorerStart = Date.now();
+  const refResult = await refRole.execute(plannedTask);
+  trackBudget({ role: "refactorer", provider: refactorerRole.provider, model: refactorerRole.model, result: refResult.result, duration_ms: Date.now() - refactorerStart });
+  if (!refResult.ok) {
+    await markSessionStatus(session, "failed");
+    const details = refResult.result?.error || refResult.summary || "unknown error";
+    emitProgress(
+      emitter,
+      makeEvent("refactorer:end", { ...eventBase, stage: "refactorer" }, {
+        status: "fail",
+        message: `Refactorer failed: ${details}`
+      })
+    );
+    throw new Error(`Refactorer failed: ${details}`);
+  }
+  await addCheckpoint(session, { stage: "refactorer", iteration, note: "Refactorer applied cleanups" });
+  emitProgress(
+    emitter,
+    makeEvent("refactorer:end", { ...eventBase, stage: "refactorer" }, {
+      message: "Refactorer completed"
+    })
+  );
+}
+
+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 tddEval = evaluateTddPolicy(tddDiff, config.development);
+  await addCheckpoint(session, {
+    stage: "tdd-policy",
+    iteration,
+    ok: tddEval.ok,
+    reason: tddEval.reason,
+    source_files: tddEval.sourceFiles?.length || 0,
+    test_files: tddEval.testFiles?.length || 0
+  });
+
+  emitProgress(
+    emitter,
+    makeEvent("tdd:result", { ...eventBase, stage: "tdd" }, {
+      status: tddEval.ok ? "ok" : "fail",
+      message: tddEval.ok ? "TDD policy passed" : `TDD policy failed: ${tddEval.reason}`,
+      detail: {
+        ok: tddEval.ok,
+        reason: tddEval.reason,
+        sourceFiles: tddEval.sourceFiles?.length || 0,
+        testFiles: tddEval.testFiles?.length || 0
+      }
+    })
+  );
+
+  if (!tddEval.ok) {
+    session.last_reviewer_feedback = tddEval.message;
+    session.repeated_issue_count += 1;
+    await saveSession(session);
+    if (session.repeated_issue_count >= config.session.fail_fast_repeats) {
+      const question = `TDD policy has failed ${session.repeated_issue_count} times. The coder is not creating tests. How should we proceed? Issue: ${tddEval.reason}`;
+      if (askQuestion) {
+        const answer = await askQuestion(question, { iteration, stage: "tdd" });
+        if (answer) {
+          session.last_reviewer_feedback += `\nUser guidance: ${answer}`;
+          session.repeated_issue_count = 0;
+          await saveSession(session);
+          return { action: "continue" };
+        }
+      }
+      await pauseSession(session, {
+        question,
+        context: {
+          iteration,
+          stage: "tdd",
+          lastFeedback: tddEval.message,
+          repeatedCount: session.repeated_issue_count
+        }
+      });
+      emitProgress(
+        emitter,
+        makeEvent("question", { ...eventBase, stage: "tdd" }, {
+          status: "paused",
+          message: question,
+          detail: { question, sessionId: session.id }
+        })
+      );
+      return { action: "pause", result: { paused: true, sessionId: session.id, question, context: "tdd_fail_fast" } };
+    }
+    return { action: "continue" };
+  }
+
+  return { action: "ok" };
+}
+
+export async function runSonarStage({ config, logger, emitter, eventBase, session, trackBudget, iteration, repeatDetector, budgetSummary, sonarState, askQuestion, task }) {
+  logger.setContext({ iteration, stage: "sonar" });
+  emitProgress(
+    emitter,
+    makeEvent("sonar:start", { ...eventBase, stage: "sonar" }, {
+      message: "SonarQube scanning"
+    })
+  );
+
+  const sonarRole = new SonarRole({ config, logger, emitter });
+  await sonarRole.init({ iteration });
+  const sonarStart = Date.now();
+  const sonarOutput = await sonarRole.run();
+  trackBudget({ role: "sonar", provider: "sonar", result: sonarOutput, duration_ms: Date.now() - sonarStart });
+  const sonarResult = sonarOutput.result;
+
+  if (!sonarResult.gateStatus && sonarResult.error) {
+    await markSessionStatus(session, "failed");
+    emitProgress(
+      emitter,
+      makeEvent("sonar:end", { ...eventBase, stage: "sonar" }, {
+        status: "fail",
+        message: `Sonar scan failed: ${sonarResult.error}`
+      })
+    );
+    throw new Error(`Sonar scan failed: ${sonarResult.error}`);
+  }
+
+  session.last_sonar_summary = sonarOutput.summary;
+  if (typeof sonarResult.openIssuesTotal === "number") {
+    if (sonarState.issuesInitial === null) {
+      sonarState.issuesInitial = sonarResult.openIssuesTotal;
+    }
+    sonarState.issuesFinal = sonarResult.openIssuesTotal;
+  }
+  await addCheckpoint(session, {
+    stage: "sonar",
+    iteration,
+    project_key: sonarResult.projectKey,
+    quality_gate: sonarResult.gateStatus,
+    open_issues: sonarResult.openIssuesTotal
+  });
+
+  emitProgress(
+    emitter,
+    makeEvent("sonar:end", { ...eventBase, stage: "sonar" }, {
+      status: sonarResult.blocking ? "fail" : "ok",
+      message: `Quality gate: ${sonarResult.gateStatus}`,
+      detail: { projectKey: sonarResult.projectKey, gateStatus: sonarResult.gateStatus, openIssues: sonarResult.openIssuesTotal }
+    })
+  );
+
+  if (sonarResult.blocking) {
+    repeatDetector.addIteration(sonarResult.issues, []);
+    const repeatState = repeatDetector.isStalled();
+    if (repeatState.stalled) {
+      const repeatCounts = repeatDetector.getRepeatCounts();
+      const message = `No progress: SonarQube issues repeated ${repeatCounts.sonar} times.`;
+      logger.warn(message);
+      await markSessionStatus(session, "stalled");
+      emitProgress(
+        emitter,
+        makeEvent("session:end", { ...eventBase, stage: "sonar" }, {
+          status: "stalled",
+          message,
+          detail: { reason: repeatState.reason, repeats: repeatCounts.sonar, budget: budgetSummary() }
+        })
+      );
+      return { action: "stalled", result: { approved: false, sessionId: session.id, reason: "stalled" } };
+    }
+
+    session.last_reviewer_feedback = `Sonar gate blocking (${sonarResult.gateStatus}). Resolve critical findings first.`;
+    session.sonar_retry_count = (session.sonar_retry_count || 0) + 1;
+    await saveSession(session);
+    const maxSonarRetries = config.session.max_sonar_retries ?? config.session.fail_fast_repeats;
+    if (session.sonar_retry_count >= maxSonarRetries) {
+      emitProgress(
+        emitter,
+        makeEvent("solomon:escalate", { ...eventBase, stage: "sonar" }, {
+          message: `Sonar sub-loop limit reached (${session.sonar_retry_count}/${maxSonarRetries})`,
+          detail: { subloop: "sonar", retryCount: session.sonar_retry_count, limit: maxSonarRetries, gateStatus: sonarResult.gateStatus }
+        })
+      );
+
+      const solomonResult = await invokeSolomon({
+        config, logger, emitter, eventBase, stage: "sonar", askQuestion, session, iteration,
+        conflict: {
+          stage: "sonar",
+          task,
+          iterationCount: session.sonar_retry_count,
+          maxIterations: maxSonarRetries,
+          history: [{ agent: "sonar", feedback: session.last_sonar_summary }]
+        }
+      });
+
+      if (solomonResult.action === "pause") {
+        return { action: "pause", result: { paused: true, sessionId: session.id, question: solomonResult.question, context: "sonar_fail_fast" } };
+      }
+      if (solomonResult.action === "continue") {
+        if (solomonResult.humanGuidance) {
+          session.last_reviewer_feedback += `\nUser guidance: ${solomonResult.humanGuidance}`;
+        }
+        session.sonar_retry_count = 0;
+        await saveSession(session);
+        return { action: "continue" };
+      }
+      if (solomonResult.action === "subtask") {
+        return { action: "pause", result: { paused: true, sessionId: session.id, subtask: solomonResult.subtask, context: "sonar_subtask" } };
+      }
+    }
+    return { action: "continue" };
+  }
+
+  // Sonar passed — reset retry counter
+  session.sonar_retry_count = 0;
+  const issuesInitial = sonarState.issuesInitial ?? sonarResult.openIssuesTotal ?? 0;
+  const issuesFinal = sonarState.issuesFinal ?? sonarResult.openIssuesTotal ?? 0;
+  const stageResult = {
+    gateStatus: sonarResult.gateStatus,
+    openIssues: sonarResult.openIssuesTotal,
+    issuesInitial,
+    issuesFinal,
+    issuesResolved: Math.max(issuesInitial - issuesFinal, 0)
+  };
+
+  return { action: "ok", stageResult };
+}
+
+export async function runReviewerStage({ reviewerRole, config, logger, emitter, eventBase, session, trackBudget, iteration, reviewRules, task, repeatDetector, budgetSummary }) {
+  logger.setContext({ iteration, stage: "reviewer" });
+  emitProgress(
+    emitter,
+    makeEvent("reviewer:start", { ...eventBase, stage: "reviewer" }, {
+      message: `Reviewer (${reviewerRole.provider}) running`,
+      detail: { reviewer: reviewerRole.provider }
+    })
+  );
+
+  const diff = await generateDiff({ baseRef: session.session_start_sha });
+  const reviewerOnOutput = ({ stream, line }) => {
+    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "reviewer" }, {
+      message: line,
+      detail: { stream, agent: reviewerRole.provider }
+    }));
+  };
+  const reviewerStart = Date.now();
+  const reviewerExec = await runReviewerWithFallback({
+    reviewerName: reviewerRole.provider,
+    config,
+    logger,
+    emitter,
+    reviewInput: { task, diff, reviewRules, onOutput: reviewerOnOutput },
+    session,
+    iteration,
+    onAttemptResult: ({ reviewer, result }) => {
+      trackBudget({ role: "reviewer", provider: reviewer, model: reviewerRole.model, result, duration_ms: Date.now() - reviewerStart });
+    }
+  });
+
+  if (!reviewerExec.execResult || !reviewerExec.execResult.ok) {
+    await markSessionStatus(session, "failed");
+    const lastAttempt = reviewerExec.attempts.at(-1);
+    const details =
+      lastAttempt?.result?.error ||
+      lastAttempt?.execResult?.summary ||
+      `reviewer=${lastAttempt?.reviewer || "unknown"}`;
+    emitProgress(
+      emitter,
+      makeEvent("reviewer:end", { ...eventBase, stage: "reviewer" }, {
+        status: "fail",
+        message: `Reviewer failed: ${details}`
+      })
+    );
+    throw new Error(`Reviewer failed: ${details}`);
+  }
+
+  const reviewResult = reviewerExec.execResult.result;
+  let review;
+  try {
+    review = validateReviewResult({
+      approved: reviewResult.approved,
+      blocking_issues: reviewResult.blocking_issues || [],
+      non_blocking_suggestions: reviewResult.non_blocking_suggestions || [],
+      summary: reviewResult.raw_summary || "",
+      confidence: reviewResult.confidence ?? 0
+    });
+  } catch (parseErr) {
+    logger.warn(`Reviewer output validation failed: ${parseErr.message}`);
+    review = {
+      approved: false,
+      blocking_issues: [{
+        id: "PARSE_ERROR",
+        severity: "high",
+        description: `Reviewer output could not be parsed: ${parseErr.message}`
+      }],
+      non_blocking_suggestions: [],
+      summary: `Parse error: ${parseErr.message}`,
+      confidence: 0
+    };
+  }
+  await addCheckpoint(session, {
+    stage: "reviewer",
+    iteration,
+    approved: review.approved,
+    blocking_issues: review.blocking_issues.length
+  });
+
+  emitProgress(
+    emitter,
+    makeEvent("reviewer:end", { ...eventBase, stage: "reviewer" }, {
+      status: review.approved ? "ok" : "fail",
+      message: review.approved ? "Review approved" : `Review rejected (${review.blocking_issues.length} blocking)`,
+      detail: {
+        approved: review.approved,
+        blockingCount: review.blocking_issues.length,
+        issues: review.blocking_issues.map(
+          (x) => `${x.id || "ISSUE"}: ${x.description || "Missing description"}`
+        )
+      }
+    })
+  );
+
+  if (!review.approved) {
+    repeatDetector.addIteration([], review.blocking_issues);
+    const repeatState = repeatDetector.isStalled();
+    if (repeatState.stalled) {
+      const repeatCounts = repeatDetector.getRepeatCounts();
+      const message = `Manual intervention required: reviewer issues repeated ${repeatCounts.reviewer} times.`;
+      logger.warn(message);
+      await markSessionStatus(session, "stalled");
+      emitProgress(
+        emitter,
+        makeEvent("session:end", { ...eventBase, stage: "reviewer" }, {
+          status: "stalled",
+          message,
+          detail: { reason: repeatState.reason, repeats: repeatCounts.reviewer, budget: budgetSummary() }
+        })
+      );
+      return { review, stalled: true, stalledResult: { approved: false, sessionId: session.id, reason: "stalled" } };
+    }
+  }
+
+  return { review };
+}