ralphctl 0.1.4 → 0.2.1

package/dist/{chunk-M7JV6MKD.mjs → chunk-AXNZMHFQ.mjs}

@@ -11,7 +11,7 @@ import {
   getPendingRequirements,
   groupTicketsByProject,
   listTickets
-} from "./chunk-F2MMCTB5.mjs";
+} from "./chunk-XPDI4SYI.mjs";
 import {
   EXIT_ALL_BLOCKED,
   EXIT_ERROR,
@@ -23,13 +23,14 @@ import {
 import {
   getProject,
   listProjects
-} from "./chunk-PDI6HBZ7.mjs";
+} from "./chunk-LG6B7QVO.mjs";
 import {
   activateSprint,
   assertSprintStatus,
   closeSprint,
   generateUuid8,
   getAiProvider,
+  getEvaluationIterations,
   getProgress,
   getSprint,
   listSprints,
@@ -39,7 +40,7 @@ import {
   setAiProvider,
   summarizeProgressForContext,
   withFileLock
-} from "./chunk-LFDW6MWF.mjs";
+} from "./chunk-KPTPKLXY.mjs";
 import {
   ensureError,
   unwrapOrThrow,
@@ -60,7 +61,7 @@ import {
   getTasksFilePath,
   readValidatedJson,
   writeValidatedJson
-} from "./chunk-W3TY22IS.mjs";
+} from "./chunk-ZDEVRTGY.mjs";
 import {
   DependencyCycleError,
   IOError,
@@ -106,7 +107,7 @@ import {
 import { mkdir, readFile } from "fs/promises";
 import { join as join4 } from "path";
 import { confirm } from "@inquirer/prompts";
-import { Result as Result3 } from "typescript-result";
+import { Result as Result4 } from "typescript-result";
 
 // src/ai/prompts/index.ts
 import { existsSync, readFileSync } from "fs";
@@ -138,7 +139,7 @@ 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 commitConstraint = noCommit ? "" : "- **Must commit** \u2014 Create a git commit before signaling completion.\n";
-  return template.replace("{{PROGRESS_FILE}}", progressFilePath).replace("{{COMMIT_STEP}}", commitStep).replace("{{COMMIT_CONSTRAINT}}", commitConstraint).replaceAll("{{CONTEXT_FILE}}", contextFileName);
+  return template.replaceAll("{{PROGRESS_FILE}}", progressFilePath).replaceAll("{{COMMIT_STEP}}", commitStep).replaceAll("{{COMMIT_CONSTRAINT}}", commitConstraint).replaceAll("{{CONTEXT_FILE}}", contextFileName);
 }
 function buildTicketRefinePrompt(ticketContent, outputFile, schema, issueContext = "") {
   const template = loadTemplate("ticket-refine");
@@ -154,6 +155,18 @@ function buildIdeateAutoPrompt(ideaTitle, ideaDescription, projectName, reposito
   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 buildEvaluatorPrompt(ctx) {
+  const template = loadTemplate("task-evaluation");
+  const descriptionSection = ctx.taskDescription ? `
+**Description:** ${ctx.taskDescription}` : "";
+  const stepsSection = ctx.taskSteps.length > 0 ? `
+**Implementation Steps:**
+${ctx.taskSteps.map((s) => `- ${s}`).join("\n")}` : "";
+  const checkSection = ctx.checkScriptSection ? `
+
+${ctx.checkScriptSection}` : "";
+  return template.replaceAll("{{TASK_NAME}}", ctx.taskName).replace("{{TASK_DESCRIPTION_SECTION}}", descriptionSection).replace("{{TASK_STEPS_SECTION}}", stepsSection).replace("{{PROJECT_PATH}}", ctx.projectPath).replace("{{CHECK_SCRIPT_SECTION}}", checkSection);
+}
 
 // src/utils/requirements-export.ts
 import { writeFile } from "fs/promises";
@@ -223,7 +236,7 @@ function providerDisplayName(provider) {
 // src/commands/ticket/refine-utils.ts
 import { writeFile as writeFile2 } from "fs/promises";
 import { join as join3 } from "path";
-import { Result as Result2 } from "typescript-result";
+import { Result as Result3 } from "typescript-result";
 
 // src/ai/session.ts
 import { spawn, spawnSync } from "child_process";
@@ -243,6 +256,9 @@ var ProcessManager = class _ProcessManager {
   handlersInstalled = false;
   /** Timestamp of first SIGINT (for double-signal detection) */
   firstSigintAt = null;
+  /** Stored signal handler references for cleanup */
+  sigintHandler = null;
+  sigtermHandler = null;
   constructor() {
   }
   /**
@@ -331,9 +347,9 @@ var ProcessManager = class _ProcessManager {
         if (error2.code === "ESRCH") {
           this.children.delete(child);
         } else if (error2.code === "EPERM") {
-          console.warn(`Warning: Permission denied killing process ${String(child.pid)}`);
+          log.warn(`Permission denied killing process ${String(child.pid)}`);
         } else {
-          console.error(`Error killing process ${String(child.pid)}:`, error2.message);
+          log.error(`Error killing process ${String(child.pid)}: ${error2.message}`);
         }
       }
     }
@@ -352,7 +368,7 @@ var ProcessManager = class _ProcessManager {
     if (signal === "SIGINT" && this.firstSigintAt) {
       const now = Date.now();
       if (now - this.firstSigintAt < FORCE_QUIT_WINDOW_MS) {
-        console.log("\n\nForce quit (double signal) \u2014 killing all processes immediately...");
+        log.warn("\n\nForce quit (double signal) \u2014 killing all processes immediately...");
         this.killAll("SIGKILL");
         process.exit(1);
         return;
@@ -365,12 +381,12 @@ var ProcessManager = class _ProcessManager {
     if (signal === "SIGINT") {
       this.firstSigintAt = Date.now();
     }
-    console.log("\n\nShutting down gracefully... (press Ctrl+C again to force-quit)");
+    log.dim("\n\nShutting down gracefully... (press Ctrl+C again to force-quit)");
     for (const callback of this.cleanupCallbacks) {
       try {
         callback();
       } catch (err) {
-        console.error("Error in cleanup callback:", err instanceof Error ? err.message : String(err));
+        log.error(`Error in cleanup callback: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
     this.cleanupCallbacks.clear();
@@ -380,7 +396,7 @@ var ProcessManager = class _ProcessManager {
       await new Promise((resolve) => setTimeout(resolve, 100));
     }
     if (this.children.size > 0) {
-      console.log(`Force-killing ${String(this.children.size)} remaining process(es)...`);
+      log.warn(`Force-killing ${String(this.children.size)} remaining process(es)...`);
       this.killAll("SIGKILL");
     }
     process.exit(signal === "SIGINT" ? EXIT_INTERRUPTED : 1);
@@ -390,6 +406,14 @@ var ProcessManager = class _ProcessManager {
    * @internal
    */
   dispose() {
+    if (this.sigintHandler) {
+      process.removeListener("SIGINT", this.sigintHandler);
+      this.sigintHandler = null;
+    }
+    if (this.sigtermHandler) {
+      process.removeListener("SIGTERM", this.sigtermHandler);
+      this.sigtermHandler = null;
+    }
     this.children.clear();
     this.cleanupCallbacks.clear();
     this.exiting = false;
@@ -399,14 +423,17 @@ var ProcessManager = class _ProcessManager {
   /**
    * Install signal handlers for SIGINT and SIGTERM.
    * Uses process.on() (persistent) not process.once() (one-shot).
+   * Stores handler references so dispose() can remove them.
    */
   installSignalHandlers() {
-    process.on("SIGINT", () => {
+    this.sigintHandler = () => {
       void this.shutdown("SIGINT");
-    });
-    process.on("SIGTERM", () => {
+    };
+    this.sigtermHandler = () => {
       void this.shutdown("SIGTERM");
-    });
+    };
+    process.on("SIGINT", this.sigintHandler);
+    process.on("SIGTERM", this.sigtermHandler);
   }
 };
 
@@ -427,14 +454,21 @@ var claudeAdapter = {
   parseJsonOutput(stdout) {
     const jsonResult = Result.try(() => JSON.parse(stdout));
     if (!jsonResult.ok) {
-      return { result: stdout, sessionId: null };
+      return { result: stdout, sessionId: null, model: null };
     }
     const parsed = jsonResult.value;
     return {
       result: parsed.result ?? stdout,
-      sessionId: parsed.session_id ?? null
+      sessionId: parsed.session_id ?? null,
+      model: parsed.model ?? null
     };
   },
+  buildResumeArgs(sessionId) {
+    if (!/^[a-zA-Z0-9_][a-zA-Z0-9_-]{0,127}$/.test(sessionId)) {
+      throw new Error("Invalid session ID format");
+    }
+    return ["--resume", sessionId];
+  },
   detectRateLimit(stderr) {
     const patterns = [/rate.?limit/i, /\b429\b/, /too many requests/i, /overloaded/i, /\b529\b/];
     const isRateLimited = patterns.some((p) => p.test(stderr));
@@ -453,6 +487,7 @@ var claudeAdapter = {
 // src/providers/copilot.ts
 import { lstat, readdir, unlink } from "fs/promises";
 import { join as join2 } from "path";
+import { Result as Result2 } from "typescript-result";
 var copilotAdapter = {
   name: "copilot",
   displayName: "Copilot",
@@ -463,10 +498,30 @@ var copilotAdapter = {
     return [...this.baseArgs, ...extraArgs, "-i", prompt];
   },
   buildHeadlessArgs(extraArgs = []) {
-    return ["-p", "-s", "--autopilot", "--no-ask-user", "--share", ...this.baseArgs, ...extraArgs];
+    return ["-p", "--output-format", "json", "--autopilot", "--no-ask-user", "--share", ...this.baseArgs, ...extraArgs];
   },
   parseJsonOutput(stdout) {
-    return { result: stdout.trim(), sessionId: null };
+    const lines = stdout.trim().split("\n").filter(Boolean);
+    if (lines.length === 0) {
+      return { result: "", sessionId: null, model: null };
+    }
+    const lastLine = lines.at(-1) ?? "";
+    const jsonResult = Result2.try(() => JSON.parse(lastLine));
+    if (jsonResult.ok) {
+      const parsed = jsonResult.value;
+      return {
+        result: parsed.result ?? parsed.result_text ?? lastLine,
+        sessionId: parsed.session_id ?? null,
+        model: null
+      };
+    }
+    return { result: stdout.trim(), sessionId: null, model: null };
+  },
+  buildResumeArgs(sessionId) {
+    if (!/^[a-zA-Z0-9_][a-zA-Z0-9_-]{0,127}$/.test(sessionId)) {
+      throw new Error("Invalid session ID format");
+    }
+    return [`--resume=${sessionId}`];
   },
   async extractSessionId(cwd) {
     const filesResult = await wrapAsync(
@@ -511,11 +566,13 @@ function getProvider(provider) {
       return copilotAdapter;
   }
 }
+var experimentalWarningShown = false;
 async function getActiveProvider() {
   const provider = await resolveProvider();
   const adapter = getProvider(provider);
-  if (adapter.experimental) {
+  if (adapter.experimental && !experimentalWarningShown) {
     showWarning(`${adapter.displayName} provider is in public preview \u2014 some features may not work as expected.`);
+    experimentalWarningShown = true;
   }
   return adapter;
 }
@@ -523,25 +580,15 @@ async function getActiveProvider() {
 // src/ai/session.ts
 function spawnInteractive(prompt, options, provider) {
   assertSafeCwd(options.cwd);
-  const p = provider ?? {
-    binary: "claude",
-    baseArgs: ["--permission-mode", "acceptEdits"],
-    buildInteractiveArgs: (pr, extra = []) => [
-      ...["--permission-mode", "acceptEdits"],
-      ...extra,
-      "--",
-      pr
-    ]
-  };
-  const args = prompt ? p.buildInteractiveArgs(prompt, options.args ?? []) : [...p.baseArgs, ...options.args ?? []];
+  const args = prompt ? provider.buildInteractiveArgs(prompt, options.args ?? []) : [...provider.baseArgs, ...options.args ?? []];
   const env = options.env ? { ...process.env, ...options.env } : void 0;
-  const result = spawnSync(p.binary, args, {
+  const result = spawnSync(provider.binary, args, {
     cwd: options.cwd,
     stdio: "inherit",
     env
   });
   if (result.error) {
-    return { code: 1, error: `Failed to spawn ${p.binary} CLI: ${result.error.message}` };
+    return { code: 1, error: `Failed to spawn ${provider.binary} CLI: ${result.error.message}` };
   }
   return { code: result.status ?? 1 };
 }
@@ -555,11 +602,12 @@ async function spawnHeadlessRaw(options, provider) {
   return new Promise((resolve, reject) => {
     const allArgs = p.buildHeadlessArgs(options.args ?? []);
     if (options.resumeSessionId) {
-      if (!/^[a-zA-Z0-9_][a-zA-Z0-9_-]{0,127}$/.test(options.resumeSessionId)) {
+      try {
+        allArgs.push(...p.buildResumeArgs(options.resumeSessionId));
+      } catch {
         reject(new SpawnError("Invalid session ID format", "", 1));
         return;
       }
-      allArgs.push("--resume", options.resumeSessionId);
     }
     const child = spawn(p.binary, allArgs, {
       cwd: options.cwd,
@@ -573,6 +621,7 @@ async function spawnHeadlessRaw(options, provider) {
       reject(new SpawnError("Cannot spawn during shutdown", "", 1));
       return;
     }
+    const MAX_STDOUT_SIZE = 1e7;
     const MAX_PROMPT_SIZE = 1e6;
     if (options.prompt) {
       if (options.prompt.length > MAX_PROMPT_SIZE) {
@@ -585,7 +634,9 @@ async function spawnHeadlessRaw(options, provider) {
     let rawStdout = "";
     let stderr = "";
     child.stdout.on("data", (data) => {
-      rawStdout += data.toString();
+      if (rawStdout.length < MAX_STDOUT_SIZE) {
+        rawStdout += data.toString();
+      }
     });
     child.stderr.on("data", (data) => {
       stderr += data.toString();
@@ -593,7 +644,7 @@ async function spawnHeadlessRaw(options, provider) {
     child.on("close", (code) => {
       void (async () => {
         const exitCode = code ?? 1;
-        const { result, sessionId: parsedSessionId } = p.parseJsonOutput(rawStdout);
+        const { result, sessionId: parsedSessionId, model: parsedModel } = p.parseJsonOutput(rawStdout);
         const sessionId = parsedSessionId ?? await p.extractSessionId?.(options.cwd) ?? null;
         if (exitCode !== 0) {
           reject(
@@ -605,7 +656,7 @@ async function spawnHeadlessRaw(options, provider) {
             )
           );
         } else {
-          resolve({ stdout: result, stderr, exitCode: 0, sessionId });
+          resolve({ stdout: result, stderr, exitCode: 0, sessionId, model: parsedModel });
         }
       })().catch((err) => {
         reject(new SpawnError(`Unexpected error in close handler: ${String(err)}`, "", 1));
@@ -716,7 +767,7 @@ function formatTicketForPrompt(ticket) {
 }
 function parseRequirementsFile(content) {
   const jsonStr = extractJsonArray(content);
-  const parseR = Result2.try(() => JSON.parse(jsonStr));
+  const parseR = Result3.try(() => JSON.parse(jsonStr));
   if (!parseR.ok) {
     throw new Error(`Invalid JSON: ${parseR.error.message}`, { cause: parseR.error });
   }
@@ -743,7 +794,8 @@ async function runAiSession(workingDir, prompt, ticketTitle) {
   const result = spawnInteractive(
     startPrompt,
     {
-      cwd: workingDir
+      cwd: workingDir,
+      env: provider.getSpawnEnv()
     },
     provider
   );
@@ -864,7 +916,7 @@ async function sprintRefineCommand(args) {
       const fetchSpinner = createSpinner("Fetching issue data...");
       fetchSpinner.start();
       const link = ticket.link;
-      const issueR = Result3.try(() => fetchIssueFromUrl(link));
+      const issueR = Result4.try(() => fetchIssueFromUrl(link));
       if (issueR.ok && issueR.value) {
         issueContext = formatIssueContext(issueR.value);
         fetchSpinner.succeed(`Issue data fetched (${String(issueR.value.comments.length)} comment(s))`);
@@ -907,7 +959,7 @@ async function sprintRefineCommand(args) {
         skipped++;
         continue;
       }
-      const parseR = Result3.try(() => parseRequirementsFile(contentR.value));
+      const parseR = Result4.try(() => parseRequirementsFile(contentR.value));
       if (!parseR.ok) {
         showError(`Failed to parse requirements file: ${parseR.error.message}`);
         log.newline();
@@ -1000,7 +1052,7 @@ ${text}`;
 import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { join as join5 } from "path";
 import { confirm as confirm3 } from "@inquirer/prompts";
-import { Result as Result4 } from "typescript-result";
+import { Result as Result5 } from "typescript-result";
 
 // src/store/task.ts
 async function getTasks(sprintId) {
@@ -1040,7 +1092,8 @@ async function addTask(input3, sprintId) {
       ticketId: input3.ticketId,
       blockedBy: input3.blockedBy ?? [],
       projectPath: input3.projectPath,
-      verified: false
+      verified: false,
+      evaluated: false
     };
     tasks.push(task);
     await saveTasks(tasks, id);
@@ -1100,6 +1153,12 @@ async function updateTask(taskId, updates, sprintId) {
     if (updates.verificationOutput !== void 0) {
       task.verificationOutput = updates.verificationOutput;
     }
+    if (updates.evaluated !== void 0) {
+      task.evaluated = updates.evaluated;
+    }
+    if (updates.evaluationOutput !== void 0) {
+      task.evaluationOutput = updates.evaluationOutput;
+    }
     await saveTasks(tasks, id);
     return task;
   });
@@ -1269,7 +1328,8 @@ function validateImportTasks(importTasks2, existingTasks, ticketIds) {
       }),
       projectPath: "/tmp",
       // Placeholder for validation only
-      verified: false
+      verified: false,
+      evaluated: false
     }))
   ];
   try {
@@ -1295,7 +1355,7 @@ async function selectProject(message = "Select project:") {
       default: true
     });
     if (create) {
-      const { projectAddCommand } = await import("./add-DVEYDCTR.mjs");
+      const { projectAddCommand } = await import("./add-TGJTRHIF.mjs");
       await projectAddCommand({ interactive: true });
       const updated = await listProjects();
       if (updated.length === 0) return null;
@@ -1368,7 +1428,7 @@ async function selectSprint(message = "Select sprint:", filter) {
       default: true
     });
     if (create) {
-      const { sprintCreateCommand } = await import("./create-MQ4OHZAX.mjs");
+      const { sprintCreateCommand } = await import("./create-DJHCP7LN.mjs");
       await sprintCreateCommand({ interactive: true });
       const updated = await listSprints();
       const refiltered = filter ? updated.filter((s) => filter.includes(s.status)) : updated;
@@ -1403,7 +1463,7 @@ async function selectTicket(message = "Select ticket:", filter) {
         default: true
       });
       if (create) {
-        const { ticketAddCommand } = await import("./add-7LBVENXM.mjs");
+        const { ticketAddCommand } = await import("./add-SEDQ3VK7.mjs");
         await ticketAddCommand({ interactive: true });
         const updated = await listTickets();
         const refiltered = filter ? updated.filter(filter) : updated;
@@ -1491,6 +1551,12 @@ function parsePlanningBlocked(output) {
   const match = /<planning-blocked>([\s\S]*?)<\/planning-blocked>/.exec(output);
   return match?.[1]?.trim() ?? null;
 }
+function buildHeadlessAiRequest(repoPaths, prompt) {
+  return {
+    args: repoPaths.flatMap((path) => ["--add-dir", path]),
+    prompt
+  };
+}
 function parseTasksJson(output) {
   const jsonStr = extractJsonArray(output);
   let parsed;
@@ -1598,6 +1664,7 @@ async function importTasksReplace(tasks, sprintId) {
       blockedBy: [],
       // Set in second pass
       projectPath: taskInput.projectPath,
+      evaluated: false,
       verified: false
     });
     log.itemSuccess(`${realId}: ${taskInput.name}`);
@@ -1694,7 +1761,7 @@ async function invokeAiInteractive(prompt, repoPaths, planDir) {
   const provider = await getActiveProvider();
   const ticketCount = (prompt.match(/^####/gm) ?? []).length;
   const startPrompt = `I need help planning tasks for a sprint. The full planning context is in planning-context.md (${String(ticketCount)} tickets). Please read that file now and follow the instructions to help me plan implementation tasks.`;
-  const args = ["--add-dir", ...repoPaths];
+  const args = repoPaths.flatMap((path) => ["--add-dir", path]);
   const result = spawnInteractive(
     startPrompt,
     {
@@ -1710,15 +1777,12 @@ async function invokeAiInteractive(prompt, repoPaths, planDir) {
 }
 async function invokeAiAuto(prompt, repoPaths, planDir) {
   const provider = await getActiveProvider();
-  const args = ["--permission-mode", "plan", "--print"];
-  for (const path of repoPaths) {
-    args.push("--add-dir", path);
-  }
-  args.push("-p", prompt);
+  const request = buildHeadlessAiRequest(repoPaths, prompt);
   return spawnHeadless(
     {
       cwd: planDir,
-      args,
+      args: request.args,
+      prompt: request.prompt,
       env: provider.getSpawnEnv()
     },
     provider
@@ -1881,7 +1945,7 @@ async function sprintPlanCommand(args) {
       return;
     }
     console.log(muted("Parsing response..."));
-    const parsedR = Result4.try(() => parseTasksJson(output));
+    const parsedR = Result5.try(() => parseTasksJson(output));
     if (!parsedR.ok) {
       showError(`Failed to parse ${providerName} output: ${parsedR.error.message}`);
       log.dim("Raw output:");
@@ -1946,7 +2010,7 @@ async function sprintPlanCommand(args) {
         log.newline();
         return;
       }
-      const parsedR = Result4.try(() => parseTasksJson(contentR.value));
+      const parsedR = Result5.try(() => parseTasksJson(contentR.value));
       if (!parsedR.ok) {
         showError(`Failed to parse task file: ${parsedR.error.message}`);
         log.newline();
@@ -1989,11 +2053,11 @@ async function sprintPlanCommand(args) {
 }
 
 // src/commands/sprint/start.ts
-import { Result as Result8 } from "typescript-result";
+import { Result as Result9 } from "typescript-result";
 
 // src/ai/runner.ts
 import { confirm as confirm5, input as input2, select as select2 } from "@inquirer/prompts";
-import { Result as Result7 } from "typescript-result";
+import { Result as Result8 } from "typescript-result";
 
 // src/ai/executor.ts
 import { confirm as confirm4 } from "@inquirer/prompts";
@@ -2095,13 +2159,13 @@ var RateLimitCoordinator = class {
 import { execSync } from "child_process";
 import { writeFile as writeFile4 } from "fs/promises";
 import { join as join7 } from "path";
-import { Result as Result6 } from "typescript-result";
+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 { homedir } from "os";
-import { Result as Result5 } from "typescript-result";
+import { Result as Result6 } from "typescript-result";
 function getProviderPermissions(projectPath, provider) {
   const permissions = {
     allow: [],
@@ -2112,7 +2176,7 @@ function getProviderPermissions(projectPath, provider) {
   }
   const projectSettingsPath = join6(projectPath, ".claude", "settings.local.json");
   if (existsSync2(projectSettingsPath)) {
-    const projectResult = Result5.try(() => {
+    const projectResult = Result6.try(() => {
       const content = readFileSync2(projectSettingsPath, "utf-8");
       return JSON.parse(content);
     });
@@ -2128,7 +2192,7 @@ function getProviderPermissions(projectPath, provider) {
   }
   const userSettingsPath = join6(homedir(), ".claude", "settings.json");
   if (existsSync2(userSettingsPath)) {
-    const userResult = Result5.try(() => {
+    const userResult = Result6.try(() => {
       const content = readFileSync2(userSettingsPath, "utf-8");
       return JSON.parse(content);
     });
@@ -2185,6 +2249,9 @@ function matchesPattern(pattern, tool, specifier) {
 }
 function checkTaskPermissions(projectPath, options) {
   const warnings = [];
+  if (options.provider === "copilot") {
+    return warnings;
+  }
   const permissions = getProviderPermissions(projectPath, options.provider);
   if (options.needsCommit !== false) {
     const commitAllowed = isToolAllowed(permissions, "Bash", "git commit");
@@ -2211,7 +2278,7 @@ function checkTaskPermissions(projectPath, options) {
 
 // src/ai/task-context.ts
 function getRecentGitHistory(projectPath, count = 20) {
-  const r = Result6.try(() => {
+  const r = Result7.try(() => {
     assertSafeCwd(projectPath);
     const result = execSync(`git log -${String(count)} --oneline --no-decorate`, {
       cwd: projectPath,
@@ -2279,7 +2346,8 @@ function buildFullTaskContext(ctx, progressSummary, gitHistory, checkScript, che
     lines.push("");
     lines.push("Your task is NOT marked done unless this command passes after completion.");
   } else {
-    lines.push("No check script is configured. Read CLAUDE.md in the project root to find verification commands.");
+    lines.push("No check script is configured. Check the project root for instruction files");
+    lines.push("(CLAUDE.md, .github/copilot-instructions.md, README) to find verification commands.");
   }
   if (checkStatus) {
     lines.push("");
@@ -2290,7 +2358,7 @@ function buildFullTaskContext(ctx, progressSummary, gitHistory, checkScript, che
       lines.push("Do not re-run the install portion unless you encounter dependency errors.");
     } else {
       lines.push(
-        "No check script is configured for this repository. Read CLAUDE.md or project configuration files (package.json, pyproject.toml, etc.) to discover build, test, and lint commands."
+        "No check script is configured for this repository. Check project instruction files (CLAUDE.md, .github/copilot-instructions.md, README) or configuration files (package.json, pyproject.toml, etc.) to discover build, test, and lint commands."
       );
     }
   }
@@ -2381,9 +2449,9 @@ function getHookTimeoutMs() {
   }
   return DEFAULT_HOOK_TIMEOUT_MS;
 }
-function runLifecycleHook(projectPath, script, event) {
+function runLifecycleHook(projectPath, script, event, timeoutOverrideMs) {
   assertSafeCwd(projectPath);
-  const timeoutMs = getHookTimeoutMs();
+  const timeoutMs = timeoutOverrideMs ?? getHookTimeoutMs();
   const result = spawnSync2(script, {
     cwd: projectPath,
     shell: true,
@@ -2396,7 +2464,81 @@ function runLifecycleHook(projectPath, script, event) {
   return { passed: result.status === 0, output };
 }
 
+// src/ai/evaluator.ts
+function getEvaluatorModel(generatorModel, provider) {
+  if (provider.name !== "claude" || !generatorModel) return null;
+  const modelLower = generatorModel.toLowerCase();
+  if (modelLower.includes("opus")) return "claude-sonnet-4-6";
+  if (modelLower.includes("sonnet")) return "claude-haiku-4-5";
+  return "claude-haiku-4-5";
+}
+function parseEvaluationResult(output) {
+  if (output.includes("<evaluation-passed>")) {
+    return { passed: true, output };
+  }
+  const failedMatch = /<evaluation-failed>([\s\S]*?)<\/evaluation-failed>/.exec(output);
+  if (failedMatch) {
+    return { passed: false, output: failedMatch[1]?.trim() ?? output };
+  }
+  return { passed: false, output };
+}
+function buildEvaluatorContext(task, checkScript) {
+  const checkScriptSection = checkScript ? `## Check Script
+
+You can run the following check script to verify the changes:
+
+\`\`\`
+${checkScript}
+\`\`\`
+
+Run it to gain additional insight into whether the implementation is correct.` : null;
+  return {
+    taskName: task.name,
+    taskDescription: task.description ?? "",
+    taskSteps: task.steps,
+    projectPath: task.projectPath,
+    checkScriptSection
+  };
+}
+async function runEvaluation(task, generatorModel, checkScript, sprintId, provider) {
+  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()
+  });
+  return parseEvaluationResult(result.stdout);
+}
+
 // src/ai/executor.ts
+function buildProviderArgs(options, provider) {
+  if (provider.name !== "claude") {
+    if (options.maxBudgetUsd != null) {
+      console.log(warning(`--max-budget-usd is only supported with the Claude provider \u2014 ignored`));
+    }
+    if (options.fallbackModel) {
+      console.log(warning(`--fallback-model is only supported with the Claude provider \u2014 ignored`));
+    }
+    return [];
+  }
+  const args = [];
+  if (options.maxBudgetUsd != null) {
+    args.push("--max-budget-usd", String(options.maxBudgetUsd));
+  }
+  if (options.fallbackModel) {
+    args.push("--fallback-model", options.fallbackModel);
+  }
+  return args;
+}
 async function executeTask(ctx, options, sprintId, resumeSessionId, provider, checkStatus) {
   const p = provider ?? await getActiveProvider();
   const label = p.displayName;
@@ -2417,21 +2559,23 @@ async function executeTask(ctx, options, sprintId, resumeSessionId, provider, ch
         `Read ${contextFileName} and follow the instructions`,
         {
           cwd: projectPath,
-          args: ["--add-dir", sprintDir]
+          args: ["--add-dir", sprintDir],
+          env: p.getSpawnEnv()
         },
         p
       );
       if (result.error) {
-        return { success: false, output: "", blockedReason: result.error, sessionId: null };
+        return { success: false, output: "", blockedReason: result.error, sessionId: null, model: null };
       }
       if (result.code === 0) {
-        return { success: true, output: "", verified: true, sessionId: null };
+        return { success: true, output: "", verified: true, sessionId: null, model: null };
       }
       return {
         success: false,
         output: "",
         blockedReason: `${label} exited with code ${String(result.code)}`,
-        sessionId: null
+        sessionId: null,
+        model: null
       };
     } finally {
       await unlink2(contextFile).catch(() => void 0);
@@ -2448,9 +2592,10 @@ async function executeTask(ctx, options, sprintId, resumeSessionId, provider, ch
       spawnResult = await spawnWithRetry(
         {
           cwd: projectPath,
-          args: ["--add-dir", sprintDir],
+          args: ["--add-dir", sprintDir, ...buildProviderArgs(options, p)],
           prompt: "Continue where you left off. Complete the task and signal completion.",
-          resumeSessionId
+          resumeSessionId,
+          env: p.getSpawnEnv()
         },
         {
           maxRetries: options.maxRetries,
@@ -2487,8 +2632,9 @@ async function executeTask(ctx, options, sprintId, resumeSessionId, provider, ch
       spawnResult = await spawnWithRetry(
         {
           cwd: projectPath,
-          args: ["--add-dir", sprintDir],
-          prompt: contextContent
+          args: ["--add-dir", sprintDir, ...buildProviderArgs(options, p)],
+          prompt: contextContent,
+          env: p.getSpawnEnv()
         },
         {
           maxRetries: options.maxRetries,
@@ -2508,7 +2654,81 @@ async function executeTask(ctx, options, sprintId, resumeSessionId, provider, ch
     }
   }
   const parsed = parseExecutionResult(spawnResult.stdout);
-  return { ...parsed, sessionId: spawnResult.sessionId };
+  return { ...parsed, sessionId: spawnResult.sessionId, model: spawnResult.model };
+}
+var MAX_EVAL_OUTPUT = 2e3;
+async function runEvaluationLoop(params) {
+  const {
+    task,
+    result,
+    project,
+    sprintId,
+    provider,
+    options,
+    evalIterations,
+    checkTimeout,
+    useSpinner = false
+  } = params;
+  const evalCheckScript = getEffectiveCheckScript(project, task.projectPath);
+  const sprintDir = getSprintDir(sprintId);
+  let evalResult = await runEvaluation(task, result.model, evalCheckScript, sprintId, provider);
+  for (let i = 0; i < evalIterations && !evalResult.passed; i++) {
+    console.log(warning(`Evaluation failed for ${task.name} (iteration ${String(i + 1)}/${String(evalIterations)})`));
+    console.log(muted(evalResult.output.slice(0, 500)));
+    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 work:
+
+${evalResult.output}
+
+Fix these issues, then verify${options.noCommit ? "" : ", commit your fix,"} and signal completion.`,
+        resumeSessionId: result.sessionId ?? void 0,
+        env: provider.getSpawnEnv()
+      },
+      {
+        maxRetries: options.maxRetries,
+        ...resumeSpinner ? {
+          onRetry: (attempt, delayMs) => {
+            resumeSpinner.text = `Rate limited, retrying in ${String(Math.round(delayMs / 1e3))}s (attempt ${String(attempt)})...`;
+          }
+        } : {}
+      },
+      provider
+    );
+    resumeSpinner?.succeed(`Fix attempt completed: ${task.name}`);
+    const fixResult = parseExecutionResult(resumeResult.stdout);
+    if (!fixResult.success) {
+      console.log(warning(`Generator could not fix issues after feedback: ${task.name}`));
+      break;
+    }
+    const recheckScript = getEffectiveCheckScript(project, task.projectPath);
+    if (recheckScript) {
+      const recheckResult = runLifecycleHook(task.projectPath, recheckScript, "taskComplete", checkTimeout);
+      if (!recheckResult.passed) {
+        console.log(warning(`Post-task check failed after generator fix: ${task.name}`));
+        break;
+      }
+    }
+    evalResult = await runEvaluation(task, resumeResult.model ?? result.model, evalCheckScript, sprintId, provider);
+  }
+  await updateTask(
+    task.id,
+    {
+      evaluated: true,
+      evaluationOutput: evalResult.output.slice(0, MAX_EVAL_OUTPUT)
+    },
+    sprintId
+  );
+  if (!evalResult.passed) {
+    console.log(
+      warning(`Evaluation did not pass after ${String(evalIterations)} iteration(s) \u2014 marking done: ${task.name}`)
+    );
+  } else {
+    console.log(success(`Evaluation passed: ${task.name}`));
+  }
 }
 async function areAllRemainingBlocked(sprintId) {
   const remaining = await getRemainingTasks(sprintId);
@@ -2524,6 +2744,7 @@ async function executeTaskLoop(sprintId, options, checkResults) {
   ProcessManager.getInstance().ensureHandlers();
   const provider = await getActiveProvider();
   const label = provider.displayName;
+  const evalIterations = await getEvaluationIterations();
   const sprint = await getSprint(sprintId);
   let completedCount = 0;
   const targetCount = options.count ?? Infinity;
@@ -2674,6 +2895,18 @@ Post-task check failed for: ${task.name}`));
       }
       console.log(success("Post-task check: passed"));
     }
+    if (evalIterations > 0 && !options.noEvaluate && !options.session) {
+      await runEvaluationLoop({
+        task,
+        result,
+        project,
+        sprintId,
+        provider,
+        options,
+        evalIterations,
+        useSpinner: true
+      });
+    }
     await updateTaskStatus(task.id, "done", sprintId);
     console.log(success("Status updated to: done"));
     await logProgress(
@@ -2720,8 +2953,10 @@ ${String(remaining2.length)} task(s) remaining.`));
     exitCode: EXIT_SUCCESS
   };
 }
-function pickTasksToLaunch(readyTasks, inFlightPaths, concurrencyLimit, currentInFlight) {
-  const available = readyTasks.filter((t) => !inFlightPaths.has(t.projectPath));
+function pickTasksToLaunch(readyTasks, inFlightPaths, concurrencyLimit, currentInFlight, failedPaths) {
+  const available = readyTasks.filter(
+    (t) => !inFlightPaths.has(t.projectPath) && !(failedPaths?.has(t.projectPath) ?? false)
+  );
   const byPath = /* @__PURE__ */ new Map();
   for (const task of available) {
     if (!byPath.has(task.projectPath)) {
@@ -2736,6 +2971,7 @@ async function executeTaskLoopParallel(sprintId, options, checkResults) {
   ProcessManager.getInstance().ensureHandlers();
   const provider = await getActiveProvider();
   const label = provider.displayName;
+  const evalIterations = await getEvaluationIterations();
   const sprint = await getSprint(sprintId);
   let completedCount = 0;
   const targetCount = options.count ?? Infinity;
@@ -2761,6 +2997,7 @@ Rate limited. Pausing new launches for ${String(Math.round(delayMs / 1e3))}s...`
   const running = /* @__PURE__ */ new Map();
   const taskSessionIds = /* @__PURE__ */ new Map();
   const branchRetries = /* @__PURE__ */ new Map();
+  const failedPaths = /* @__PURE__ */ new Set();
   const MAX_BRANCH_RETRIES = 3;
   let permissionCheckDone = false;
   try {
@@ -2805,17 +3042,22 @@ Resuming ${String(inProgressTasks.length)} in-progress task(s):`));
             exitCode: EXIT_SUCCESS
           };
         }
+        const hasFailures = hasFailed || failedPaths.size > 0;
+        if (failedPaths.size > 0) {
+          console.log(warning(`
+Repos with failed checks: ${[...failedPaths].join(", ")}`));
+        }
         return {
           completed: completedCount,
           remaining: remaining.length,
-          stopReason: hasFailed ? "task_blocked" : "all_blocked",
+          stopReason: hasFailures ? "task_blocked" : "all_blocked",
           blockedTask: firstBlockedTask,
           blockedReason: firstBlockedReason ?? "All remaining tasks are blocked by dependencies",
-          exitCode: hasFailed ? EXIT_ERROR : EXIT_ALL_BLOCKED
+          exitCode: hasFailures ? EXIT_ERROR : EXIT_ALL_BLOCKED
         };
       }
       if (!hasFailed || !failFast) {
-        const toStart = pickTasksToLaunch(launchCandidates, inFlightPaths, concurrencyLimit, running.size);
+        const toStart = pickTasksToLaunch(launchCandidates, inFlightPaths, concurrencyLimit, running.size, failedPaths);
         for (const task of toStart) {
           if (completedCount + running.size >= targetCount) break;
           const project = await getProjectForTask(task, sprint);
@@ -2965,23 +3207,39 @@ Task not completed: ${settled.task.name}`));
         const taskProject = await getProjectForTask(settled.task, sprint);
         const taskCheckScript = getEffectiveCheckScript(taskProject, settled.task.projectPath);
         if (taskCheckScript) {
-          const hookResult = runLifecycleHook(settled.task.projectPath, taskCheckScript, "taskComplete");
+          const taskRepo = taskProject?.repositories.find((r) => r.path === settled.task.projectPath);
+          const hookResult = runLifecycleHook(
+            settled.task.projectPath,
+            taskCheckScript,
+            "taskComplete",
+            taskRepo?.checkTimeout
+          );
           if (!hookResult.passed) {
             console.log(warning(`
 Post-task check failed for: ${settled.task.name}`));
-            console.log(muted(`Task ${settled.task.id} remains in_progress.`));
-            hasFailed = true;
+            console.log(muted(`Task ${settled.task.id} remains in_progress. Repo ${settled.task.projectPath} paused.`));
+            failedPaths.add(settled.task.projectPath);
             if (!firstBlockedTask) {
               firstBlockedTask = settled.task;
               firstBlockedReason = `Post-task check failed: ${hookResult.output.slice(0, 500)}`;
             }
-            if (failFast) {
-              console.log(muted("Fail-fast: waiting for running tasks to finish..."));
-            }
             continue;
           }
           console.log(success(`Post-task check passed: ${settled.task.name}`));
         }
+        if (evalIterations > 0 && !options.noEvaluate && !options.session) {
+          const taskRepo = taskProject?.repositories.find((r) => r.path === settled.task.projectPath);
+          await runEvaluationLoop({
+            task: settled.task,
+            result: settled.result,
+            project: taskProject,
+            sprintId,
+            provider,
+            options,
+            evalIterations,
+            checkTimeout: taskRepo?.checkTimeout
+          });
+        }
         await updateTaskStatus(settled.task.id, "done", sprintId);
         console.log(success(`Completed: ${settled.task.name}`));
         taskSessionIds.delete(settled.task.id);
@@ -3012,7 +3270,13 @@ Waiting for ${String(running.size)} remaining task(s)...`));
           const drainProject = await getProjectForTask(r.value.task, sprint);
           const drainCheckScript = getEffectiveCheckScript(drainProject, r.value.task.projectPath);
           if (drainCheckScript) {
-            const hookResult = runLifecycleHook(r.value.task.projectPath, drainCheckScript, "taskComplete");
+            const drainRepo = drainProject?.repositories.find((repo) => repo.path === r.value.task.projectPath);
+            const hookResult = runLifecycleHook(
+              r.value.task.projectPath,
+              drainCheckScript,
+              "taskComplete",
+              drainRepo?.checkTimeout
+            );
             if (!hookResult.passed) {
               console.log(warning(`Post-task check failed for: ${r.value.task.name}`));
               continue;
@@ -3220,7 +3484,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 = Result7.try(() => hasUncommittedChanges(projectPath));
+    const uncommittedR = Result8.try(() => hasUncommittedChanges(projectPath));
     if (!uncommittedR.ok) {
       log.dim(`  Skipping ${projectPath} \u2014 not a git repository`);
       continue;
@@ -3232,7 +3496,7 @@ async function ensureSprintBranches(sprintId, sprint, branchName) {
     }
   }
   for (const projectPath of uniquePaths) {
-    const branchR = Result7.try(() => {
+    const branchR = Result8.try(() => {
       const currentBranch = getCurrentBranch(projectPath);
       if (currentBranch === branchName) {
         log.dim(`  Already on branch '${branchName}' in ${projectPath}`);
@@ -3253,7 +3517,7 @@ async function ensureSprintBranches(sprintId, sprint, branchName) {
   }
 }
 function verifySprintBranch(projectPath, expectedBranch) {
-  const r = Result7.try(() => {
+  const r = Result8.try(() => {
     if (verifyCurrentBranch(projectPath, expectedBranch)) return true;
     log.dim(`  Branch mismatch in ${projectPath} \u2014 checking out '${expectedBranch}'`);
     createAndCheckoutBranch(projectPath, expectedBranch);
@@ -3289,7 +3553,7 @@ async function runCheckScripts(sprintId, sprint, refreshCheck = false) {
     }
     log.info(`
 Running check for ${repoName}: ${checkScript}`);
-    const hookResult = runLifecycleHook(projectPath, checkScript, "sprintStart");
+    const hookResult = runLifecycleHook(projectPath, checkScript, "sprintStart", repo?.checkTimeout);
     if (!hookResult.passed) {
       return {
         success: false,
@@ -3514,6 +3778,27 @@ function parseArgs3(args) {
         throw new Error("--branch-name requires a value");
       }
       options.branchName = nameStr;
+    } else if (arg === "--max-budget-usd") {
+      const budgetStr = args[++i];
+      if (!budgetStr) {
+        throw new Error("--max-budget-usd requires a number");
+      }
+      const budget = parseFloat(budgetStr);
+      if (isNaN(budget) || budget <= 0) {
+        throw new Error("--max-budget-usd must be a positive number");
+      }
+      options.maxBudgetUsd = budget;
+    } else if (arg === "--fallback-model") {
+      const modelStr = args[++i];
+      if (!modelStr) {
+        throw new Error("--fallback-model requires a model name");
+      }
+      if (!/^[a-zA-Z0-9._-]{1,100}$/.test(modelStr)) {
+        throw new Error("Invalid model name \u2014 must be 1-100 alphanumeric characters, dots, hyphens, or underscores");
+      }
+      options.fallbackModel = modelStr;
+    } else if (arg === "--no-evaluate") {
+      options.noEvaluate = true;
     } else if (!arg?.startsWith("-")) {
       sprintId = arg;
     }
@@ -3521,7 +3806,7 @@ function parseArgs3(args) {
   return { sprintId, options };
 }
 async function sprintStartCommand(args) {
-  const parseR = Result8.try(() => parseArgs3(args));
+  const parseR = Result9.try(() => parseArgs3(args));
   if (!parseR.ok) {
     showError(parseR.error.message);
     log.newline();
@@ -3566,6 +3851,7 @@ export {
   reorderTask,
   listTasks,
   areAllTasksDone,
+  reorderByDependencies,
   validateImportTasks,
   selectProject,
   selectProjectRepository,
@@ -3584,6 +3870,7 @@ export {
   getActiveProvider,
   spawnInteractive,
   spawnHeadless,
+  extractJsonArray,
   extractJsonObject,
   formatTicketForPrompt,
   parseRequirementsFile,
@@ -3591,6 +3878,7 @@ export {
   sprintRefineCommand,
   getTaskImportSchema,
   parsePlanningBlocked,
+  buildHeadlessAiRequest,
   parseTasksJson,
   renderParsedTasksTable,
   importTasks,