ralphctl 0.2.3 → 0.2.4

package/dist/{add-K7LNOYQ4.mjs → add-3T225IX5.mjs}

@@ -2,12 +2,12 @@
 import {
   addCheckScriptToRepository,
   projectAddCommand
-} from "./chunk-LAERLCL5.mjs";
+} from "./chunk-UBPZHHCD.mjs";
 import "./chunk-7LZ6GOGN.mjs";
 import "./chunk-7TG3EAQ2.mjs";
-import "./chunk-7TBO6GOT.mjs";
+import "./chunk-EUNAUHC3.mjs";
 import "./chunk-OEUJDSHY.mjs";
-import "./chunk-GLDPHKEW.mjs";
+import "./chunk-IB6OCKZW.mjs";
 import "./chunk-EDJX7TT6.mjs";
 import "./chunk-QBXHAXHI.mjs";
 export {

package/dist/{add-DWNLZQ7Q.mjs → add-6A5432U2.mjs}

@@ -2,12 +2,12 @@
 import {
   addSingleTicketInteractive,
   ticketAddCommand
-} from "./chunk-QYF7QIZJ.mjs";
+} from "./chunk-742XQ7FL.mjs";
 import "./chunk-7TG3EAQ2.mjs";
-import "./chunk-7TBO6GOT.mjs";
-import "./chunk-ITRZMBLJ.mjs";
+import "./chunk-EUNAUHC3.mjs";
+import "./chunk-JRFOUFD3.mjs";
 import "./chunk-OEUJDSHY.mjs";
-import "./chunk-GLDPHKEW.mjs";
+import "./chunk-IB6OCKZW.mjs";
 import "./chunk-EDJX7TT6.mjs";
 import "./chunk-QBXHAXHI.mjs";
 export {

package/dist/{chunk-QYF7QIZJ.mjs → chunk-742XQ7FL.mjs}

@@ -6,14 +6,14 @@ import {
 import {
   listProjects,
   projectExists
-} from "./chunk-7TBO6GOT.mjs";
+} from "./chunk-EUNAUHC3.mjs";
 import {
   assertSprintStatus,
   generateUuid8,
   getEditor,
   resolveSprintId,
   setEditor
-} from "./chunk-ITRZMBLJ.mjs";
+} from "./chunk-JRFOUFD3.mjs";
 import {
   ensureError,
   unwrapOrThrow,
@@ -24,7 +24,7 @@ import {
   getSprintFilePath,
   readValidatedJson,
   writeValidatedJson
-} from "./chunk-GLDPHKEW.mjs";
+} from "./chunk-IB6OCKZW.mjs";
 import {
   IOError,
   IssueFetchError,

package/dist/{chunk-V4ZUDZCG.mjs → chunk-DUU5346E.mjs}

@@ -2,7 +2,7 @@
 import {
   createSprint,
   setCurrentSprint
-} from "./chunk-ITRZMBLJ.mjs";
+} from "./chunk-JRFOUFD3.mjs";
 import {
   emoji,
   field,

package/dist/{chunk-7TBO6GOT.mjs → chunk-EUNAUHC3.mjs}

@@ -7,7 +7,7 @@ import {
   readValidatedJson,
   validateProjectPath,
   writeValidatedJson
-} from "./chunk-GLDPHKEW.mjs";
+} from "./chunk-IB6OCKZW.mjs";
 import {
   ParseError,
   ProjectExistsError,

package/dist/{chunk-GLDPHKEW.mjs → chunk-IB6OCKZW.mjs}

@@ -53,6 +53,13 @@ function getTasksFilePath(sprintId) {
 function getProgressFilePath(sprintId) {
   return join(getSprintDir(sprintId), "progress.md");
 }
+function getEvaluationsDir(sprintId) {
+  return join(getSprintDir(sprintId), "evaluations");
+}
+function getEvaluationFilePath(sprintId, taskId) {
+  assertSafeSegment(taskId, "task ID");
+  return join(getEvaluationsDir(sprintId), `${taskId}.md`);
+}
 function assertSafeSegment(segment, label) {
   if (!segment || segment.includes("/") || segment.includes("\\") || segment.includes("..") || segment.includes("\0")) {
     throw new Error(`Path traversal detected in ${label}: ${segment}`);
@@ -203,6 +210,7 @@ import { z } from "zod";
 var SprintStatusSchema = z.enum(["draft", "active", "closed"]);
 var TaskStatusSchema = z.enum(["todo", "in_progress", "done"]);
 var RequirementStatusSchema = z.enum(["pending", "approved"]);
+var EvaluationStatusSchema = z.enum(["passed", "failed", "malformed"]);
 var RepositorySchema = z.object({
   name: z.string().min(1),
   // Auto-derived from basename(path)
@@ -254,8 +262,12 @@ var TaskSchema = z.object({
   // Output from verification run
   evaluated: z.boolean().default(false),
   // Whether evaluation passed
-  evaluationOutput: z.string().optional()
-  // Output from evaluation run
+  evaluationOutput: z.string().optional(),
+  // Truncated output from evaluation run (full critique lives in evaluationFile)
+  evaluationStatus: EvaluationStatusSchema.optional(),
+  // Discriminator: 'passed' | 'failed' | 'malformed'
+  evaluationFile: z.string().optional()
+  // Sidecar file path containing the full untruncated critique
 });
 var TasksSchema = z.array(TaskSchema);
 var ImportTaskSchema = z.object({
@@ -309,6 +321,7 @@ export {
   getSprintFilePath,
   getTasksFilePath,
   getProgressFilePath,
+  getEvaluationFilePath,
   getRefinementDir,
   getPlanningDir,
   getIdeateDir,

package/dist/{chunk-ITRZMBLJ.mjs → chunk-JRFOUFD3.mjs}

@@ -21,7 +21,7 @@ import {
   readValidatedJson,
   removeDir,
   writeValidatedJson
-} from "./chunk-GLDPHKEW.mjs";
+} from "./chunk-IB6OCKZW.mjs";
 import {
   LockError,
   NoCurrentSprintError,

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

@@ -11,7 +11,7 @@ import {
   getPendingRequirements,
   groupTicketsByProject,
   listTickets
-} from "./chunk-QYF7QIZJ.mjs";
+} from "./chunk-742XQ7FL.mjs";
 import {
   EXIT_ALL_BLOCKED,
   EXIT_ERROR,
@@ -23,7 +23,7 @@ import {
 import {
   getProject,
   listProjects
-} from "./chunk-7TBO6GOT.mjs";
+} from "./chunk-EUNAUHC3.mjs";
 import {
   activateSprint,
   assertSprintStatus,
@@ -40,7 +40,7 @@ import {
   setAiProvider,
   summarizeProgressForContext,
   withFileLock
-} from "./chunk-ITRZMBLJ.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-GLDPHKEW.mjs";
+} from "./chunk-IB6OCKZW.mjs";
 import {
   DependencyCycleError,
   IOError,
@@ -168,7 +170,12 @@ ${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("{{VERIFICATION_CRITERIA_SECTION}}", criteriaSection).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
@@ -1163,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;
   });
@@ -1360,7 +1373,7 @@ async function selectProject(message = "Select project:") {
       default: true
     });
     if (create) {
-      const { projectAddCommand } = await import("./add-K7LNOYQ4.mjs");
+      const { projectAddCommand } = await import("./add-3T225IX5.mjs");
       await projectAddCommand({ interactive: true });
       const updated = await listProjects();
       if (updated.length === 0) return null;
@@ -1433,7 +1446,7 @@ async function selectSprint(message = "Select sprint:", filter) {
       default: true
     });
     if (create) {
-      const { sprintCreateCommand } = await import("./create-5MILNF7E.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;
@@ -1468,7 +1481,7 @@ async function selectTicket(message = "Select ticket:", filter) {
         default: true
       });
       if (create) {
-        const { ticketAddCommand } = await import("./add-DWNLZQ7Q.mjs");
+        const { ticketAddCommand } = await import("./add-6A5432U2.mjs");
         await ticketAddCommand({ interactive: true });
         const updated = await listTickets();
         const refiltered = filter ? updated.filter(filter) : updated;
@@ -2059,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) {
@@ -2455,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"];
@@ -2468,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"],
@@ -2480,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();
@@ -2512,13 +2810,16 @@ function parseDimensionScores(output) {
 function parseEvaluationResult(output) {
   const dimensions = parseDimensionScores(output);
   if (output.includes("<evaluation-passed>")) {
-    return { passed: true, output, dimensions };
+    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, dimensions };
+    return { passed: false, status: "failed", output: failedMatch[1]?.trim() ?? output, dimensions };
   }
-  return { passed: false, output, dimensions };
+  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 (Computational Gate)
@@ -2530,31 +2831,42 @@ ${checkScript}
 \`\`\`
 
 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);
 }
 
@@ -2701,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,
@@ -2711,30 +3048,37 @@ 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);
+  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; i++) {
-    console.log(warning(`Evaluation failed for ${task.name} (iteration ${String(i + 1)}/${String(evalIterations)})`));
+  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.`,
+        prompt: resumePrompt,
         resumeSessionId: currentSessionId ?? void 0,
         env: provider.getSpawnEnv()
       },
@@ -2753,35 +3097,84 @@ If the critique is about something outside your task scope, fix only what is wit
     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, currentModel, 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;
@@ -2926,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}`));
@@ -2956,6 +3350,7 @@ Post-task check failed for: ${task.name}`));
         provider,
         options,
         evalIterations,
+        checkTimeout: sequentialRepo?.checkTimeout,
         useSpinner: true
       });
     }
@@ -3289,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);
@@ -3368,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);
@@ -3536,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;
@@ -3548,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}`);
@@ -3569,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);
@@ -3868,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();

package/dist/{chunk-LAERLCL5.mjs → chunk-UBPZHHCD.mjs}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-7TG3EAQ2.mjs";
 import {
   createProject
-} from "./chunk-7TBO6GOT.mjs";
+} from "./chunk-EUNAUHC3.mjs";
 import {
   ensureError,
   wrapAsync
@@ -16,7 +16,7 @@ import {
 import {
   expandTilde,
   validateProjectPath
-} from "./chunk-GLDPHKEW.mjs";
+} from "./chunk-IB6OCKZW.mjs";
 import {
   IOError,
   ProjectExistsError

package/dist/cli.mjs

@@ -2,7 +2,7 @@
 import {
   addCheckScriptToRepository,
   projectAddCommand
-} from "./chunk-LAERLCL5.mjs";
+} from "./chunk-UBPZHHCD.mjs";
 import {
   addTask,
   areAllTasksDone,
@@ -52,13 +52,13 @@ import {
   sprintStartCommand,
   updateTaskStatus,
   validateImportTasks
-} from "./chunk-ORVGM6EV.mjs";
+} from "./chunk-U62BX47C.mjs";
 import {
   escapableSelect
 } from "./chunk-7LZ6GOGN.mjs";
 import {
   sprintCreateCommand
-} from "./chunk-V4ZUDZCG.mjs";
+} from "./chunk-DUU5346E.mjs";
 import {
   addTicket,
   allRequirementsApproved,
@@ -73,7 +73,7 @@ import {
   removeTicket,
   ticketAddCommand,
   updateTicket
-} from "./chunk-QYF7QIZJ.mjs";
+} from "./chunk-742XQ7FL.mjs";
 import {
   EXIT_ERROR,
   exitWithCode
@@ -84,7 +84,7 @@ import {
   listProjects,
   removeProject,
   removeProjectRepo
-} from "./chunk-7TBO6GOT.mjs";
+} from "./chunk-EUNAUHC3.mjs";
 import {
   DEFAULT_EVALUATION_ITERATIONS,
   assertSprintStatus,
@@ -107,7 +107,7 @@ import {
   setEditor,
   setEvaluationIterations,
   withFileLock
-} from "./chunk-ITRZMBLJ.mjs";
+} from "./chunk-JRFOUFD3.mjs";
 import {
   ensureError,
   wrapAsync
@@ -134,7 +134,7 @@ import {
   getTasksFilePath,
   readValidatedJson,
   validateProjectPath
-} from "./chunk-GLDPHKEW.mjs";
+} from "./chunk-IB6OCKZW.mjs";
 import {
   DomainError,
   NoCurrentSprintError,
@@ -3764,7 +3764,7 @@ async function interactiveMode() {
       continue;
     }
     if (command === "wizard") {
-      const { runWizard } = await import("./wizard-RCQ4QQOL.mjs");
+      const { runWizard } = await import("./wizard-HWOH2HPV.mjs");
       await runWizard();
       continue;
     }
@@ -4323,7 +4323,7 @@ Checks performed:
 // package.json
 var package_default = {
   name: "ralphctl",
-  version: "0.2.3",
+  version: "0.2.4",
   description: "Agent harness for long-running AI coding tasks \u2014 orchestrates Claude Code & GitHub Copilot across repositories",
   homepage: "https://github.com/lukas-grigis/ralphctl",
   type: "module",
@@ -4445,7 +4445,7 @@ registerCompletionCommands(program);
 registerDoctorCommands(program);
 async function main() {
   if (process.env["COMP_CWORD"] && process.env["COMP_POINT"] && process.env["COMP_LINE"]) {
-    const { handleCompletionRequest } = await import("./handle-2BACSJLR.mjs");
+    const { handleCompletionRequest } = await import("./handle-TA4MYNQJ.mjs");
     if (await handleCompletionRequest(program)) return;
   }
   if (process.argv.length <= 2 || process.argv[2] === "interactive") {

package/dist/{create-5MILNF7E.mjs → create-MYGOWO2F.mjs}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   sprintCreateCommand
-} from "./chunk-V4ZUDZCG.mjs";
-import "./chunk-ITRZMBLJ.mjs";
+} from "./chunk-DUU5346E.mjs";
+import "./chunk-JRFOUFD3.mjs";
 import "./chunk-OEUJDSHY.mjs";
-import "./chunk-GLDPHKEW.mjs";
+import "./chunk-IB6OCKZW.mjs";
 import "./chunk-EDJX7TT6.mjs";
 import "./chunk-QBXHAXHI.mjs";
 export {

package/dist/{handle-2BACSJLR.mjs → handle-TA4MYNQJ.mjs}

@@ -7,7 +7,7 @@ async function handleCompletionRequest(program) {
     return false;
   }
   const tabtab = (await import("tabtab")).default;
-  const { resolveCompletions } = await import("./resolver-CFY6DIOP.mjs");
+  const { resolveCompletions } = await import("./resolver-RXEY6EJE.mjs");
   const tabEnv = tabtab.parseEnv(env);
   const completions = await resolveCompletions(program, {
     line: tabEnv.line,

package/dist/{project-XC7AXA4B.mjs → project-YONEJICR.mjs}

@@ -9,8 +9,8 @@ import {
   removeProject,
   removeProjectRepo,
   updateProject
-} from "./chunk-7TBO6GOT.mjs";
-import "./chunk-GLDPHKEW.mjs";
+} from "./chunk-EUNAUHC3.mjs";
+import "./chunk-IB6OCKZW.mjs";
 import {
   ProjectExistsError,
   ProjectNotFoundError

package/dist/prompts/task-evaluation-resume.md

@@ -0,0 +1,22 @@
+# Evaluator Feedback — Fix and Re-verify
+
+The independent code reviewer found issues with your implementation. Treat this as ground truth — do not argue with
+it. Read the critique carefully, fix each identified issue, then re-verify and signal completion.
+
+## Critique
+
+{{CRITIQUE}}
+
+## What to do now
+
+1. **Fix each issue in the critique above.** Reference the file:line locations the reviewer cited. If a citation is
+   wrong, find the actually-affected location and fix that.
+2. **Stay in scope.** If the critique calls out something outside your task scope, fix only what is within scope and
+   note the rest. Do not expand the task.
+3. **Re-run verification commands.** Run the project's check script (or the equivalent verification commands) and
+   confirm they pass.{{COMMIT_INSTRUCTION}}
+4. **Re-output verification results** wrapped in `<task-verified>...</task-verified>`.
+5. **Signal completion** with `<task-complete>` ONLY after all of the above pass.
+
+If the critique is unfixable (e.g. it asks for something that contradicts the spec, or requires changes you cannot
+make), signal `<task-blocked>reason</task-blocked>` instead of completing.

package/dist/prompts/task-evaluation.md

@@ -22,6 +22,8 @@ You are working in this project directory:
 {{PROJECT_PATH}}
 ```
 
+{{PROJECT_TOOLING_SECTION}}
+
 ### Phase 1: Computational Verification (run before reasoning)
 
 Run deterministic checks first — these are cheap, fast, and authoritative.

package/dist/{resolver-CFY6DIOP.mjs → resolver-RXEY6EJE.mjs}

@@ -11,7 +11,7 @@ var dynamicResolvers = {
   "--project": async () => {
     const result = await wrapAsync(
       async () => {
-        const { listProjects } = await import("./project-XC7AXA4B.mjs");
+        const { listProjects } = await import("./project-YONEJICR.mjs");
         return listProjects();
       },
       (err) => new IOError("Failed to load projects for completion", err instanceof Error ? err : void 0)
@@ -45,7 +45,7 @@ var configValueCompletions = {
 async function getSprintCompletions() {
   const result = await wrapAsync(
     async () => {
-      const { listSprints } = await import("./sprint-F4VRAEWZ.mjs");
+      const { listSprints } = await import("./sprint-FGLWYWKX.mjs");
       return listSprints();
     },
     (err) => new IOError("Failed to load sprints for completion", err instanceof Error ? err : void 0)

package/dist/{sprint-F4VRAEWZ.mjs → sprint-FGLWYWKX.mjs}

@@ -12,9 +12,9 @@ import {
   listSprints,
   resolveSprintId,
   saveSprint
-} from "./chunk-ITRZMBLJ.mjs";
+} from "./chunk-JRFOUFD3.mjs";
 import "./chunk-OEUJDSHY.mjs";
-import "./chunk-GLDPHKEW.mjs";
+import "./chunk-IB6OCKZW.mjs";
 import {
   NoCurrentSprintError,
   SprintNotFoundError,

package/dist/{wizard-RCQ4QQOL.mjs → wizard-HWOH2HPV.mjs}

@@ -3,25 +3,25 @@ import {
   sprintPlanCommand,
   sprintRefineCommand,
   sprintStartCommand
-} from "./chunk-ORVGM6EV.mjs";
+} from "./chunk-U62BX47C.mjs";
 import "./chunk-7LZ6GOGN.mjs";
 import {
   sprintCreateCommand
-} from "./chunk-V4ZUDZCG.mjs";
+} from "./chunk-DUU5346E.mjs";
 import {
   addSingleTicketInteractive
-} from "./chunk-QYF7QIZJ.mjs";
+} from "./chunk-742XQ7FL.mjs";
 import "./chunk-7TG3EAQ2.mjs";
-import "./chunk-7TBO6GOT.mjs";
+import "./chunk-EUNAUHC3.mjs";
 import {
   getCurrentSprint,
   getSprint
-} from "./chunk-ITRZMBLJ.mjs";
+} from "./chunk-JRFOUFD3.mjs";
 import {
   ensureError,
   wrapAsync
 } from "./chunk-OEUJDSHY.mjs";
-import "./chunk-GLDPHKEW.mjs";
+import "./chunk-IB6OCKZW.mjs";
 import "./chunk-EDJX7TT6.mjs";
 import {
   colors,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ralphctl",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Agent harness for long-running AI coding tasks — orchestrates Claude Code & GitHub Copilot across repositories",
   "homepage": "https://github.com/lukas-grigis/ralphctl",
   "type": "module",

package/schemas/tasks.schema.json

@@ -82,7 +82,16 @@
       },
       "evaluationOutput": {
         "type": "string",
-        "description": "Output from the evaluation run (truncated to 2000 chars)"
+        "description": "Output from the evaluation run (truncated to 2000 chars; full critique in evaluationFile)"
+      },
+      "evaluationStatus": {
+        "type": "string",
+        "enum": ["passed", "failed", "malformed"],
+        "description": "Evaluation outcome discriminator. 'malformed' = evaluator output had no parseable signal."
+      },
+      "evaluationFile": {
+        "type": "string",
+        "description": "Sidecar file path containing the full untruncated critique"
       }
     }
   }