ralphctl 0.2.3 → 0.2.5

package/dist/{chunk-ORVGM6EV.mjs → chunk-CSICORGV.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,
@@ -123,37 +125,91 @@ var promptDir = getPromptDir();
 function loadTemplate(name) {
   return readFileSync(join(promptDir, `${name}.md`), "utf-8");
 }
-function buildPlanPrompt(template, context, schema) {
-  const common = loadTemplate("plan-common");
-  return template.replace("{{COMMON}}", common).replace("{{CONTEXT}}", context).replace("{{SCHEMA}}", schema);
+function loadPartial(name) {
+  return loadTemplate(name).replace(/\s+$/, "");
 }
-function buildInteractivePrompt(context, outputFile, schema) {
-  const template = loadTemplate("plan-interactive");
-  return buildPlanPrompt(template, context, schema).replace("{{OUTPUT_FILE}}", outputFile);
+var UNREPLACED_TOKEN_RE = /\{\{[A-Z_]+\}\}/g;
+function composePrompt(template, substitutions) {
+  let result = template;
+  for (const [key, value] of Object.entries(substitutions)) {
+    result = result.replaceAll(`{{${key}}}`, value);
+  }
+  const remaining = result.match(UNREPLACED_TOKEN_RE);
+  if (remaining) {
+    throw new Error(`composePrompt: unreplaced placeholders: ${[...new Set(remaining)].join(", ")}`);
+  }
+  return result;
+}
+function buildPlanCommon(projectToolingSection) {
+  return composePrompt(loadPartial("plan-common"), {
+    PROJECT_TOOLING: projectToolingSection
+  });
+}
+function buildPlannerBase(projectToolingSection) {
+  return {
+    HARNESS_CONTEXT: loadPartial("harness-context"),
+    COMMON: buildPlanCommon(projectToolingSection),
+    VALIDATION: loadPartial("validation-checklist"),
+    SIGNALS: loadPartial("signals-planning")
+  };
+}
+function buildInteractivePrompt(context, outputFile, schema, projectToolingSection) {
+  return composePrompt(loadTemplate("plan-interactive"), {
+    ...buildPlannerBase(projectToolingSection),
+    CONTEXT: context,
+    OUTPUT_FILE: outputFile,
+    SCHEMA: schema
+  });
 }
-function buildAutoPrompt(context, schema) {
-  const template = loadTemplate("plan-auto");
-  return buildPlanPrompt(template, context, schema);
+function buildAutoPrompt(context, schema, projectToolingSection) {
+  return composePrompt(loadTemplate("plan-auto"), {
+    ...buildPlannerBase(projectToolingSection),
+    CONTEXT: context,
+    SCHEMA: schema
+  });
 }
 function buildTaskExecutionPrompt(progressFilePath, noCommit, contextFileName) {
   const template = loadTemplate("task-execution");
-  const commitStep = noCommit ? "" : "\n> **Before continuing:** Create a git commit with a descriptive message for the changes made.\n";
+  const commitStep = noCommit ? "" : "\n   - **Before continuing:** Create a git commit with a descriptive message for the changes made.";
   const commitConstraint = noCommit ? "" : "- **Must commit** \u2014 Create a git commit before signaling completion.\n";
-  return template.replaceAll("{{PROGRESS_FILE}}", progressFilePath).replaceAll("{{COMMIT_STEP}}", commitStep).replaceAll("{{COMMIT_CONSTRAINT}}", commitConstraint).replaceAll("{{CONTEXT_FILE}}", contextFileName);
+  return composePrompt(template, {
+    HARNESS_CONTEXT: loadPartial("harness-context"),
+    SIGNALS: loadPartial("signals-task"),
+    PROGRESS_FILE: progressFilePath,
+    COMMIT_STEP: commitStep,
+    COMMIT_CONSTRAINT: commitConstraint,
+    CONTEXT_FILE: contextFileName
+  });
 }
 function buildTicketRefinePrompt(ticketContent, outputFile, schema, issueContext = "") {
   const template = loadTemplate("ticket-refine");
-  return template.replace("{{TICKET}}", ticketContent).replace("{{OUTPUT_FILE}}", outputFile).replace("{{SCHEMA}}", schema).replace("{{ISSUE_CONTEXT}}", issueContext);
+  return composePrompt(template, {
+    TICKET: ticketContent,
+    OUTPUT_FILE: outputFile,
+    SCHEMA: schema,
+    ISSUE_CONTEXT: issueContext
+  });
 }
-function buildIdeatePrompt(ideaTitle, ideaDescription, projectName, repositories, outputFile, schema) {
-  const template = loadTemplate("ideate");
-  const common = loadTemplate("plan-common");
-  return template.replace("{{IDEA_TITLE}}", ideaTitle).replace("{{IDEA_DESCRIPTION}}", ideaDescription).replace("{{PROJECT_NAME}}", projectName).replace("{{REPOSITORIES}}", repositories).replace("{{OUTPUT_FILE}}", outputFile).replace("{{SCHEMA}}", schema).replace("{{COMMON}}", common);
+function buildIdeatePrompt(ideaTitle, ideaDescription, projectName, repositories, outputFile, schema, projectToolingSection) {
+  return composePrompt(loadTemplate("ideate"), {
+    ...buildPlannerBase(projectToolingSection),
+    IDEA_TITLE: ideaTitle,
+    IDEA_DESCRIPTION: ideaDescription,
+    PROJECT_NAME: projectName,
+    REPOSITORIES: repositories,
+    OUTPUT_FILE: outputFile,
+    SCHEMA: schema
+  });
 }
-function buildIdeateAutoPrompt(ideaTitle, ideaDescription, projectName, repositories, schema) {
-  const template = loadTemplate("ideate-auto");
-  const common = loadTemplate("plan-common");
-  return template.replace("{{IDEA_TITLE}}", ideaTitle).replace("{{IDEA_DESCRIPTION}}", ideaDescription).replace("{{PROJECT_NAME}}", projectName).replace("{{REPOSITORIES}}", repositories).replace("{{SCHEMA}}", schema).replace("{{COMMON}}", common);
+function buildIdeateAutoPrompt(ideaTitle, ideaDescription, projectName, repositories, schema, projectToolingSection) {
+  return composePrompt(loadTemplate("ideate-auto"), {
+    ...buildPlannerBase(projectToolingSection),
+    IDEA_TITLE: ideaTitle,
+    IDEA_DESCRIPTION: ideaDescription,
+    PROJECT_NAME: projectName,
+    REPOSITORIES: repositories,
+    SCHEMA: schema
+  });
 }
 function buildEvaluatorPrompt(ctx) {
   const template = loadTemplate("task-evaluation");
@@ -168,7 +224,27 @@ ${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 composePrompt(template, {
+    HARNESS_CONTEXT: loadPartial("harness-context"),
+    SIGNALS: loadPartial("signals-evaluation"),
+    TASK_NAME: ctx.taskName,
+    TASK_DESCRIPTION_SECTION: descriptionSection,
+    TASK_STEPS_SECTION: stepsSection,
+    VERIFICATION_CRITERIA_SECTION: criteriaSection,
+    PROJECT_PATH: ctx.projectPath,
+    CHECK_SCRIPT_SECTION: checkSection,
+    PROJECT_TOOLING: 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 composePrompt(template, {
+    HARNESS_CONTEXT: loadPartial("harness-context"),
+    SIGNALS: loadPartial("signals-task"),
+    CRITIQUE: ctx.critique,
+    COMMIT_INSTRUCTION: commitInstruction
+  });
 }
 
 // src/utils/requirements-export.ts
@@ -1053,7 +1129,7 @@ ${text}`;
 
 // src/commands/sprint/plan.ts
 import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { confirm as confirm3 } from "@inquirer/prompts";
 import { Result as Result5 } from "typescript-result";
 
@@ -1163,6 +1239,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;
   });
@@ -1349,6 +1431,172 @@ function validateImportTasks(importTasks2, existingTasks, ticketIds) {
   return errors;
 }
 
+// src/ai/project-tooling.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { join as join5 } from "path";
+var EMPTY_TOOLING = {
+  agents: [],
+  skills: [],
+  mcpServers: [],
+  hasClaudeMd: false,
+  hasAgentsMd: false,
+  hasCopilotInstructions: false
+};
+function safeListDir(path, predicate) {
+  try {
+    if (!existsSync2(path)) return [];
+    return readdirSync(path).filter(predicate).sort();
+  } catch {
+    return [];
+  }
+}
+var EVALUATOR_DENYLISTED_AGENTS = /* @__PURE__ */ new Set(["implementer", "planner"]);
+function detectAgents(projectPath) {
+  const agentsDir = join5(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 = join5(projectPath, ".claude", "skills");
+  try {
+    if (!existsSync2(skillsDir)) return [];
+    return readdirSync(skillsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  } catch {
+    return [];
+  }
+}
+function detectMcpServers(projectPath) {
+  const mcpFile = join5(projectPath, ".mcp.json");
+  if (!existsSync2(mcpFile)) return [];
+  try {
+    const raw = readFileSync2(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 || !existsSync2(projectPath)) {
+    return EMPTY_TOOLING;
+  }
+  return {
+    agents: detectAgents(projectPath),
+    skills: detectSkills(projectPath),
+    mcpServers: detectMcpServers(projectPath),
+    hasClaudeMd: existsSync2(join5(projectPath, "CLAUDE.md")),
+    hasAgentsMd: existsSync2(join5(projectPath, "AGENTS.md")),
+    hasCopilotInstructions: existsSync2(join5(projectPath, ".github", "copilot-instructions.md"))
+  };
+}
+function detectProjectToolingAcrossPaths(projectPaths) {
+  if (projectPaths.length === 0) {
+    return EMPTY_TOOLING;
+  }
+  const agents = /* @__PURE__ */ new Set();
+  const skills = /* @__PURE__ */ new Set();
+  const mcpServers = /* @__PURE__ */ new Set();
+  let hasClaudeMd = false;
+  let hasAgentsMd = false;
+  let hasCopilotInstructions = false;
+  for (const path of projectPaths) {
+    const tooling = detectProjectTooling(path);
+    for (const agent of tooling.agents) agents.add(agent);
+    for (const skill of tooling.skills) skills.add(skill);
+    for (const server of tooling.mcpServers) mcpServers.add(server);
+    hasClaudeMd = hasClaudeMd || tooling.hasClaudeMd;
+    hasAgentsMd = hasAgentsMd || tooling.hasAgentsMd;
+    hasCopilotInstructions = hasCopilotInstructions || tooling.hasCopilotInstructions;
+  }
+  return {
+    agents: [...agents].sort(),
+    skills: [...skills].sort(),
+    mcpServers: [...mcpServers].sort(),
+    hasClaudeMd,
+    hasAgentsMd,
+    hasCopilotInstructions
+  };
+}
+function buildProjectToolingSection(paths) {
+  const tooling = typeof paths === "string" ? detectProjectTooling(paths) : detectProjectToolingAcrossPaths([...paths]);
+  return renderProjectToolingSection(tooling);
+}
+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/interactive/selectors.ts
 import { checkbox, confirm as confirm2, input } from "@inquirer/prompts";
 async function selectProject(message = "Select project:") {
@@ -1360,7 +1608,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 +1681,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 +1716,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;
@@ -1762,7 +2010,7 @@ async function getSprintContext(sprintName, ticketsByProject, existingTasks) {
   return lines.join("\n");
 }
 async function invokeAiInteractive(prompt, repoPaths, planDir) {
-  const contextFile = join5(planDir, "planning-context.md");
+  const contextFile = join6(planDir, "planning-context.md");
   await writeFile3(contextFile, prompt, "utf-8");
   const provider = await getActiveProvider();
   const ticketCount = (prompt.match(/^####/gm) ?? []).length;
@@ -1930,8 +2178,9 @@ async function sprintPlanCommand(args) {
   const planDir = getPlanningDir(id);
   await mkdir2(planDir, { recursive: true });
   const ticketIds = new Set(sprint.tickets.map((t) => t.id));
+  const projectToolingSection = buildProjectToolingSection(selectedPaths);
   if (options.auto) {
-    const prompt = buildAutoPrompt(context, schema);
+    const prompt = buildAutoPrompt(context, schema, projectToolingSection);
     const spinner = createSpinner(`${providerName} is planning tasks...`);
     spinner.start();
     const outputR = await wrapAsync(() => invokeAiAuto(prompt, selectedPaths, planDir), ensureError);
@@ -1987,8 +2236,8 @@ async function sprintPlanCommand(args) {
     showSuccess(`Imported ${String(imported)}/${String(parsedTasks.length)} tasks.`);
     log.newline();
   } else {
-    const outputFile = join5(planDir, "tasks.json");
-    const prompt = buildInteractivePrompt(context, outputFile, schema);
+    const outputFile = join6(planDir, "tasks.json");
+    const prompt = buildInteractivePrompt(context, outputFile, schema, projectToolingSection);
     showInfo(`Starting interactive ${providerName} session...`);
     console.log(
       muted(
@@ -2059,15 +2308,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) {
@@ -2164,12 +2563,12 @@ var RateLimitCoordinator = class {
 // src/ai/task-context.ts
 import { execSync } from "child_process";
 import { writeFile as writeFile4 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import { Result as Result7 } from "typescript-result";
 
 // src/ai/permissions.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join7 } from "path";
 import { homedir } from "os";
 import { Result as Result6 } from "typescript-result";
 function getProviderPermissions(projectPath, provider) {
@@ -2180,10 +2579,10 @@ function getProviderPermissions(projectPath, provider) {
   if (provider === "copilot") {
     return permissions;
   }
-  const projectSettingsPath = join6(projectPath, ".claude", "settings.local.json");
-  if (existsSync2(projectSettingsPath)) {
+  const projectSettingsPath = join7(projectPath, ".claude", "settings.local.json");
+  if (existsSync3(projectSettingsPath)) {
     const projectResult = Result6.try(() => {
-      const content = readFileSync2(projectSettingsPath, "utf-8");
+      const content = readFileSync3(projectSettingsPath, "utf-8");
       return JSON.parse(content);
     });
     if (projectResult.ok) {
@@ -2196,10 +2595,10 @@ function getProviderPermissions(projectPath, provider) {
       }
     }
   }
-  const userSettingsPath = join6(homedir(), ".claude", "settings.json");
-  if (existsSync2(userSettingsPath)) {
+  const userSettingsPath = join7(homedir(), ".claude", "settings.json");
+  if (existsSync3(userSettingsPath)) {
     const userResult = Result6.try(() => {
-      const content = readFileSync2(userSettingsPath, "utf-8");
+      const content = readFileSync3(userSettingsPath, "utf-8");
       return JSON.parse(content);
     });
     if (userResult.ok) {
@@ -2413,7 +2812,7 @@ function getContextFileName(sprintId, taskId) {
   return `.ralphctl-sprint-${sprintId}-task-${taskId}-context.md`;
 }
 async function writeTaskContextFile(projectPath, taskContent, instructions, sprintId, taskId) {
-  const contextFile = join7(projectPath, getContextFileName(sprintId, taskId));
+  const contextFile = join8(projectPath, getContextFileName(sprintId, taskId));
   const warning2 = `<!-- TEMPORARY FILE - DO NOT COMMIT -->
 <!-- This file is auto-generated by ralphctl for task execution context -->
 <!-- It will be automatically cleaned up after task completion -->
@@ -2455,7 +2854,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 +2867,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"],
@@ -2481,6 +2880,7 @@ function runLifecycleHook(projectPath, script, event, timeoutOverrideMs) {
 }
 
 // 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 +2912,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 };
+  }
+  if (dimensions.length > 0) {
+    return { passed: false, status: "failed", output, dimensions };
   }
-  return { passed: false, output, dimensions };
+  return { passed: false, status: "malformed", output, dimensions };
 }
 function buildEvaluatorContext(task, checkScript) {
   const checkScriptSection = checkScript ? `## Check Script (Computational Gate)
@@ -2530,31 +2933,41 @@ ${checkScript}
 \`\`\`
 
 If this script fails, the implementation fails regardless of code quality. Record the full output.` : null;
+  const projectToolingSection = buildProjectToolingSection(task.projectPath);
   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 +3114,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 +3149,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 +3198,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 +3420,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 +3451,7 @@ Post-task check failed for: ${task.name}`));
         provider,
         options,
         evalIterations,
+        checkTimeout: sequentialRepo?.checkTimeout,
         useSpinner: true
       });
     }
@@ -3289,7 +3785,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 +3865,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 +3914,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 +3926,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 +3947,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 +4246,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();
@@ -3938,6 +4316,7 @@ export {
   parseRequirementsFile,
   runAiSession,
   sprintRefineCommand,
+  buildProjectToolingSection,
   getTaskImportSchema,
   parsePlanningBlocked,
   buildHeadlessAiRequest,