karajan-code 1.49.0 → 1.50.1

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/stages/architect-stage.js

@@ -0,0 +1,176 @@
+/**
+ * Architect stage logic.
+ * Extracted from pre-loop-stages.js for maintainability.
+ */
+
+import { ArchitectRole } from "../../roles/architect-role.js";
+import { createAgent } from "../../agents/index.js";
+import { createArchitectADRs } from "../../planning-game/architect-adrs.js";
+import { addCheckpoint } from "../../session-store.js";
+import { emitProgress, makeEvent } from "../../utils/events.js";
+import { createStallDetector } from "../../utils/stall-detector.js";
+
+async function handleArchitectClarification({ architectOutput, askQuestion, config, logger, emitter, eventBase, session, architectOnOutput, architectProvider, coderRole, researchContext, discoverResult, triageLevel, trackBudget }) {
+  if (!architectOutput.ok
+    || architectOutput.result?.verdict !== "needs_clarification"
+    || !architectOutput.result?.questions?.length) {
+    return architectOutput;
+  }
+
+  const questions = architectOutput.result.questions;
+  if (!askQuestion) {
+    logger.warn("Architect returned needs_clarification but no interactive input available — continuing with best-effort decisions");
+    return architectOutput;
+  }
+
+  const formatted = "The architect needs clarification before proceeding:\n\n"
+    + questions.map((q, i) => `${i + 1}. ${q}`).join("\n")
+    + "\n\nPlease provide your answers:";
+
+  emitProgress(
+    emitter,
+    makeEvent("architect:clarification", { ...eventBase, stage: "architect" }, {
+      message: "Architect needs clarification — pausing for human input",
+      detail: { questions }
+    })
+  );
+
+  const answer = await askQuestion(formatted, { iteration: 0, stage: "architect" });
+  if (!answer) return architectOutput;
+
+  const architect2 = new ArchitectRole({ config, logger, emitter, createAgentFn: createAgent });
+  await architect2.init({ task: session.task, sessionId: session.id, iteration: 0 });
+  const rerunStart = Date.now();
+  const rerunStall = createStallDetector({
+    onOutput: architectOnOutput, emitter, eventBase, stage: "architect", provider: architectProvider
+  });
+  let result;
+  try {
+    result = await architect2.execute({
+      task: session.task,
+      onOutput: rerunStall.onOutput,
+      researchContext,
+      discoverResult,
+      triageLevel,
+      humanAnswers: answer
+    });
+  } finally {
+    rerunStall.stop();
+  }
+  trackBudget({
+    role: "architect",
+    provider: architectProvider,
+    model: config?.roles?.architect?.model || coderRole.model,
+    result,
+    duration_ms: Date.now() - rerunStart
+  });
+  return result;
+}
+
+export async function runArchitectStage({ config, logger, emitter, eventBase, session, coderRole, trackBudget, researchContext = null, discoverResult = null, triageLevel = null, askQuestion = null }) {
+  logger.setContext({ iteration: 0, stage: "architect" });
+  const architectProvider = config?.roles?.architect?.provider || coderRole.provider;
+  emitProgress(
+    emitter,
+    makeEvent("architect:start", { ...eventBase, stage: "architect" }, {
+      message: "Architect designing solution architecture",
+      detail: { architect: architectProvider, provider: architectProvider, executorType: "agent" }
+    })
+  );
+  const architectOnOutput = ({ stream, line }) => {
+    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "architect" }, {
+      message: line,
+      detail: { stream, agent: architectProvider }
+    }));
+  };
+  const architectStall = createStallDetector({
+    onOutput: architectOnOutput, emitter, eventBase, stage: "architect", provider: architectProvider
+  });
+
+  const architect = new ArchitectRole({ config, logger, emitter, createAgentFn: createAgent });
+  await architect.init({ task: session.task, sessionId: session.id, iteration: 0 });
+  const architectStart = Date.now();
+  let architectOutput;
+  try {
+    architectOutput = await architect.execute({
+      task: session.task,
+      onOutput: architectStall.onOutput,
+      researchContext,
+      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();
+  }
+  trackBudget({
+    role: "architect",
+    provider: architectProvider,
+    model: config?.roles?.architect?.model || coderRole.model,
+    result: architectOutput,
+    duration_ms: Date.now() - architectStart
+  });
+
+  await addCheckpoint(session, {
+    stage: "architect",
+    iteration: 0,
+    ok: architectOutput.ok,
+    provider: architectProvider,
+    model: config?.roles?.architect?.model || coderRole.model || null
+  });
+
+  // --- Interactive clarification loop ---
+  architectOutput = await handleArchitectClarification({
+    architectOutput, askQuestion, config, logger, emitter, eventBase, session,
+    architectOnOutput, architectProvider, coderRole, researchContext, discoverResult, triageLevel, trackBudget
+  });
+
+  const stageResult = {
+    ok: architectOutput.ok,
+    verdict: architectOutput.result?.verdict || null,
+    architecture: architectOutput.result?.architecture || null,
+    questions: architectOutput.result?.questions || []
+  };
+
+  emitProgress(
+    emitter,
+    makeEvent("architect:end", { ...eventBase, stage: "architect" }, {
+      status: architectOutput.ok ? "ok" : "fail",
+      message: architectOutput.ok ? "Architecture completed" : `Architecture failed: ${architectOutput.summary}`,
+      detail: { ...stageResult, provider: architectProvider, executorType: "agent" }
+    })
+  );
+
+  const architectContext = architectOutput.ok ? architectOutput.result : null;
+
+  // TODO: Move ADR creation to planning-game/pipeline-adapter.js (PG coupling still here because
+  // stageResult.adrs is consumed synchronously within runArchitectStage's return value).
+  // Generate ADRs from architect tradeoffs when PG is linked
+  const tradeoffs = architectOutput.result?.architecture?.tradeoffs;
+  if (architectOutput.ok
+    && architectOutput.result?.verdict === "ready"
+    && tradeoffs?.length > 0
+    && session.pg_task_id
+    && session.pg_project_id) {
+    try {
+      const pgClient = await import("../../planning-game/client.js");
+      const adrResult = await createArchitectADRs({
+        tradeoffs,
+        pgTaskId: session.pg_task_id,
+        pgProject: session.pg_project_id,
+        taskTitle: session.task,
+        mcpClient: pgClient
+      });
+      stageResult.adrs = adrResult;
+      if (adrResult.created > 0) {
+        logger.info(`Architect: created ${adrResult.created} ADR(s) in Planning Game`);
+      }
+    } catch (err) {
+      logger.warn(`Architect: failed to create ADRs: ${err.message}`);
+    }
+  }
+
+  return { architectContext, stageResult };
+}

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

@@ -0,0 +1,307 @@
+/**
+ * Coder stage logic.
+ * Extracted from iteration-stages.js for maintainability.
+ */
+
+import { createAgent } from "../../agents/index.js";
+import { CoderRole } from "../../roles/coder-role.js";
+import { RefactorerRole } from "../../roles/refactorer-role.js";
+import { addCheckpoint, markSessionStatus, saveSession } from "../../session-store.js";
+import { generateDiff, getUntrackedFiles } from "../../review/diff-generator.js";
+import { evaluateTddPolicy } from "../../review/tdd-policy.js";
+import { buildDeferredContext } from "../../review/scope-filter.js";
+import { emitProgress, makeEvent } from "../../utils/events.js";
+import { runCoderWithFallback } from "../agent-fallback.js";
+import { invokeSolomon } from "../solomon-escalation.js";
+import { detectRateLimit } from "../../utils/rate-limit-detector.js";
+import { createStallDetector } from "../../utils/stall-detector.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, provider: coderRole.provider, executorType: "agent" }
+    })
+  );
+
+  const coderOnOutput = ({ stream, line }) => {
+    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "coder" }, {
+      message: line,
+      detail: { stream, agent: coderRole.provider }
+    }));
+  };
+  const coderStall = createStallDetector({
+    onOutput: coderOnOutput, emitter, eventBase, stage: "coder", provider: coderRole.provider
+  });
+  const coderStart = Date.now();
+  let coderExecResult;
+  try {
+    coderExecResult = await coderRoleInstance.execute({
+      task: plannedTask,
+      reviewerFeedback: session.last_reviewer_feedback,
+      sonarSummary: session.last_sonar_summary,
+      deferredContext: buildDeferredContext(session.deferred_issues),
+      onOutput: coderStall.onOutput
+    });
+  } finally {
+    coderStall.stop();
+  }
+  trackBudget({ role: "coder", provider: coderRole.provider, model: coderRole.model, result: coderExecResult.result, duration_ms: Date.now() - coderStart });
+
+  if (!coderExecResult.ok) {
+    const details = coderExecResult.result?.error || coderExecResult.summary || "unknown error";
+    const rateLimitCheck = detectRateLimit({
+      stderr: coderExecResult.result?.error || "",
+      stdout: coderExecResult.result?.output || ""
+    });
+
+    if (rateLimitCheck.isRateLimit) {
+      // Try fallback agent if configured
+      const fallbackCoder = config.coder_options?.fallback_coder;
+      if (fallbackCoder && fallbackCoder !== coderRole.provider) {
+        logger.warn(`Coder ${coderRole.provider} hit rate limit, falling back to ${fallbackCoder}`);
+        emitProgress(
+          emitter,
+          makeEvent("coder:fallback", { ...eventBase, stage: "coder" }, {
+            message: `Coder ${coderRole.provider} rate-limited, switching to ${fallbackCoder}`,
+            detail: { primary: coderRole.provider, fallback: fallbackCoder }
+          })
+        );
+
+        const fallbackResult = await runCoderWithFallback({
+          coderName: fallbackCoder,
+          fallbackCoder: null,
+          config,
+          logger,
+          emitter,
+          RoleClass: CoderRole,
+          roleInput: { task: plannedTask, reviewerFeedback: session.last_reviewer_feedback, sonarSummary: session.last_sonar_summary, onOutput: coderOnOutput },
+          session,
+          iteration,
+          onAttemptResult: ({ coder, result }) => {
+            trackBudget({ role: "coder", provider: coder, model: coderRole.model, result, duration_ms: Date.now() - coderStart });
+          }
+        });
+
+        if (fallbackResult.execResult?.ok) {
+          await addCheckpoint(session, { stage: "coder", iteration, note: `Coder completed via fallback (${fallbackCoder})`, provider: fallbackCoder, model: null });
+          emitProgress(
+            emitter,
+            makeEvent("coder:end", { ...eventBase, stage: "coder" }, {
+              message: `Coder completed (fallback: ${fallbackCoder})`,
+              detail: { provider: fallbackCoder, executorType: "agent" }
+            })
+          );
+          return;
+        }
+      }
+
+      // No fallback or fallback also failed — enter standby
+      return {
+        action: "standby",
+        standbyInfo: {
+          agent: coderRole.provider,
+          cooldownMs: rateLimitCheck.cooldownMs || (rateLimitCheck.isProviderOutage ? 30000 : null),
+          cooldownUntil: rateLimitCheck.cooldownUntil,
+          message: rateLimitCheck.message,
+          isProviderOutage: rateLimitCheck.isProviderOutage || false
+        }
+      };
+    }
+
+    await markSessionStatus(session, "failed");
+    emitProgress(
+      emitter,
+      makeEvent("coder:end", { ...eventBase, stage: "coder" }, {
+        status: "fail",
+        message: `Coder failed: ${details}`,
+        detail: { provider: coderRole.provider, executorType: "agent" }
+      })
+    );
+    throw new Error(`Coder failed: ${details}`);
+  }
+
+  await addCheckpoint(session, { stage: "coder", iteration, note: "Coder applied changes", provider: coderRole.provider, model: coderRole.model || null });
+  emitProgress(
+    emitter,
+    makeEvent("coder:end", { ...eventBase, stage: "coder" }, {
+      message: "Coder completed",
+      detail: { provider: coderRole.provider, executorType: "agent" }
+    })
+  );
+}
+
+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, provider: refactorerRole.provider, executorType: "agent" }
+    })
+  );
+  const refactorerOnOutput = ({ stream, line }) => {
+    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "refactorer" }, {
+      message: line,
+      detail: { stream, agent: refactorerRole.provider }
+    }));
+  };
+  const refactorerStall = createStallDetector({
+    onOutput: refactorerOnOutput, emitter, eventBase, stage: "refactorer", provider: refactorerRole.provider
+  });
+
+  const refRole = new RefactorerRole({ config, logger, emitter, createAgentFn: createAgent });
+  await refRole.init();
+  const refactorerStart = Date.now();
+  let refResult;
+  try {
+    refResult = await refRole.execute({ task: plannedTask, onOutput: refactorerStall.onOutput });
+  } finally {
+    refactorerStall.stop();
+  }
+  trackBudget({ role: "refactorer", provider: refactorerRole.provider, model: refactorerRole.model, result: refResult.result, duration_ms: Date.now() - refactorerStart });
+  if (!refResult.ok) {
+    const details = refResult.result?.error || refResult.summary || "unknown error";
+    const rateLimitCheck = detectRateLimit({
+      stderr: refResult.result?.error || "",
+      stdout: refResult.result?.output || ""
+    });
+
+    if (rateLimitCheck.isRateLimit) {
+      // Enter standby instead of pausing
+      return {
+        action: "standby",
+        standbyInfo: {
+          agent: refactorerRole.provider,
+          cooldownMs: rateLimitCheck.cooldownMs || (rateLimitCheck.isProviderOutage ? 30000 : null),
+          cooldownUntil: rateLimitCheck.cooldownUntil,
+          message: rateLimitCheck.message,
+          isProviderOutage: rateLimitCheck.isProviderOutage || false
+        }
+      };
+    }
+
+    await markSessionStatus(session, "failed");
+    emitProgress(
+      emitter,
+      makeEvent("refactorer:end", { ...eventBase, stage: "refactorer" }, {
+        status: "fail",
+        message: `Refactorer failed: ${details}`,
+        detail: { provider: refactorerRole.provider, executorType: "agent" }
+      })
+    );
+    throw new Error(`Refactorer failed: ${details}`);
+  }
+  await addCheckpoint(session, { stage: "refactorer", iteration, note: "Refactorer applied cleanups", provider: refactorerRole.provider, model: refactorerRole.model || null });
+  emitProgress(
+    emitter,
+    makeEvent("refactorer:end", { ...eventBase, stage: "refactorer" }, {
+      message: "Refactorer completed",
+      detail: { provider: refactorerRole.provider, executorType: "agent" }
+    })
+  );
+}
+
+function handleSolomonAction(solomonResult, session, contextPrefix) {
+  if (solomonResult.action === "pause") {
+    return { action: "pause", result: { paused: true, sessionId: session.id, question: solomonResult.question, context: `${contextPrefix}_fail_fast` } };
+  }
+  if (solomonResult.action === "subtask") {
+    return { action: "pause", result: { paused: true, sessionId: session.id, subtask: solomonResult.subtask, context: `${contextPrefix}_subtask` } };
+  }
+  return null;
+}
+
+async function handleSolomonContinue(solomonResult, session, counterField) {
+  if (solomonResult.action !== "continue") return false;
+  if (solomonResult.humanGuidance) {
+    session.last_reviewer_feedback += `\nUser guidance: ${solomonResult.humanGuidance}`;
+  }
+  session[counterField] = 0;
+  await saveSession(session);
+  return true;
+}
+
+async function handleTddFailure({ tddEval, config, logger, emitter, eventBase, session, iteration, askQuestion }) {
+  session.last_reviewer_feedback = tddEval.message;
+  session.repeated_issue_count += 1;
+  await saveSession(session);
+
+  if (session.repeated_issue_count < config.session.fail_fast_repeats) {
+    return { action: "continue" };
+  }
+
+  emitProgress(
+    emitter,
+    makeEvent("solomon:escalate", { ...eventBase, stage: "tdd" }, {
+      message: `TDD sub-loop limit reached (${session.repeated_issue_count}/${config.session.fail_fast_repeats})`,
+      detail: { subloop: "tdd", retryCount: session.repeated_issue_count, reason: tddEval.reason }
+    })
+  );
+
+  const solomonResult = await invokeSolomon({
+    config, logger, emitter, eventBase, stage: "tdd", askQuestion, session, iteration,
+    conflict: {
+      stage: "tdd",
+      task: session.task,
+      iterationCount: session.repeated_issue_count,
+      maxIterations: config.session.fail_fast_repeats,
+      reason: tddEval.reason,
+      sourceFiles: tddEval.sourceFiles,
+      testFiles: tddEval.testFiles,
+      history: [{ agent: "tdd-policy", feedback: tddEval.message }]
+    }
+  });
+
+  const actionResult = handleSolomonAction(solomonResult, session, "tdd");
+  if (actionResult) return actionResult;
+  const continued = await handleSolomonContinue(solomonResult, session, "repeated_issue_count");
+  if (continued) return { action: "continue" };
+
+  return { action: "continue" };
+}
+
+export async function runTddCheckStage({ config, logger, emitter, eventBase, session, trackBudget, iteration, askQuestion }) {
+  logger.setContext({ iteration, stage: "tdd" });
+  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 effectiveTaskType = session.resolved_policies?.taskType || null;
+  const tddEval = evaluateTddPolicy(tddDiff, config.development, untrackedFiles, effectiveTaskType);
+  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,
+        executorType: "local"
+      }
+    })
+  );
+
+  if (!tddEval.ok) {
+    return handleTddFailure({ tddEval, config, logger, emitter, eventBase, session, iteration, askQuestion });
+  }
+
+  return { action: "ok" };
+}