ralphctl 0.2.2 → 0.2.4

package/dist/{chunk-XXIHDQOH.mjs → chunk-U62BX47C.mjs}

@@ -11,7 +11,7 @@ import {
   getPendingRequirements,
   groupTicketsByProject,
   listTickets
-} from "./chunk-XPDI4SYI.mjs";
+} from "./chunk-742XQ7FL.mjs";
 import {
   EXIT_ALL_BLOCKED,
   EXIT_ERROR,
@@ -23,7 +23,7 @@ import {
 import {
   getProject,
   listProjects
-} from "./chunk-LG6B7QVO.mjs";
+} from "./chunk-EUNAUHC3.mjs";
 import {
   activateSprint,
   assertSprintStatus,
@@ -40,7 +40,7 @@ import {
   setAiProvider,
   summarizeProgressForContext,
   withFileLock
-} from "./chunk-KPTPKLXY.mjs";
+} from "./chunk-JRFOUFD3.mjs";
 import {
   ensureError,
   unwrapOrThrow,
@@ -50,9 +50,11 @@ import {
   ImportTasksSchema,
   RefinedRequirementsSchema,
   TasksSchema,
+  appendToFile,
   assertSafeCwd,
   ensureDir,
   fileExists,
+  getEvaluationFilePath,
   getPlanningDir,
   getProgressFilePath,
   getRefinementDir,
@@ -61,7 +63,7 @@ import {
   getTasksFilePath,
   readValidatedJson,
   writeValidatedJson
-} from "./chunk-ZDEVRTGY.mjs";
+} from "./chunk-IB6OCKZW.mjs";
 import {
   DependencyCycleError,
   IOError,
@@ -162,10 +164,18 @@ function buildEvaluatorPrompt(ctx) {
   const stepsSection = ctx.taskSteps.length > 0 ? `
 **Implementation Steps:**
 ${ctx.taskSteps.map((s) => `- ${s}`).join("\n")}` : "";
+  const criteriaSection = ctx.verificationCriteria.length > 0 ? `
+**Verification Criteria:**
+${ctx.verificationCriteria.map((c) => `- ${c}`).join("\n")}` : "";
   const checkSection = ctx.checkScriptSection ? `
 
 ${ctx.checkScriptSection}` : "";
-  return template.replaceAll("{{TASK_NAME}}", ctx.taskName).replace("{{TASK_DESCRIPTION_SECTION}}", descriptionSection).replace("{{TASK_STEPS_SECTION}}", stepsSection).replace("{{PROJECT_PATH}}", ctx.projectPath).replace("{{CHECK_SCRIPT_SECTION}}", checkSection);
+  return template.replaceAll("{{TASK_NAME}}", ctx.taskName).replace("{{TASK_DESCRIPTION_SECTION}}", descriptionSection).replace("{{TASK_STEPS_SECTION}}", stepsSection).replace("{{VERIFICATION_CRITERIA_SECTION}}", criteriaSection).replace("{{PROJECT_PATH}}", ctx.projectPath).replace("{{CHECK_SCRIPT_SECTION}}", checkSection).replace("{{PROJECT_TOOLING_SECTION}}", ctx.projectToolingSection);
+}
+function buildEvaluationResumePrompt(ctx) {
+  const template = loadTemplate("task-evaluation-resume");
+  const commitInstruction = ctx.needsCommit ? "\n   - **Then commit the fix** with a descriptive message before signaling completion." : "";
+  return template.replace("{{CRITIQUE}}", ctx.critique).replace("{{COMMIT_INSTRUCTION}}", commitInstruction);
 }
 
 // src/utils/requirements-export.ts
@@ -1087,6 +1097,7 @@ async function addTask(input3, sprintId) {
       name: input3.name,
       description: input3.description,
       steps: input3.steps ?? [],
+      verificationCriteria: input3.verificationCriteria ?? [],
       status: "todo",
       order: maxOrder + 1,
       ticketId: input3.ticketId,
@@ -1159,6 +1170,12 @@ async function updateTask(taskId, updates, sprintId) {
     if (updates.evaluationOutput !== void 0) {
       task.evaluationOutput = updates.evaluationOutput;
     }
+    if (updates.evaluationStatus !== void 0) {
+      task.evaluationStatus = updates.evaluationStatus;
+    }
+    if (updates.evaluationFile !== void 0) {
+      task.evaluationFile = updates.evaluationFile;
+    }
     await saveTasks(tasks, id);
     return task;
   });
@@ -1320,6 +1337,7 @@ function validateImportTasks(importTasks2, existingTasks, ticketIds) {
       name: t.name,
       description: void 0,
       steps: [],
+      verificationCriteria: [],
       status: "todo",
       order: existingTasks.length + i + 1,
       ticketId: void 0,
@@ -1355,7 +1373,7 @@ async function selectProject(message = "Select project:") {
       default: true
     });
     if (create) {
-      const { projectAddCommand } = await import("./add-TGJTRHIF.mjs");
+      const { projectAddCommand } = await import("./add-3T225IX5.mjs");
       await projectAddCommand({ interactive: true });
       const updated = await listProjects();
       if (updated.length === 0) return null;
@@ -1428,7 +1446,7 @@ async function selectSprint(message = "Select sprint:", filter) {
       default: true
     });
     if (create) {
-      const { sprintCreateCommand } = await import("./create-DJHCP7LN.mjs");
+      const { sprintCreateCommand } = await import("./create-MYGOWO2F.mjs");
       await sprintCreateCommand({ interactive: true });
       const updated = await listSprints();
       const refiltered = filter ? updated.filter((s) => filter.includes(s.status)) : updated;
@@ -1463,7 +1481,7 @@ async function selectTicket(message = "Select ticket:", filter) {
         default: true
       });
       if (create) {
-        const { ticketAddCommand } = await import("./add-SEDQ3VK7.mjs");
+        const { ticketAddCommand } = await import("./add-6A5432U2.mjs");
         await ticketAddCommand({ interactive: true });
         const updated = await listTickets();
         const refiltered = filter ? updated.filter(filter) : updated;
@@ -1658,6 +1676,7 @@ async function importTasksReplace(tasks, sprintId) {
       name: taskInput.name,
       description: taskInput.description,
       steps: taskInput.steps ?? [],
+      verificationCriteria: taskInput.verificationCriteria ?? [],
       status: "todo",
       order: newTasks.length + 1,
       ticketId: taskInput.ticketId,
@@ -2053,15 +2072,165 @@ async function sprintPlanCommand(args) {
 }
 
 // src/commands/sprint/start.ts
-import { Result as Result9 } from "typescript-result";
+import { Result as Result10 } from "typescript-result";
 
 // src/ai/runner.ts
 import { confirm as confirm5, input as input2, select as select2 } from "@inquirer/prompts";
-import { Result as Result8 } from "typescript-result";
+import { Result as Result9 } from "typescript-result";
 
 // src/ai/executor.ts
 import { confirm as confirm4 } from "@inquirer/prompts";
 import { readFile as readFile4, unlink as unlink2 } from "fs/promises";
+import { Result as Result8 } from "typescript-result";
+
+// src/utils/git.ts
+import { spawnSync as spawnSync2 } from "child_process";
+var BRANCH_NAME_RE = /^[a-zA-Z0-9/_.-]+$/;
+var BRANCH_NAME_INVALID_PATTERNS = [/\.\./, /\.$/, /\/$/, /\.lock$/, /^-/, /\/\//];
+function isValidBranchName(name) {
+  if (!name || name.length > 250) return false;
+  if (!BRANCH_NAME_RE.test(name)) return false;
+  for (const pattern of BRANCH_NAME_INVALID_PATTERNS) {
+    if (pattern.test(name)) return false;
+  }
+  return true;
+}
+function getCurrentBranch(cwd) {
+  assertSafeCwd(cwd);
+  const result = spawnSync2("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (result.status !== 0) {
+    throw new Error(`Failed to get current branch in ${cwd}: ${result.stderr.trim()}`);
+  }
+  return result.stdout.trim();
+}
+function branchExists(cwd, name) {
+  assertSafeCwd(cwd);
+  if (!isValidBranchName(name)) {
+    throw new Error(`Invalid branch name: ${name}`);
+  }
+  const result = spawnSync2("git", ["show-ref", "--verify", `refs/heads/${name}`], {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return result.status === 0;
+}
+function createAndCheckoutBranch(cwd, name) {
+  assertSafeCwd(cwd);
+  if (!isValidBranchName(name)) {
+    throw new Error(`Invalid branch name: ${name}`);
+  }
+  const current = getCurrentBranch(cwd);
+  if (current === name) {
+    return;
+  }
+  if (branchExists(cwd, name)) {
+    const result = spawnSync2("git", ["checkout", name], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (result.status !== 0) {
+      throw new Error(`Failed to checkout branch '${name}' in ${cwd}: ${result.stderr.trim()}`);
+    }
+  } else {
+    const result = spawnSync2("git", ["checkout", "-b", name], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (result.status !== 0) {
+      throw new Error(`Failed to create branch '${name}' in ${cwd}: ${result.stderr.trim()}`);
+    }
+  }
+}
+function verifyCurrentBranch(cwd, expected) {
+  const current = getCurrentBranch(cwd);
+  return current === expected;
+}
+function getDefaultBranch(cwd) {
+  assertSafeCwd(cwd);
+  const result = spawnSync2("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (result.status === 0) {
+    const ref = result.stdout.trim();
+    const parts = ref.split("/");
+    return parts[parts.length - 1] ?? "main";
+  }
+  const stderr = result.stderr.trim();
+  if (stderr.includes("is not a symbolic ref") || stderr.includes("No such ref")) {
+    if (branchExists(cwd, "main")) return "main";
+    if (branchExists(cwd, "master")) return "master";
+    return "main";
+  }
+  throw new Error(`Failed to detect default branch in ${cwd}: ${stderr}`);
+}
+function getHeadSha(cwd) {
+  try {
+    assertSafeCwd(cwd);
+    const result = spawnSync2("git", ["rev-parse", "HEAD"], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (result.status !== 0) return null;
+    return result.stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function hasUncommittedChanges(cwd) {
+  assertSafeCwd(cwd);
+  const result = spawnSync2("git", ["status", "--porcelain"], {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (result.status !== 0) {
+    throw new Error(`Failed to check git status in ${cwd}: ${result.stderr.trim()}`);
+  }
+  return result.stdout.trim().length > 0;
+}
+function generateBranchName(sprintId) {
+  return `ralphctl/${sprintId}`;
+}
+function isGhAvailable() {
+  const result = spawnSync2("gh", ["--version"], {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return result.status === 0;
+}
+function isGlabAvailable() {
+  const result = spawnSync2("glab", ["--version"], {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return result.status === 0;
+}
+
+// src/store/evaluation.ts
+async function writeEvaluation(sprintId, taskId, iteration, status, body) {
+  const filePath = getEvaluationFilePath(sprintId, taskId);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const header = `## ${timestamp} \u2014 Iteration ${String(iteration)} \u2014 ${status.toUpperCase()}
+
+`;
+  const entry = `${header}${body.trimEnd()}
+
+---
+
+`;
+  unwrapOrThrow(await appendToFile(filePath, entry));
+  return filePath;
+}
 
 // src/ai/parser.ts
 function parseExecutionResult(output) {
@@ -2321,6 +2490,16 @@ function formatTask(ctx) {
       lines.push(`${String(i + 1)}. ${step}`);
     });
   }
+  if (ctx.task.verificationCriteria.length > 0) {
+    lines.push("");
+    lines.push("## Verification Criteria");
+    lines.push("");
+    lines.push("The task is done when all of the following are true:");
+    lines.push("");
+    ctx.task.verificationCriteria.forEach((criterion) => {
+      lines.push(`- ${criterion}`);
+    });
+  }
   return lines.join("\n");
 }
 function buildFullTaskContext(ctx, progressSummary, gitHistory, checkScript, checkStatus) {
@@ -2439,7 +2618,7 @@ function runPermissionCheck(ctx, noCommit, provider) {
 }
 
 // src/ai/lifecycle.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 var DEFAULT_HOOK_TIMEOUT_MS = 5 * 60 * 1e3;
 function getHookTimeoutMs() {
   const envVal = process.env["RALPHCTL_SETUP_TIMEOUT_MS"];
@@ -2452,7 +2631,7 @@ function getHookTimeoutMs() {
 function runLifecycleHook(projectPath, script, event, timeoutOverrideMs) {
   assertSafeCwd(projectPath);
   const timeoutMs = timeoutOverrideMs ?? getHookTimeoutMs();
-  const result = spawnSync2(script, {
+  const result = spawnSync3(script, {
     cwd: projectPath,
     shell: true,
     stdio: ["pipe", "pipe", "pipe"],
@@ -2464,7 +2643,142 @@ function runLifecycleHook(projectPath, script, event, timeoutOverrideMs) {
   return { passed: result.status === 0, output };
 }
 
+// src/ai/project-tooling.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "fs";
+import { join as join8 } from "path";
+var EMPTY_TOOLING = {
+  agents: [],
+  skills: [],
+  mcpServers: [],
+  hasClaudeMd: false,
+  hasAgentsMd: false,
+  hasCopilotInstructions: false
+};
+function safeListDir(path, predicate) {
+  try {
+    if (!existsSync3(path)) return [];
+    return readdirSync(path).filter(predicate).sort();
+  } catch {
+    return [];
+  }
+}
+var EVALUATOR_DENYLISTED_AGENTS = /* @__PURE__ */ new Set(["implementer", "planner"]);
+function detectAgents(projectPath) {
+  const agentsDir = join8(projectPath, ".claude", "agents");
+  return safeListDir(agentsDir, (name) => name.endsWith(".md")).map((name) => name.replace(/\.md$/, "")).filter((name) => !EVALUATOR_DENYLISTED_AGENTS.has(name));
+}
+function detectSkills(projectPath) {
+  const skillsDir = join8(projectPath, ".claude", "skills");
+  try {
+    if (!existsSync3(skillsDir)) return [];
+    return readdirSync(skillsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  } catch {
+    return [];
+  }
+}
+function detectMcpServers(projectPath) {
+  const mcpFile = join8(projectPath, ".mcp.json");
+  if (!existsSync3(mcpFile)) return [];
+  try {
+    const raw = readFileSync3(mcpFile, "utf-8");
+    const parsed = JSON.parse(raw);
+    const servers = parsed.mcpServers;
+    if (!servers || typeof servers !== "object") return [];
+    return Object.keys(servers).sort();
+  } catch {
+    return [];
+  }
+}
+function detectProjectTooling(projectPath) {
+  if (!projectPath || !existsSync3(projectPath)) {
+    return EMPTY_TOOLING;
+  }
+  return {
+    agents: detectAgents(projectPath),
+    skills: detectSkills(projectPath),
+    mcpServers: detectMcpServers(projectPath),
+    hasClaudeMd: existsSync3(join8(projectPath, "CLAUDE.md")),
+    hasAgentsMd: existsSync3(join8(projectPath, "AGENTS.md")),
+    hasCopilotInstructions: existsSync3(join8(projectPath, ".github", "copilot-instructions.md"))
+  };
+}
+function renderProjectToolingSection(tooling) {
+  const hasAny = tooling.agents.length > 0 || tooling.skills.length > 0 || tooling.mcpServers.length > 0 || tooling.hasClaudeMd || tooling.hasAgentsMd || tooling.hasCopilotInstructions;
+  if (!hasAny) return "";
+  const lines = [];
+  lines.push("## Project Tooling (use these \u2014 they exist for a reason)");
+  lines.push("");
+  lines.push(
+    "This project ships with tooling that you should prefer over generic approaches. Verification and evaluation must adapt to the project\u2019s actual stack and the agents, skills, and MCP servers it has installed."
+  );
+  lines.push("");
+  if (tooling.agents.length > 0) {
+    lines.push("### Subagents available");
+    lines.push("");
+    lines.push("Delegate via the Task tool with `subagent_type=<name>` when the diff matches a specialty:");
+    for (const agent of tooling.agents) {
+      const hint = describeAgentHint(agent);
+      lines.push(`- \`${agent}\`${hint ? ` \u2014 ${hint}` : ""}`);
+    }
+    lines.push("");
+  }
+  if (tooling.skills.length > 0) {
+    lines.push("### Skills available");
+    lines.push("");
+    lines.push("Invoke via the Skill tool when the skill name matches the work in front of you:");
+    for (const skill of tooling.skills) {
+      lines.push(`- \`${skill}\``);
+    }
+    lines.push("");
+  }
+  if (tooling.mcpServers.length > 0) {
+    lines.push("### MCP servers available");
+    lines.push("");
+    lines.push(
+      "These give you tools beyond the filesystem. Use them to **interact with the running system**, not just read its source."
+    );
+    for (const server of tooling.mcpServers) {
+      const hint = describeMcpHint(server);
+      lines.push(`- \`${server}\`${hint ? ` \u2014 ${hint}` : ""}`);
+    }
+    lines.push("");
+  }
+  const instructionFiles = [];
+  if (tooling.hasClaudeMd) instructionFiles.push("`CLAUDE.md`");
+  if (tooling.hasAgentsMd) instructionFiles.push("`AGENTS.md`");
+  if (tooling.hasCopilotInstructions) instructionFiles.push("`.github/copilot-instructions.md`");
+  if (instructionFiles.length > 0) {
+    lines.push("### Project instructions");
+    lines.push("");
+    lines.push(
+      `Read ${instructionFiles.join(" / ")} for project-specific verification commands, conventions, and constraints. If no check script is configured, derive verification commands from these files (e.g. \`package.json\` scripts referenced there).`
+    );
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function describeAgentHint(name) {
+  const hints = {
+    auditor: "use for security-sensitive diffs (auth, input handling, file IO, secrets)",
+    reviewer: "use for general code-quality review of the diff",
+    tester: "use to assess test coverage and quality of new tests",
+    designer: "use for UI/UX/theming changes"
+  };
+  return hints[name] ?? null;
+}
+function describeMcpHint(name) {
+  const lower = name.toLowerCase();
+  if (lower.includes("playwright")) return "use for any UI/frontend task \u2014 click through the changed flow";
+  if (lower.includes("puppeteer")) return "use for browser automation on UI changes";
+  if (lower.includes("github")) return "use to inspect related PRs/issues for context";
+  if (lower.includes("postgres") || lower.includes("mysql") || lower.includes("sqlite")) {
+    return "use to verify database schema/migration changes against a real DB";
+  }
+  return null;
+}
+
 // src/ai/evaluator.ts
+var EVALUATOR_MAX_TURNS = 100;
 function getEvaluatorModel(generatorModel, provider) {
   if (provider.name !== "claude" || !generatorModel) return null;
   const modelLower = generatorModel.toLowerCase();
@@ -2472,54 +2786,92 @@ function getEvaluatorModel(generatorModel, provider) {
   if (modelLower.includes("sonnet")) return "claude-haiku-4-5";
   return "claude-haiku-4-5";
 }
+var DIMENSION_NAMES = ["correctness", "completeness", "safety", "consistency"];
+var DIMENSION_PATTERNS = {
+  correctness: /\*\*correctness\*\*\s*:\s*(PASS|FAIL)\s*(?:—|-)\s*(.+)/i,
+  completeness: /\*\*completeness\*\*\s*:\s*(PASS|FAIL)\s*(?:—|-)\s*(.+)/i,
+  safety: /\*\*safety\*\*\s*:\s*(PASS|FAIL)\s*(?:—|-)\s*(.+)/i,
+  consistency: /\*\*consistency\*\*\s*:\s*(PASS|FAIL)\s*(?:—|-)\s*(.+)/i
+};
+function parseDimensionScores(output) {
+  const scores = [];
+  for (const dim of DIMENSION_NAMES) {
+    const match = DIMENSION_PATTERNS[dim].exec(output);
+    if (match?.[1] && match[2]) {
+      scores.push({
+        dimension: dim,
+        passed: match[1].toUpperCase() === "PASS",
+        finding: match[2].trim()
+      });
+    }
+  }
+  return scores;
+}
 function parseEvaluationResult(output) {
+  const dimensions = parseDimensionScores(output);
   if (output.includes("<evaluation-passed>")) {
-    return { passed: true, output };
+    return { passed: true, status: "passed", output, dimensions };
   }
   const failedMatch = /<evaluation-failed>([\s\S]*?)<\/evaluation-failed>/.exec(output);
   if (failedMatch) {
-    return { passed: false, output: failedMatch[1]?.trim() ?? output };
+    return { passed: false, status: "failed", output: failedMatch[1]?.trim() ?? output, dimensions };
   }
-  return { passed: false, output };
+  if (dimensions.length > 0) {
+    return { passed: false, status: "failed", output, dimensions };
+  }
+  return { passed: false, status: "malformed", output, dimensions };
 }
 function buildEvaluatorContext(task, checkScript) {
-  const checkScriptSection = checkScript ? `## Check Script
+  const checkScriptSection = checkScript ? `## Check Script (Computational Gate)
 
-You can run the following check script to verify the changes:
+Run this check script as the **first step** of your review \u2014 it is the same gate the harness uses post-task:
 
 \`\`\`
 ${checkScript}
 \`\`\`
 
-Run it to gain additional insight into whether the implementation is correct.` : null;
+If this script fails, the implementation fails regardless of code quality. Record the full output.` : null;
+  const tooling = detectProjectTooling(task.projectPath);
+  const projectToolingSection = renderProjectToolingSection(tooling);
   return {
     taskName: task.name,
     taskDescription: task.description ?? "",
     taskSteps: task.steps,
+    verificationCriteria: task.verificationCriteria,
     projectPath: task.projectPath,
-    checkScriptSection
+    checkScriptSection,
+    projectToolingSection
   };
 }
-async function runEvaluation(task, generatorModel, checkScript, sprintId, provider) {
+async function runEvaluation(task, generatorModel, checkScript, sprintId, provider, options) {
   const p = provider ?? await getActiveProvider();
   const evaluatorModel = getEvaluatorModel(generatorModel, p);
   const sprintDir = getSprintDir(sprintId);
   const ctx = buildEvaluatorContext(task, checkScript);
   const prompt = buildEvaluatorPrompt(ctx);
   const providerArgs = ["--add-dir", sprintDir];
-  if (evaluatorModel && p.name === "claude") {
-    providerArgs.push("--model", evaluatorModel);
-  }
-  const result = await spawnWithRetry({
-    cwd: task.projectPath,
-    args: providerArgs,
-    prompt,
-    env: p.getSpawnEnv()
-  });
+  if (p.name === "claude") {
+    if (evaluatorModel) {
+      providerArgs.push("--model", evaluatorModel);
+    }
+    providerArgs.push("--max-turns", String(EVALUATOR_MAX_TURNS));
+  }
+  await options?.coordinator?.waitIfPaused();
+  const result = await spawnWithRetry(
+    {
+      cwd: task.projectPath,
+      args: providerArgs,
+      prompt,
+      env: p.getSpawnEnv()
+    },
+    { maxRetries: options?.maxRetries },
+    p
+  );
   return parseEvaluationResult(result.stdout);
 }
 
 // src/ai/executor.ts
+var DEFAULT_MAX_TURNS = 200;
 function buildProviderArgs(options, provider) {
   if (provider.name !== "claude") {
     if (options.maxBudgetUsd != null) {
@@ -2528,6 +2880,9 @@ function buildProviderArgs(options, provider) {
     if (options.fallbackModel) {
       console.log(warning(`--fallback-model is only supported with the Claude provider \u2014 ignored`));
     }
+    if (options.maxTurns != null) {
+      console.log(warning(`--max-turns is only supported with the Claude provider \u2014 ignored`));
+    }
     return [];
   }
   const args = [];
@@ -2537,6 +2892,7 @@ function buildProviderArgs(options, provider) {
   if (options.fallbackModel) {
     args.push("--fallback-model", options.fallbackModel);
   }
+  args.push("--max-turns", String(options.maxTurns ?? DEFAULT_MAX_TURNS));
   return args;
 }
 async function executeTask(ctx, options, sprintId, resumeSessionId, provider, checkStatus) {
@@ -2657,6 +3013,31 @@ async function executeTask(ctx, options, sprintId, resumeSessionId, provider, ch
   return { ...parsed, sessionId: spawnResult.sessionId, model: spawnResult.model };
 }
 var MAX_EVAL_OUTPUT = 2e3;
+var EVAL_SPAWN_FAILURE_PREFIX = "Evaluator spawn failed:";
+function isEvalSpawnFailure(output) {
+  return output.startsWith(EVAL_SPAWN_FAILURE_PREFIX);
+}
+async function runEvaluationSafely(task, generatorModel, checkScript, sprintId, provider, options, coordinator) {
+  const evalR = await wrapAsync(
+    () => runEvaluation(task, generatorModel, checkScript, sprintId, provider, {
+      coordinator,
+      maxRetries: options.maxRetries
+    }),
+    ensureError
+  );
+  if (evalR.ok) return evalR.value;
+  const err = evalR.error;
+  if (err instanceof SpawnError && err.rateLimited && coordinator) {
+    coordinator.pause(err.retryAfterMs ?? 6e4);
+  }
+  console.log(warning(`Evaluator spawn failed for ${task.name}: ${err.message} \u2014 marking malformed`));
+  return {
+    passed: false,
+    status: "malformed",
+    output: `${EVAL_SPAWN_FAILURE_PREFIX} ${err.message}`,
+    dimensions: []
+  };
+}
 async function runEvaluationLoop(params) {
   const {
     task,
@@ -2667,29 +3048,38 @@ async function runEvaluationLoop(params) {
     options,
     evalIterations,
     checkTimeout,
-    useSpinner = false
+    useSpinner = false,
+    coordinator
   } = params;
   const evalCheckScript = getEffectiveCheckScript(project, task.projectPath);
   const sprintDir = getSprintDir(sprintId);
-  let evalResult = await runEvaluation(task, result.model, evalCheckScript, sprintId, provider);
-  for (let i = 0; i < evalIterations && !evalResult.passed; i++) {
-    console.log(warning(`Evaluation failed for ${task.name} (iteration ${String(i + 1)}/${String(evalIterations)})`));
+  let evalResult = await runEvaluationSafely(
+    task,
+    result.model,
+    evalCheckScript,
+    sprintId,
+    provider,
+    options,
+    coordinator
+  );
+  let evaluationFile = await tryWriteEvaluationEntry(sprintId, task, 1, evalResult);
+  let currentSessionId = result.sessionId;
+  let currentModel = result.model;
+  for (let i = 0; i < evalIterations && !evalResult.passed && evalResult.status !== "malformed"; i++) {
+    console.log(warning(`Evaluation failed for ${task.name} \u2014 fix attempt ${String(i + 1)}/${String(evalIterations)}`));
     console.log(muted(evalResult.output.slice(0, 500)));
+    const headBefore = getHeadSha(task.projectPath);
+    const resumePrompt = buildEvaluationResumePrompt({
+      critique: evalResult.output,
+      needsCommit: !options.noCommit
+    });
     const resumeSpinner = useSpinner ? createSpinner(`Fixing evaluation issues: ${task.name}`).start() : null;
     const resumeResult = await spawnWithRetry(
       {
         cwd: task.projectPath,
         args: ["--add-dir", sprintDir, ...buildProviderArgs(options, provider)],
-        prompt: `The evaluator found issues with your implementation:
-
-${evalResult.output}
-
-Review the critique carefully. Fix each identified issue in the code, then:
-1. Re-run verification commands to confirm the fix
-${options.noCommit ? "" : "2. Commit the fix with a descriptive message\n"}${options.noCommit ? "2" : "3"}. Signal completion with <task-verified> and <task-complete>
-
-If the critique is about something outside your task scope, fix only what is within scope and signal completion.`,
-        resumeSessionId: result.sessionId ?? void 0,
+        prompt: resumePrompt,
+        resumeSessionId: currentSessionId ?? void 0,
         env: provider.getSpawnEnv()
       },
       {
@@ -2703,37 +3093,88 @@ If the critique is about something outside your task scope, fix only what is wit
       provider
     );
     resumeSpinner?.succeed(`Fix attempt completed: ${task.name}`);
+    if (resumeResult.sessionId) currentSessionId = resumeResult.sessionId;
+    if (resumeResult.model) currentModel = resumeResult.model;
     const fixResult = parseExecutionResult(resumeResult.stdout);
     if (!fixResult.success) {
-      console.log(warning(`Generator could not fix issues after feedback: ${task.name}`));
+      const reason = `Generator could not fix issues after feedback (no <task-complete> signal)`;
+      console.log(warning(`${reason}: ${task.name}`));
+      const stubPath = await tryWriteEvaluationStub(sprintId, task, i + 2, reason);
+      if (stubPath) evaluationFile = stubPath;
+      break;
+    }
+    const headAfter = getHeadSha(task.projectPath);
+    const dirtyR = Result8.try(() => hasUncommittedChanges(task.projectPath));
+    const dirty = dirtyR.ok ? dirtyR.value : false;
+    if (headBefore !== null && headAfter === headBefore && !dirty) {
+      const reason = "Generator no-op (HEAD unchanged, no uncommitted changes)";
+      console.log(warning(`${reason}: ${task.name}`));
+      const stubPath = await tryWriteEvaluationStub(sprintId, task, i + 2, reason);
+      if (stubPath) evaluationFile = stubPath;
       break;
     }
     const recheckScript = getEffectiveCheckScript(project, task.projectPath);
     if (recheckScript) {
       const recheckResult = runLifecycleHook(task.projectPath, recheckScript, "taskComplete", checkTimeout);
       if (!recheckResult.passed) {
+        const reason = `Post-task check failed after generator fix: ${recheckResult.output.slice(0, 200)}`;
         console.log(warning(`Post-task check failed after generator fix: ${task.name}`));
+        const stubPath = await tryWriteEvaluationStub(sprintId, task, i + 2, reason);
+        if (stubPath) evaluationFile = stubPath;
         break;
       }
     }
-    evalResult = await runEvaluation(task, resumeResult.model ?? result.model, evalCheckScript, sprintId, provider);
+    evalResult = await runEvaluationSafely(
+      task,
+      currentModel,
+      evalCheckScript,
+      sprintId,
+      provider,
+      options,
+      coordinator
+    );
+    const entryPath = await tryWriteEvaluationEntry(sprintId, task, i + 2, evalResult);
+    if (entryPath) evaluationFile = entryPath;
   }
   await updateTask(
     task.id,
     {
       evaluated: true,
-      evaluationOutput: evalResult.output.slice(0, MAX_EVAL_OUTPUT)
+      evaluationStatus: evalResult.status,
+      evaluationOutput: evalResult.output.slice(0, MAX_EVAL_OUTPUT),
+      ...evaluationFile ? { evaluationFile } : {}
     },
     sprintId
   );
-  if (!evalResult.passed) {
+  if (evalResult.status === "malformed") {
+    const cause = isEvalSpawnFailure(evalResult.output) ? evalResult.output : "no signal, no dimensions";
+    console.log(warning(`Evaluator output was malformed for ${task.name} (${cause}) \u2014 marking done`));
+  } else if (!evalResult.passed) {
     console.log(
-      warning(`Evaluation did not pass after ${String(evalIterations)} iteration(s) \u2014 marking done: ${task.name}`)
+      warning(`Evaluation did not pass after ${String(evalIterations)} fix attempt(s) \u2014 marking done: ${task.name}`)
     );
   } else {
     console.log(success(`Evaluation passed: ${task.name}`));
   }
 }
+async function tryWriteEvaluationEntry(sprintId, task, iteration, evalResult) {
+  let body;
+  if (evalResult.status === "malformed") {
+    body = isEvalSpawnFailure(evalResult.output) ? evalResult.output : "_(evaluator output had no parseable signal \u2014 see executor stdout)_";
+  } else {
+    body = evalResult.output;
+  }
+  return tryWriteEvaluationRaw(sprintId, task, iteration, evalResult.status, body);
+}
+async function tryWriteEvaluationStub(sprintId, task, iteration, reason) {
+  return tryWriteEvaluationRaw(sprintId, task, iteration, "failed", `_(no re-evaluation: ${reason})_`);
+}
+async function tryWriteEvaluationRaw(sprintId, task, iteration, status, body) {
+  const writeR = await wrapAsync(() => writeEvaluation(sprintId, task.id, iteration, status, body), ensureError);
+  if (writeR.ok) return writeR.value;
+  console.log(warning(`Could not persist evaluation sidecar for ${task.name}: ${writeR.error.message}`));
+  return null;
+}
 async function areAllRemainingBlocked(sprintId) {
   const remaining = await getRemainingTasks(sprintId);
   if (remaining.length === 0) return false;
@@ -2878,9 +3319,10 @@ Starting ${label} in ${task.projectPath} (session)...
       console.log(success("Verification: passed"));
     }
     const checkScript = getEffectiveCheckScript(project, task.projectPath);
+    const sequentialRepo = project?.repositories.find((r) => r.path === task.projectPath);
     if (checkScript) {
       console.log(muted(`Running post-task check: ${checkScript}`));
-      const hookResult = runLifecycleHook(task.projectPath, checkScript, "taskComplete");
+      const hookResult = runLifecycleHook(task.projectPath, checkScript, "taskComplete", sequentialRepo?.checkTimeout);
       if (!hookResult.passed) {
         console.log(warning(`
 Post-task check failed for: ${task.name}`));
@@ -2908,6 +3350,7 @@ Post-task check failed for: ${task.name}`));
         provider,
         options,
         evalIterations,
+        checkTimeout: sequentialRepo?.checkTimeout,
         useSpinner: true
       });
     }
@@ -3241,7 +3684,8 @@ Post-task check failed for: ${settled.task.name}`));
             provider,
             options,
             evalIterations,
-            checkTimeout: taskRepo?.checkTimeout
+            checkTimeout: taskRepo?.checkTimeout,
+            coordinator
           });
         }
         await updateTaskStatus(settled.task.id, "done", sprintId);
@@ -3320,125 +3764,6 @@ Waiting for ${String(running.size)} remaining task(s)...`));
   };
 }
 
-// src/utils/git.ts
-import { spawnSync as spawnSync3 } from "child_process";
-var BRANCH_NAME_RE = /^[a-zA-Z0-9/_.-]+$/;
-var BRANCH_NAME_INVALID_PATTERNS = [/\.\./, /\.$/, /\/$/, /\.lock$/, /^-/, /\/\//];
-function isValidBranchName(name) {
-  if (!name || name.length > 250) return false;
-  if (!BRANCH_NAME_RE.test(name)) return false;
-  for (const pattern of BRANCH_NAME_INVALID_PATTERNS) {
-    if (pattern.test(name)) return false;
-  }
-  return true;
-}
-function getCurrentBranch(cwd) {
-  assertSafeCwd(cwd);
-  const result = spawnSync3("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-    cwd,
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  if (result.status !== 0) {
-    throw new Error(`Failed to get current branch in ${cwd}: ${result.stderr.trim()}`);
-  }
-  return result.stdout.trim();
-}
-function branchExists(cwd, name) {
-  assertSafeCwd(cwd);
-  if (!isValidBranchName(name)) {
-    throw new Error(`Invalid branch name: ${name}`);
-  }
-  const result = spawnSync3("git", ["show-ref", "--verify", `refs/heads/${name}`], {
-    cwd,
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  return result.status === 0;
-}
-function createAndCheckoutBranch(cwd, name) {
-  assertSafeCwd(cwd);
-  if (!isValidBranchName(name)) {
-    throw new Error(`Invalid branch name: ${name}`);
-  }
-  const current = getCurrentBranch(cwd);
-  if (current === name) {
-    return;
-  }
-  if (branchExists(cwd, name)) {
-    const result = spawnSync3("git", ["checkout", name], {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    if (result.status !== 0) {
-      throw new Error(`Failed to checkout branch '${name}' in ${cwd}: ${result.stderr.trim()}`);
-    }
-  } else {
-    const result = spawnSync3("git", ["checkout", "-b", name], {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    if (result.status !== 0) {
-      throw new Error(`Failed to create branch '${name}' in ${cwd}: ${result.stderr.trim()}`);
-    }
-  }
-}
-function verifyCurrentBranch(cwd, expected) {
-  const current = getCurrentBranch(cwd);
-  return current === expected;
-}
-function getDefaultBranch(cwd) {
-  assertSafeCwd(cwd);
-  const result = spawnSync3("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
-    cwd,
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  if (result.status === 0) {
-    const ref = result.stdout.trim();
-    const parts = ref.split("/");
-    return parts[parts.length - 1] ?? "main";
-  }
-  const stderr = result.stderr.trim();
-  if (stderr.includes("is not a symbolic ref") || stderr.includes("No such ref")) {
-    if (branchExists(cwd, "main")) return "main";
-    if (branchExists(cwd, "master")) return "master";
-    return "main";
-  }
-  throw new Error(`Failed to detect default branch in ${cwd}: ${stderr}`);
-}
-function hasUncommittedChanges(cwd) {
-  assertSafeCwd(cwd);
-  const result = spawnSync3("git", ["status", "--porcelain"], {
-    cwd,
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  if (result.status !== 0) {
-    throw new Error(`Failed to check git status in ${cwd}: ${result.stderr.trim()}`);
-  }
-  return result.stdout.trim().length > 0;
-}
-function generateBranchName(sprintId) {
-  return `ralphctl/${sprintId}`;
-}
-function isGhAvailable() {
-  const result = spawnSync3("gh", ["--version"], {
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  return result.status === 0;
-}
-function isGlabAvailable() {
-  const result = spawnSync3("glab", ["--version"], {
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  return result.status === 0;
-}
-
 // src/ai/runner.ts
 async function promptBranchStrategy(sprintId) {
   const autoBranch = generateBranchName(sprintId);
@@ -3488,7 +3813,7 @@ async function ensureSprintBranches(sprintId, sprint, branchName) {
   const uniquePaths = [...new Set(remainingTasks.map((t) => t.projectPath))];
   if (uniquePaths.length === 0) return;
   for (const projectPath of uniquePaths) {
-    const uncommittedR = Result8.try(() => hasUncommittedChanges(projectPath));
+    const uncommittedR = Result9.try(() => hasUncommittedChanges(projectPath));
     if (!uncommittedR.ok) {
       log.dim(`  Skipping ${projectPath} \u2014 not a git repository`);
       continue;
@@ -3500,7 +3825,7 @@ async function ensureSprintBranches(sprintId, sprint, branchName) {
     }
   }
   for (const projectPath of uniquePaths) {
-    const branchR = Result8.try(() => {
+    const branchR = Result9.try(() => {
       const currentBranch = getCurrentBranch(projectPath);
       if (currentBranch === branchName) {
         log.dim(`  Already on branch '${branchName}' in ${projectPath}`);
@@ -3521,7 +3846,7 @@ async function ensureSprintBranches(sprintId, sprint, branchName) {
   }
 }
 function verifySprintBranch(projectPath, expectedBranch) {
-  const r = Result8.try(() => {
+  const r = Result9.try(() => {
     if (verifyCurrentBranch(projectPath, expectedBranch)) return true;
     log.dim(`  Branch mismatch in ${projectPath} \u2014 checking out '${expectedBranch}'`);
     createAndCheckoutBranch(projectPath, expectedBranch);
@@ -3801,6 +4126,16 @@ function parseArgs3(args) {
         throw new Error("Invalid model name \u2014 must be 1-100 alphanumeric characters, dots, hyphens, or underscores");
       }
       options.fallbackModel = modelStr;
+    } else if (arg === "--max-turns") {
+      const turnsStr = args[++i];
+      if (!turnsStr) {
+        throw new Error("--max-turns requires a number");
+      }
+      const turns = parseInt(turnsStr, 10);
+      if (isNaN(turns) || turns <= 0) {
+        throw new Error("--max-turns must be a positive integer");
+      }
+      options.maxTurns = turns;
     } else if (arg === "--no-evaluate") {
       options.noEvaluate = true;
     } else if (!arg?.startsWith("-")) {
@@ -3810,7 +4145,7 @@ function parseArgs3(args) {
   return { sprintId, options };
 }
 async function sprintStartCommand(args) {
-  const parseR = Result9.try(() => parseArgs3(args));
+  const parseR = Result10.try(() => parseArgs3(args));
   if (!parseR.ok) {
     showError(parseR.error.message);
     log.newline();