ralphctl 0.4.5 → 0.5.0

package/dist/{add-YVXM34RP.mjs → add-67UFUI54.mjs}

@@ -2,8 +2,8 @@
 import {
   addCheckScriptToRepository,
   projectAddCommand
-} from "./chunk-PYZEQ2VK.mjs";
-import "./chunk-ZLWSPLWI.mjs";
+} from "./chunk-BT5FKIZX.mjs";
+import "./chunk-62HYDA7L.mjs";
 import "./chunk-CFUVE2BP.mjs";
 import "./chunk-747KW2RW.mjs";
 import "./chunk-BSB4EDGR.mjs";

package/dist/{chunk-ZLWSPLWI.mjs → chunk-62HYDA7L.mjs}

@@ -1091,6 +1091,16 @@ ${ctx.existingAgentsMd}
     FILE_NAME: ctx.fileName
   });
 }
+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
+  });
+}
 
 export {
   buildInteractivePrompt,
@@ -1103,6 +1113,7 @@ export {
   buildSprintFeedbackPrompt,
   buildCheckScriptDiscoverPrompt,
   buildRepoOnboardPrompt,
+  buildEvaluationResumePrompt,
   processLifecycleAdapter,
   resolveProvider,
   providerDisplayName,

package/dist/{chunk-PYZEQ2VK.mjs → chunk-BT5FKIZX.mjs}

@@ -3,7 +3,7 @@ import {
   ProviderAiSessionAdapter,
   SignalParser,
   buildCheckScriptDiscoverPrompt
-} from "./chunk-ZLWSPLWI.mjs";
+} from "./chunk-62HYDA7L.mjs";
 import {
   EXIT_ERROR,
   exitWithCode

package/dist/{chunk-OFILN7QL.mjs → chunk-D6QZNEYN.mjs}

@@ -3,6 +3,7 @@ import {
   ProviderAiSessionAdapter,
   SignalParser,
   buildAutoPrompt,
+  buildEvaluationResumePrompt,
   buildEvaluatorPrompt,
   buildIdeateAutoPrompt,
   buildIdeatePrompt,
@@ -13,7 +14,7 @@ import {
   buildTicketRefinePrompt,
   getActiveProvider,
   spawnInteractive
-} from "./chunk-ZLWSPLWI.mjs";
+} from "./chunk-62HYDA7L.mjs";
 import {
   fetchIssueFromUrl,
   formatIssueContext,
@@ -1626,6 +1627,14 @@ function resolveCheckScriptForRepo(repo) {
 }
 
 // src/business/pipelines/steps/run-check-scripts.ts
+var ERROR_OUTPUT_TAIL_LINES = 100;
+function tailOutput(output, maxLines = ERROR_OUTPUT_TAIL_LINES) {
+  const lines = output.split("\n");
+  if (lines.length <= maxLines) return output;
+  const hidden = lines.length - maxLines;
+  return `[${String(hidden)} earlier line${hidden !== 1 ? "s" : ""} omitted]
+${lines.slice(-maxLines).join("\n")}`;
+}
 function runCheckScriptsStep(external, persistence, mode, options) {
   return step("run-check-scripts", async (ctx) => {
     const sprint = ctx.sprint;
@@ -1646,15 +1655,17 @@ function runCheckScriptsStep(external, persistence, mode, options) {
           const checkScript = resolveCheckScriptForRepo(resolved?.repo);
           if (!resolved || !checkScript) continue;
           const { repo } = resolved;
-          const result = external.runCheckScript(repo.path, checkScript, "sprintStart", repo.checkTimeout);
+          const result = await external.runCheckScript(repo.path, checkScript, "sprintStart", repo.checkTimeout);
           if (!result.passed) {
             checkResults[repoId] = {
               projectPath: repo.path,
               success: false,
               output: result.output
             };
-            return Result.error(new StorageError(`Check failed for ${repo.path}: ${checkScript}
-${result.output}`));
+            return Result.error(
+              new StorageError(`Check failed for ${repo.path}: ${checkScript}
+${tailOutput(result.output)}`)
+            );
           }
           const ranAt = (/* @__PURE__ */ new Date()).toISOString();
           sprint.checkRanAt[repoId] = ranAt;
@@ -1680,7 +1691,7 @@ ${result.output}`));
           return Result.ok(partial2);
         }
         const { repo } = resolved;
-        const result = external.runCheckScript(repo.path, checkScript, "taskComplete", repo.checkTimeout);
+        const result = await external.runCheckScript(repo.path, checkScript, "taskComplete", repo.checkTimeout);
         checkResults[targetRepoId] = {
           projectPath: repo.path,
           success: result.passed,
@@ -1689,7 +1700,7 @@ ${result.output}`));
         if (!result.passed) {
           return Result.error(
             new StorageError(`Post-task check failed for ${repo.path}: ${checkScript}
-${result.output}`)
+${tailOutput(result.output)}`)
           );
         }
       }
@@ -1892,7 +1903,7 @@ ${instructions}`;
     if (!resolved || !checkScript) return true;
     this.logger.info(`Running post-task check: ${checkScript}`);
     const { repo } = resolved;
-    const result = this.external.runCheckScript(repo.path, checkScript, "taskComplete", repo.checkTimeout);
+    const result = await this.external.runCheckScript(repo.path, checkScript, "taskComplete", repo.checkTimeout);
     if (result.passed) {
       this.logger.success("Post-task check: passed");
     }
@@ -2478,10 +2489,9 @@ var EvaluateTaskUseCase = class {
           options
         );
         if (!fixSuccess) {
-          const reason = "Generator could not fix issues after feedback";
-          await this.persistEvaluationStub(sprintId, taskId, i + 2, reason);
-          break;
+          log2.debug(`Fix attempt ${String(i + 1)}: generator did not signal completion \u2014 re-evaluating anyway`);
         }
+        if (i === maxIterations - 1) break;
         const previousEvalResult = evalResult;
         const stopReeval = log2.time("evaluator-re-spawn");
         evalResult = await this.runSingleEvaluation(
@@ -2505,7 +2515,7 @@ var EvaluateTaskUseCase = class {
       }
       const finalStatus = plateaued ? "plateau" : evalResult.status;
       await this.updateTaskEvaluation(sprintId, taskId, evalResult, finalStatus);
-      this.reportResult(task.name, evalResult, maxIterations, plateaued);
+      this.reportResult(task.name, evalResult, totalIterations, plateaued);
       return Result.ok({
         taskId,
         status: finalStatus,
@@ -2549,47 +2559,47 @@ var EvaluateTaskUseCase = class {
     }
   }
   /**
-   * Spawn a single evaluator session and parse the result.
-   *
-   * `checkScriptSection` and `projectToolingSection` are passed in
-   * pre-resolved — both are stable across fix-loop iterations, so the
-   * caller computes them once and threads them through.
+   * Spawn a single evaluator session and parse the result. Stable inputs
+   * (`checkScriptSection`, `projectToolingSection`) are passed in
+   * pre-resolved so the fix loop doesn't re-compute them per iteration.
    */
   async runSingleEvaluation(task, sprint, repoPath, generatorModel, provider, checkScriptSection, projectToolingSection, options) {
     const evaluatorModel = getEvaluatorModel(generatorModel, provider);
-    const sprintDir = this.fs.getSprintDir(sprint.id);
     const prompt = this.promptBuilder.buildTaskEvaluationPrompt(
       task,
       repoPath,
       checkScriptSection,
       projectToolingSection
     );
-    const args = ["--add-dir", sprintDir];
+    const args = ["--add-dir", this.fs.getSprintDir(sprint.id)];
     if (provider === "claude") {
-      if (evaluatorModel) {
-        args.push("--model", evaluatorModel);
-      }
+      if (evaluatorModel) args.push("--model", evaluatorModel);
       args.push("--max-turns", String(options?.maxTurns ?? EVALUATOR_MAX_TURNS));
     }
-    let result;
+    const result = await this.spawnOrNull(prompt, {
+      cwd: repoPath,
+      args,
+      env: this.aiSession.getSpawnEnv(),
+      abortSignal: options?.abortSignal
+    });
+    if (!result.ok) {
+      this.logger.warning(`Evaluator spawn failed for ${task.name}: ${result.message} \u2014 marking malformed`);
+      return { status: "malformed", dimensions: [], rawOutput: `Evaluator spawn failed: ${result.message}` };
+    }
+    return this.parser.parseEvaluation(result.value.output);
+  }
+  /**
+   * Wrap `spawnWithRetry` in a try/catch so callers can handle spawn
+   * failures without nested error handling. Returns a small discriminated
+   * union — ok with the session result, or !ok with the message.
+   */
+  async spawnOrNull(prompt, opts) {
     try {
-      result = await this.aiSession.spawnWithRetry(prompt, {
-        cwd: repoPath,
-        args,
-        env: this.aiSession.getSpawnEnv(),
-        abortSignal: options?.abortSignal
-      });
+      const value = await this.aiSession.spawnWithRetry(prompt, opts);
+      return { ok: true, value };
     } catch (err) {
-      this.logger.warning(
-        `Evaluator spawn failed for ${task.name}: ${err instanceof Error ? err.message : String(err)} \u2014 marking malformed`
-      );
-      return {
-        status: "malformed",
-        dimensions: [],
-        rawOutput: `Evaluator spawn failed: ${err instanceof Error ? err.message : String(err)}`
-      };
+      return { ok: false, message: err instanceof Error ? err.message : String(err) };
     }
-    return this.parser.parseEvaluation(result.output);
   }
   /**
    * Resolve the repo's `checkScript` and render it as the evaluator's
@@ -2618,33 +2628,39 @@ var EvaluateTaskUseCase = class {
   }
   /**
    * Resume the generator session with the evaluator critique.
-   * Returns true if the generator signaled completion.
+   *
+   * Two load-bearing properties (covered by `fix-loop fence` tests):
+   *   1. Prompt comes from `buildTaskEvaluationResumePrompt` — full template
+   *      with signals / fix-protocol / commit instruction. A regression to
+   *      an inline string silently drops signal requirements.
+   *   2. When `options.generatorSessionId` is set, `resumeSessionId` is
+   *      threaded so the fix continues the original session (`--resume`).
+   *      Absent an ID, spawn fresh and log at debug.
+   *
+   * Returns true iff the generator signaled `<task-complete>` — used as a
+   * diagnostic only; the evaluator settles whether the fix actually worked.
    */
   async resumeGeneratorWithCritique(task, sprint, repoPath, critique, options) {
-    const sprintDir = this.fs.getSprintDir(sprint.id);
-    const resumePrompt = [
-      "The evaluator found issues with your implementation. Fix them and signal completion.",
-      "",
-      "## Evaluator Critique",
-      critique
-    ].join("\n");
-    let spinner = null;
-    try {
-      spinner = this.logger.spinner(`Fixing evaluation issues: ${task.name}`);
-      const result = await this.aiSession.spawnWithRetry(resumePrompt, {
-        cwd: repoPath,
-        args: ["--add-dir", sprintDir],
-        env: this.aiSession.getSpawnEnv(),
-        maxTurns: options?.maxTurns,
-        abortSignal: options?.abortSignal
-      });
-      spinner.succeed(`Fix attempt completed: ${task.name}`);
-      const signals = this.parser.parseExecutionSignals(result.output);
-      return signals.complete;
-    } catch {
-      spinner?.fail(`Fix attempt failed: ${task.name}`);
+    const resumePrompt = this.promptBuilder.buildTaskEvaluationResumePrompt(critique, options?.needsCommit ?? true);
+    const resumeSessionId = options?.generatorSessionId;
+    this.logger.debug(
+      resumeSessionId ? `Resuming generator session ${resumeSessionId} for fix attempt: ${task.name}` : `No generator session ID \u2014 spawning fresh fix attempt: ${task.name}`
+    );
+    const spinner = this.logger.spinner(`Fixing evaluation issues: ${task.name}`);
+    const result = await this.spawnOrNull(resumePrompt, {
+      cwd: repoPath,
+      args: ["--add-dir", this.fs.getSprintDir(sprint.id)],
+      env: this.aiSession.getSpawnEnv(),
+      maxTurns: options?.maxTurns,
+      resumeSessionId,
+      abortSignal: options?.abortSignal
+    });
+    if (!result.ok) {
+      spinner.fail(`Fix attempt failed: ${task.name}`);
       return false;
     }
+    spinner.succeed(`Fix attempt completed: ${task.name}`);
+    return this.parser.parseExecutionSignals(result.value.output).complete;
   }
   /**
    * Persist a real evaluation entry to the sidecar file.
@@ -2664,49 +2680,46 @@ var EvaluateTaskUseCase = class {
     }
   }
   /**
-   * Persist a stub entry when the fix loop bails early.
-   */
-  async persistEvaluationStub(sprintId, taskId, iteration, reason) {
-    try {
-      await this.persistence.writeEvaluation(sprintId, taskId, iteration, "failed", `_(no re-evaluation: ${reason})_`);
-    } catch {
-      this.logger.warning(`Could not persist evaluation stub for task ${taskId}`);
-    }
-  }
-  /**
-   * Update the task record with evaluation fields.
-   *
-   * `statusOverride` is set when plateau detection fires: the critique body
-   * is still saved (truncated) for traceability, but the discriminator in
-   * `tasks.json` records `'plateau'` so consumers can distinguish it from
-   * a plain `'failed'` run.
+   * Update the task record with evaluation fields. `statusOverride` is set
+   * for plateau — the body is still the real critique, but the status
+   * column records `'plateau'` so readers can distinguish it from a plain
+   * failure.
    */
   async updateTaskEvaluation(sprintId, taskId, evalResult, statusOverride) {
-    const status = statusOverride ?? evalResult.status;
-    const tasks = await this.persistence.getTasks(sprintId);
-    const updatedTasks = tasks.map(
-      (t) => t.id === taskId ? {
-        ...t,
+    await this.persistence.updateTask(
+      taskId,
+      {
         evaluated: true,
-        evaluationStatus: status,
+        evaluationStatus: statusOverride ?? evalResult.status,
         evaluationOutput: evalResult.rawOutput.slice(0, MAX_EVAL_OUTPUT)
-      } : t
+      },
+      sprintId
     );
-    await this.persistence.saveTasks(updatedTasks, sprintId);
   }
   /**
    * Report the evaluation outcome to the user.
+   *
+   * `totalIterations` is the *actual* number of evaluator spawns (initial +
+   * any re-evaluations after fix attempts), NOT the configured maximum.
+   * When the loop breaks early (plateau), runs out of fix budget, or skips
+   * the final re-eval, these two diverge — and the log line must reflect
+   * reality so "6 fix attempts" never shows up when only 1 actually ran.
+   *
+   * The evaluator is advisory: a failing outcome doesn't stop the task
+   * from being marked done; the sprint proceeds. The critique is persisted
+   * in the sidecar for later review, and the warning log lets the user
+   * see what didn't pass without scrolling the evaluations directory.
    */
-  reportResult(taskName, evalResult, maxIterations, plateaued) {
+  reportResult(taskName, evalResult, totalIterations, plateaued) {
     if (plateaued) {
       this.logger.warning(
-        `Evaluation plateaued on the same failures \u2014 further fix attempts were skipped. Marking done: ${taskName}`
+        `Evaluation plateaued on the same failures after ${String(totalIterations)} iteration(s): ${taskName}`
       );
     } else if (evalResult.status === "malformed") {
-      this.logger.warning(`Evaluator output was malformed for ${taskName} \u2014 marking done`);
+      this.logger.warning(`Evaluator output was malformed for ${taskName}`);
     } else if (!isPassed(evalResult)) {
       this.logger.warning(
-        `Evaluation did not pass after ${String(maxIterations)} fix attempt(s) \u2014 marking done: ${taskName}`
+        `Evaluation did not pass after ${String(totalIterations)} iteration(s) \u2014 marking done: ${taskName}`
       );
     } else {
       this.logger.success(`Evaluation passed: ${taskName}`);
@@ -2729,40 +2742,24 @@ function loadTaskStep(persistence) {
 function checkAlreadyEvaluatedStep(options) {
   return step("check-already-evaluated", (ctx) => {
     const task = ctx.tasks?.[0];
-    if (!task) {
-      const empty2 = {};
-      return Result.ok(empty2);
-    }
-    if (task.evaluated && !options.force) {
-      const summary = {
-        taskId: task.id,
-        status: "skipped",
-        iterations: 0
-      };
-      const partial = { evaluationSummary: summary };
-      return Result.ok(partial);
+    if (task && task.evaluated && !options.force) {
+      const summary = { taskId: task.id, status: "skipped", iterations: 0 };
+      return Result.ok({ evaluationSummary: summary });
     }
-    const empty = {};
-    return Result.ok(empty);
+    return Result.ok({});
   });
 }
 function runEvaluatorLoopStep(useCase, options) {
   return step("run-evaluator-loop", async (ctx) => {
     if (ctx.evaluationSummary?.status === "skipped") {
-      const empty = {};
-      return Result.ok(empty);
+      return Result.ok({});
     }
     const result = await useCase.execute(ctx.sprintId, ctx.taskId, {
-      iterations: options.iterations,
-      maxTurns: options.maxTurns,
-      fallbackModel: ctx.generatorModel ?? void 0,
+      ...options,
       abortSignal: ctx.abortSignal ?? options.abortSignal
     });
-    if (!result.ok) {
-      return Result.error(result.error);
-    }
-    const partial = { evaluationSummary: result.value };
-    return Result.ok(partial);
+    if (!result.ok) return Result.error(result.error);
+    return Result.ok({ evaluationSummary: result.value });
   });
 }
 function createEvaluatorPipeline(deps, options = {}) {
@@ -2788,10 +2785,7 @@ function createEvaluatorPipeline(deps, options = {}) {
 function evaluateTask(deps) {
   return step("evaluate-task", async (ctx) => {
     const evalCfg = await deps.useCase.getEvaluationConfig(deps.options);
-    if (!evalCfg.enabled) {
-      const empty = {};
-      return Result.ok(empty);
-    }
+    if (!evalCfg.enabled) return Result.ok({});
     const innerPipeline = createEvaluatorPipeline(
       {
         persistence: deps.persistence,
@@ -2806,38 +2800,52 @@ function evaluateTask(deps) {
       {
         iterations: evalCfg.iterations,
         maxTurns: deps.options.maxTurns,
+        // noCommit (ExecutionOptions) inverted — if the generator committed
+        // the initial work, the fix must commit too.
+        needsCommit: !deps.options.noCommit,
+        // Model ladder input: evaluator uses a cheaper model than the
+        // generator's. Null when the generator didn't report one (Copilot,
+        // blocked tasks).
+        fallbackModel: ctx.generatorModel ?? void 0,
+        // --resume <id> so the fix continues the generator's session
+        // rather than cold-starting. Undefined → fresh spawn (rare fallback).
+        generatorSessionId: ctx.executionResult?.sessionId,
         abortSignal: ctx.abortSignal
       }
     );
     const innerCtx = {
       sprintId: ctx.sprint.id,
       taskId: ctx.task.id,
-      generatorModel: ctx.generatorModel ?? null,
       abortSignal: ctx.abortSignal
     };
-    let stepNames = [];
     try {
-      const result = await executePipeline(innerPipeline, innerCtx);
-      stepNames = result.ok ? result.value.stepResults.map((r) => r.stepName) : (
-        // Even on failure the framework populates stepResults up to and
-        // including the failing step. Extract them opportunistically —
-        // if unavailable, proceed with an empty list.
-        []
-      );
-      if (!result.ok) {
+      const innerResult = await executePipeline(innerPipeline, innerCtx);
+      if (!innerResult.ok) {
         deps.logger.warning(
-          `Evaluation failed for ${ctx.task.name}: ${result.error.message}. Proceeding with task completion.`
+          `Evaluator pipeline errored for ${ctx.task.name}: ${innerResult.error.message} \u2014 proceeding with task completion`
         );
+        return Result.ok({ evaluationStepNames: [] });
       }
+      logIfNonTerminal(deps.logger, ctx.task.name, innerResult.value.context.evaluationSummary);
+      return Result.ok({
+        evaluationStepNames: innerResult.value.stepResults.map((r) => r.stepName)
+      });
     } catch (err) {
       deps.logger.warning(
-        `Evaluator threw for ${ctx.task.name}: ${err instanceof Error ? err.message : String(err)}. Proceeding with task completion.`
+        `Evaluator threw for ${ctx.task.name}: ${err instanceof Error ? err.message : String(err)} \u2014 proceeding with task completion`
       );
+      return Result.ok({ evaluationStepNames: [] });
     }
-    const partial = { evaluationStepNames: stepNames };
-    return Result.ok(partial);
   });
 }
+function logIfNonTerminal(logger, taskName, summary) {
+  if (!summary) return;
+  if (summary.status === "failed" || summary.status === "malformed" || summary.status === "plateau") {
+    logger.warning(
+      `Evaluation ${summary.status} for ${taskName} after ${String(summary.iterations)} iteration(s) \u2014 proceeding with task completion`
+    );
+  }
+}
 
 // src/business/pipelines/execute/steps/recover-dirty-tree.ts
 function recoverDirtyTree2(deps) {
@@ -4023,6 +4031,9 @@ var TextPromptBuilderAdapter = class {
       extraDimensions: task.extraDimensions ?? []
     });
   }
+  buildTaskEvaluationResumePrompt(critique, needsCommit) {
+    return buildEvaluationResumePrompt({ critique, needsCommit });
+  }
   buildFeedbackPrompt(sprintName, completedTasks, feedback, branch) {
     return buildSprintFeedbackPrompt(sprintName, completedTasks, feedback, branch);
   }
@@ -4608,8 +4619,9 @@ function describeMcpHint(name) {
 }
 
 // src/integration/external/lifecycle.ts
-import { spawnSync } from "child_process";
+import { spawn } from "child_process";
 var DEFAULT_HOOK_TIMEOUT_MS = 5 * 60 * 1e3;
+var MAX_OUTPUT_BYTES = 50 * 1024 * 1024;
 function getHookTimeoutMs() {
   const envVal = process.env["RALPHCTL_SETUP_TIMEOUT_MS"];
   if (envVal) {
@@ -4621,16 +4633,76 @@ function getHookTimeoutMs() {
 function runLifecycleHook(projectPath, script, event, timeoutOverrideMs) {
   assertSafeCwd(projectPath);
   const timeoutMs = timeoutOverrideMs ?? getHookTimeoutMs();
-  const result = spawnSync(script, {
-    cwd: projectPath,
-    shell: true,
-    stdio: ["pipe", "pipe", "pipe"],
-    encoding: "utf-8",
-    timeout: timeoutMs,
-    env: { ...process.env, RALPHCTL_LIFECYCLE_EVENT: event }
+  return new Promise((resolve) => {
+    const child = spawn(script, {
+      cwd: projectPath,
+      shell: true,
+      detached: process.platform !== "win32",
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, RALPHCTL_LIFECYCLE_EVENT: event }
+    });
+    const killTree = () => {
+      if (process.platform !== "win32" && typeof child.pid === "number") {
+        try {
+          process.kill(-child.pid, "SIGTERM");
+          return;
+        } catch {
+        }
+      }
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    };
+    const chunks = [];
+    let totalBytes = 0;
+    let timedOut = false;
+    let capExceeded = false;
+    let settled = false;
+    const appendChunk = (chunk) => {
+      if (capExceeded) return;
+      totalBytes += chunk.length;
+      if (totalBytes > MAX_OUTPUT_BYTES) {
+        capExceeded = true;
+        killTree();
+        return;
+      }
+      chunks.push(chunk);
+    };
+    child.stdout.on("data", (chunk) => {
+      appendChunk(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      appendChunk(chunk);
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      killTree();
+    }, timeoutMs);
+    const finish = (passed, suffix) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      const base = Buffer.concat(chunks).toString("utf-8").trim();
+      const output = suffix ? base ? `${base}
+${suffix}` : suffix : base;
+      resolve({ passed, output });
+    };
+    child.on("error", (err) => {
+      finish(false, `[spawn error: ${err.message}]`);
+    });
+    child.on("close", (code) => {
+      if (timedOut) {
+        finish(false, `[timeout exceeded after ${String(timeoutMs)}ms]`);
+        return;
+      }
+      if (capExceeded) {
+        finish(false, `[output exceeded ${String(MAX_OUTPUT_BYTES)} byte cap \u2014 truncated]`);
+        return;
+      }
+      finish(code === 0);
+    });
   });
-  const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
-  return { passed: result.status === 0, output };
 }
 
 // src/integration/ai/task-context.ts
@@ -4650,7 +4722,7 @@ function getRecentGitHistory(projectPath, count = 20) {
 }
 
 // src/integration/external/git.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync } from "child_process";
 var BRANCH_NAME_RE = /^[a-zA-Z0-9/_.-]+$/;
 var BRANCH_NAME_INVALID_PATTERNS = [/\.\./, /\.$/, /\/$/, /\.lock$/, /^-/, /\/\//];
 function isValidBranchName(name) {
@@ -4663,7 +4735,7 @@ function isValidBranchName(name) {
 }
 function getCurrentBranch(cwd) {
   assertSafeCwd(cwd);
-  const result = spawnSync2("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+  const result = spawnSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -4678,7 +4750,7 @@ function branchExists(cwd, name) {
   if (!isValidBranchName(name)) {
     throw new Error(`Invalid branch name: ${name}`);
   }
-  const result = spawnSync2("git", ["show-ref", "--verify", `refs/heads/${name}`], {
+  const result = spawnSync("git", ["show-ref", "--verify", `refs/heads/${name}`], {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -4695,7 +4767,7 @@ function createAndCheckoutBranch(cwd, name) {
     return;
   }
   if (branchExists(cwd, name)) {
-    const result = spawnSync2("git", ["checkout", name], {
+    const result = spawnSync("git", ["checkout", name], {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -4704,7 +4776,7 @@ function createAndCheckoutBranch(cwd, name) {
       throw new Error(`Failed to checkout branch '${name}' in ${cwd}: ${result.stderr.trim()}`);
     }
   } else {
-    const result = spawnSync2("git", ["checkout", "-b", name], {
+    const result = spawnSync("git", ["checkout", "-b", name], {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -4720,7 +4792,7 @@ function verifyCurrentBranch(cwd, expected) {
 }
 function getDefaultBranch(cwd) {
   assertSafeCwd(cwd);
-  const result = spawnSync2("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+  const result = spawnSync("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -4741,7 +4813,7 @@ function getDefaultBranch(cwd) {
 function getHeadSha(cwd) {
   try {
     assertSafeCwd(cwd);
-    const result = spawnSync2("git", ["rev-parse", "HEAD"], {
+    const result = spawnSync("git", ["rev-parse", "HEAD"], {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -4754,7 +4826,7 @@ function getHeadSha(cwd) {
 }
 function hasUncommittedChanges(cwd) {
   assertSafeCwd(cwd);
-  const result = spawnSync2("git", ["status", "--porcelain"], {
+  const result = spawnSync("git", ["status", "--porcelain"], {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -4766,7 +4838,7 @@ function hasUncommittedChanges(cwd) {
 }
 function hardResetWorkingTree(cwd) {
   assertSafeCwd(cwd);
-  const reset = spawnSync2("git", ["reset", "--hard", "HEAD"], {
+  const reset = spawnSync("git", ["reset", "--hard", "HEAD"], {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -4774,7 +4846,7 @@ function hardResetWorkingTree(cwd) {
   if (reset.status !== 0) {
     throw new StorageError(`Failed to reset working tree in ${cwd}: ${reset.stderr.trim() || reset.stdout.trim()}`);
   }
-  const clean = spawnSync2("git", ["clean", "-fd"], {
+  const clean = spawnSync("git", ["clean", "-fd"], {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -4785,7 +4857,7 @@ function hardResetWorkingTree(cwd) {
 }
 function autoCommit(cwd, message) {
   assertSafeCwd(cwd);
-  const add = spawnSync2("git", ["add", "-A"], {
+  const add = spawnSync("git", ["add", "-A"], {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -4793,7 +4865,7 @@ function autoCommit(cwd, message) {
   if (add.status !== 0) {
     throw new Error(`Failed to stage changes in ${cwd}: ${add.stderr.trim()}`);
   }
-  const commit = spawnSync2("git", ["commit", "-m", message], {
+  const commit = spawnSync("git", ["commit", "-m", message], {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -4806,14 +4878,14 @@ function generateBranchName(sprintId) {
   return `ralphctl/${sprintId}`;
 }
 function isGhAvailable() {
-  const result = spawnSync2("gh", ["--version"], {
+  const result = spawnSync("gh", ["--version"], {
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
   });
   return result.status === 0;
 }
 function isGlabAvailable() {
-  const result = spawnSync2("glab", ["--version"], {
+  const result = spawnSync("glab", ["--version"], {
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
   });

package/dist/{chunk-XPLYLRIM.mjs → chunk-ZE2BRQA2.mjs}

@@ -6,7 +6,7 @@ import {
   getAllConfigSchemaEntries,
   getConfigDefaultValue,
   parseConfigValue
-} from "./chunk-PYZEQ2VK.mjs";
+} from "./chunk-BT5FKIZX.mjs";
 import {
   editorInput
 } from "./chunk-OGEXYSFS.mjs";
@@ -41,14 +41,14 @@ import {
   updateTask,
   updateTaskStatus,
   validateImportTasks
-} from "./chunk-OFILN7QL.mjs";
+} from "./chunk-D6QZNEYN.mjs";
 import {
   SignalParser,
   buildTicketRefinePrompt,
   processLifecycleAdapter,
   providerDisplayName,
   resolveProvider
-} from "./chunk-ZLWSPLWI.mjs";
+} from "./chunk-62HYDA7L.mjs";
 import {
   fetchIssueFromUrl,
   formatIssueContext,
@@ -176,6 +176,7 @@ import {
   ProjectNotFoundError,
   SprintNotFoundError,
   SprintStatusError,
+  StepError,
   StorageError,
   TaskNotFoundError,
   TicketNotFoundError
@@ -184,7 +185,7 @@ import {
 // package.json
 var package_default = {
   name: "ralphctl",
-  version: "0.4.5",
+  version: "0.5.0",
   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",
@@ -2068,12 +2069,20 @@ var InMemoryExecutionRegistry = class {
         this.transition(executionId, "completed", summary ?? void 0);
       }
     } catch (err) {
-      void err;
       if (abortSignal.aborted) {
         this.transition(executionId, "cancelled");
-      } else {
-        this.transition(executionId, "failed");
+        return;
       }
+      const errInfo = err instanceof StepError ? { message: err.message, stepName: err.stepName } : { message: err instanceof Error ? err.message : String(err) };
+      const entry = this.entries.get(executionId);
+      entry?.logEventBus.emit({
+        kind: "log",
+        level: "error",
+        message: errInfo.stepName ? `[${errInfo.stepName}] ${errInfo.message}` : errInfo.message,
+        context: {},
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      this.transition(executionId, "failed", void 0, errInfo);
     }
   }
   get(id) {
@@ -2100,7 +2109,7 @@ var InMemoryExecutionRegistry = class {
   getLogEventBus(id) {
     return this.entries.get(id)?.logEventBus ?? null;
   }
-  transition(executionId, status, summary) {
+  transition(executionId, status, summary, error2) {
     const entry = this.entries.get(executionId);
     if (!entry) return;
     if (entry.execution.status === status) return;
@@ -2108,7 +2117,8 @@ var InMemoryExecutionRegistry = class {
       ...entry.execution,
       status,
       endedAt: /* @__PURE__ */ new Date(),
-      summary: summary ?? entry.execution.summary
+      summary: summary ?? entry.execution.summary,
+      error: error2 ?? entry.execution.error
     };
     entry.execution = next;
     this.notify(next);
@@ -2204,7 +2214,7 @@ async function selectProject(message = "Select project:") {
       default: true
     });
     if (create) {
-      const { projectAddCommand } = await import("./add-YVXM34RP.mjs");
+      const { projectAddCommand } = await import("./add-67UFUI54.mjs");
       await projectAddCommand({ interactive: true });
       const updated = await listProjects();
       if (updated.length === 0) return null;

package/dist/cli.mjs

@@ -41,10 +41,10 @@ import {
   ticketRefineCommand,
   ticketRemoveCommand,
   ticketShowCommand
-} from "./chunk-XPLYLRIM.mjs";
+} from "./chunk-ZE2BRQA2.mjs";
 import {
   projectAddCommand
-} from "./chunk-PYZEQ2VK.mjs";
+} from "./chunk-BT5FKIZX.mjs";
 import {
   sprintCreateCommand
 } from "./chunk-FNAAA32W.mjs";
@@ -56,8 +56,8 @@ import {
   executePipeline,
   getTasks,
   sprintStartCommand
-} from "./chunk-OFILN7QL.mjs";
-import "./chunk-ZLWSPLWI.mjs";
+} from "./chunk-D6QZNEYN.mjs";
+import "./chunk-62HYDA7L.mjs";
 import {
   truncate
 } from "./chunk-GQ2WFKBN.mjs";
@@ -756,7 +756,7 @@ async function main() {
   const isBare = argv.length <= 2;
   const isInteractive = argv[2] === "interactive";
   if (isBare || isInteractive) {
-    const { mountInkApp } = await import("./mount-H2IH3MWE.mjs");
+    const { mountInkApp } = await import("./mount-NCYR22SN.mjs");
     const { fallback } = await mountInkApp({ initialView: "repl" });
     if (!fallback) return;
     printBanner();
@@ -767,10 +767,10 @@ async function main() {
     return;
   }
   if (argv[2] === "sprint" && argv[3] === "start") {
-    const { parseSprintStartArgs } = await import("./start-2WH4BTDB.mjs");
+    const { parseSprintStartArgs } = await import("./start-T34NI3LF.mjs");
     const parsed = parseSprintStartArgs(argv.slice(4));
     if (parsed.ok) {
-      const { mountInkApp } = await import("./mount-H2IH3MWE.mjs");
+      const { mountInkApp } = await import("./mount-NCYR22SN.mjs");
       const { getSharedDeps: getSharedDeps2 } = await import("./bootstrap-FMHG6DRY.mjs");
       let sprintId;
       try {

package/dist/{mount-H2IH3MWE.mjs → mount-NCYR22SN.mjs}

@@ -62,7 +62,7 @@ import {
   ticketRemoveCommand,
   ticketShowCommand,
   useCurrentPrompt
-} from "./chunk-XPLYLRIM.mjs";
+} from "./chunk-ZE2BRQA2.mjs";
 import {
   PromptCancelledError,
   detectCheckScriptCandidates,
@@ -73,7 +73,7 @@ import {
   projectAddCommand,
   suggestCheckScript,
   validateConfigValue
-} from "./chunk-PYZEQ2VK.mjs";
+} from "./chunk-BT5FKIZX.mjs";
 import {
   sprintCreateCommand
 } from "./chunk-FNAAA32W.mjs";
@@ -99,7 +99,7 @@ import {
   reorderTask,
   sprintStartCommand,
   updateTaskStatus
-} from "./chunk-OFILN7QL.mjs";
+} from "./chunk-D6QZNEYN.mjs";
 import {
   ProviderAiSessionAdapter,
   SignalParser,
@@ -107,7 +107,7 @@ import {
   exitAltScreen,
   registerTuiInstance,
   withSuspendedTui
-} from "./chunk-ZLWSPLWI.mjs";
+} from "./chunk-62HYDA7L.mjs";
 import {
   addTicket,
   allRequirementsApproved,
@@ -189,7 +189,7 @@ import { render } from "ink";
 
 // src/integration/ui/tui/views/app.tsx
 import { useEffect as useEffect37, useState as useState38 } from "react";
-import { Box as Box37, useStdout } from "ink";
+import { Box as Box37, useStdout as useStdout2 } from "ink";
 
 // src/integration/ui/tui/views/view-router.tsx
 import { useCallback as useCallback12, useMemo as useMemo34, useState as useState37 } from "react";
@@ -1606,7 +1606,7 @@ function SettingsView() {
 
 // src/integration/ui/tui/views/execute-view.tsx
 import { useEffect as useEffect8, useMemo as useMemo6, useRef as useRef2, useState as useState8 } from "react";
-import { Box as Box19, Text as Text18, useInput as useInput6 } from "ink";
+import { Box as Box19, Text as Text18, useInput as useInput6, useStdout } from "ink";
 
 // src/integration/ui/tui/runtime/hooks.ts
 import { useCallback as useCallback4, useEffect as useEffect6, useRef, useState as useState6 } from "react";
@@ -1908,8 +1908,12 @@ function renderLine(event, index, isActiveSpinner) {
     }
   }
 }
-function LogTail({ events, limit = 8 }) {
-  const tail = events.slice(-limit);
+function LogTail({ events, visibleLines = 8, scrollOffset = 0 }) {
+  const maxOffset = Math.max(0, events.length - visibleLines);
+  const clampedOffset = Math.min(Math.max(0, scrollOffset), maxOffset);
+  const end = events.length - clampedOffset;
+  const start = Math.max(0, end - visibleLines);
+  const window = events.slice(start, end);
   const resolvedIds = useMemo5(() => {
     const ids = /* @__PURE__ */ new Set();
     for (const ev of events) {
@@ -1919,9 +1923,29 @@ function LogTail({ events, limit = 8 }) {
     }
     return ids;
   }, [events]);
+  const scrolledUp = clampedOffset > 0;
+  const hiddenAbove = start;
+  const hiddenBelow = events.length - end;
   return /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx17(Text14, { dimColor: true, children: "\u2500\u2500 Log \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }),
-    tail.length === 0 ? /* @__PURE__ */ jsx17(Text14, { dimColor: true, children: "(no activity yet)" }) : tail.map((event, i) => {
+    /* @__PURE__ */ jsxs14(Box15, { children: [
+      /* @__PURE__ */ jsx17(Text14, { dimColor: true, children: "\u2500\u2500 Log \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }),
+      scrolledUp ? /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
+        "  ",
+        glyphs.arrowRight,
+        " ",
+        hiddenAbove,
+        " line",
+        hiddenAbove !== 1 ? "s" : "",
+        " above",
+        hiddenBelow > 0 ? ` \xB7 ${String(hiddenBelow)} below` : ""
+      ] }) : events.length > visibleLines ? /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
+        "  ",
+        "(",
+        events.length - visibleLines,
+        " hidden)"
+      ] }) : null
+    ] }),
+    window.length === 0 ? /* @__PURE__ */ jsx17(Text14, { dimColor: true, children: "(no activity yet)" }) : window.map((event, i) => {
       const active = event.kind === "spinner-start" && !resolvedIds.has(event.id);
       return renderLine(event, i, active);
     })
@@ -1998,9 +2022,13 @@ function ResultCard({ kind, title, fields, nextSteps, lines }) {
 }
 
 // src/integration/ui/tui/views/execute-view.tsx
-import { jsx as jsx20, jsxs as jsxs18 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx20, jsxs as jsxs18 } from "react/jsx-runtime";
 var EXECUTE_HINTS_RUNNING = [{ key: "c", action: "cancel" }];
 var EXECUTE_HINTS_TERMINAL = [{ key: "Enter", action: "back" }];
+var LOG_TAIL_FIXED_OVERHEAD = 20;
+var LOG_TAIL_MIN_LINES = 3;
+var LOG_TAIL_DEFAULT_LINES = 8;
+var ERROR_MESSAGE_MAX_LINES = 20;
 function initialState() {
   return {
     sprint: null,
@@ -2026,6 +2054,7 @@ function ExecuteView({ sprintId, executionId, executionOptions }) {
   const registryEvents = useRegistryEvents(registry);
   const [attach, setAttach] = useState8(initialAttach);
   const [state, setState] = useState8(initialState);
+  const { stdout } = useStdout();
   const processedCountRef = useRef2(0);
   const startedRef = useRef2(false);
   const attachedId = attach.execution?.id ?? null;
@@ -2122,6 +2151,7 @@ function ExecuteView({ sprintId, executionId, executionOptions }) {
       })();
     }
   }, [signalEvents, shared, sprintId]);
+  const logVisibleLines = stdout.rows ? Math.max(LOG_TAIL_MIN_LINES, stdout.rows - LOG_TAIL_FIXED_OVERHEAD) : LOG_TAIL_DEFAULT_LINES;
   const status = liveExecution?.status ?? "running";
   const terminal = status === "completed" || status === "failed" || status === "cancelled";
   const [closePromptRun, setClosePromptRun] = useState8(false);
@@ -2190,6 +2220,7 @@ function ExecuteView({ sprintId, executionId, executionOptions }) {
   if (attach.kind === "attaching") {
     return /* @__PURE__ */ jsx20(ViewShell, { title: "Execute", children: /* @__PURE__ */ jsx20(Spinner, { label: "Attaching to execution\u2026" }) });
   }
+  const errorCard = terminal && liveExecution?.status === "failed" && liveExecution.error ? buildErrorCard(liveExecution.error) : null;
   return /* @__PURE__ */ jsxs18(ViewShell, { title: "Execute", children: [
     /* @__PURE__ */ jsxs18(Box19, { children: [
       /* @__PURE__ */ jsx20(Text18, { bold: true, color: inkColors.primary, children: state.sprint?.name ?? "Sprint" }),
@@ -2216,8 +2247,8 @@ function ExecuteView({ sprintId, executionId, executionOptions }) {
       const taskName = task?.name ?? taskId.slice(0, 8);
       return /* @__PURE__ */ jsx20(Spinner, { label: `${taskName} ${glyphs.emDash} ${label}` }, taskId);
     }) }) : null,
-    /* @__PURE__ */ jsx20(Box19, { marginTop: spacing.section, children: /* @__PURE__ */ jsx20(LogTail, { events: logEvents }) }),
-    terminal && liveExecution ? /* @__PURE__ */ jsxs18(Box19, { marginTop: spacing.section, flexDirection: "column", children: [
+    /* @__PURE__ */ jsx20(Box19, { marginTop: spacing.section, children: /* @__PURE__ */ jsx20(LogTail, { events: logEvents, visibleLines: logVisibleLines, scrollOffset: 0 }) }),
+    terminal && liveExecution ? /* @__PURE__ */ jsx20(Box19, { marginTop: spacing.section, flexDirection: "column", children: errorCard ? /* @__PURE__ */ jsx20(ResultCard, { kind: "error", title: "Execution failed", fields: errorCard.fields, lines: errorCard.lines }) : /* @__PURE__ */ jsxs18(Fragment, { children: [
       /* @__PURE__ */ jsxs18(Text18, { color: terminalColor(liveExecution.status), bold: true, children: [
         terminalGlyph(liveExecution.status),
         " Execution ",
@@ -2229,8 +2260,8 @@ function ExecuteView({ sprintId, executionId, executionOptions }) {
         glyphs.inlineDot,
         " ",
         liveExecution.summary.remaining,
-        " remaining",
         " ",
+        "remaining ",
         glyphs.inlineDot,
         " ",
         liveExecution.summary.blocked,
@@ -2239,7 +2270,7 @@ function ExecuteView({ sprintId, executionId, executionOptions }) {
         liveExecution.summary.stopReason,
         ")"
       ] }) : null
-    ] }) : null
+    ] }) }) : null
   ] });
 }
 function terminalColor(status) {
@@ -2252,6 +2283,19 @@ function terminalGlyph(status) {
   if (status === "failed") return glyphs.cross;
   return glyphs.warningGlyph;
 }
+function buildErrorCard(error) {
+  const fields = error.stepName ? [["Step", error.stepName]] : void 0;
+  const rawLines = error.message.split("\n");
+  if (rawLines.length <= ERROR_MESSAGE_MAX_LINES) {
+    return { fields, lines: rawLines };
+  }
+  const hidden = rawLines.length - ERROR_MESSAGE_MAX_LINES;
+  const visibleLines = [
+    `(${String(hidden)} earlier line${hidden !== 1 ? "s" : ""} omitted)`,
+    ...rawLines.slice(-ERROR_MESSAGE_MAX_LINES)
+  ];
+  return { fields, lines: visibleLines };
+}
 function CollisionRedirect({ registry, collisionId, fallbackSprintId }) {
   const router = useRouter();
   useInput6((_input, key) => {
@@ -7311,7 +7355,7 @@ function buildInitialStack(initialView, mountOptions) {
   return [{ id: "home" }];
 }
 function useTerminalWidth() {
-  const { stdout } = useStdout();
+  const { stdout } = useStdout2();
   const [width, setWidth] = useState38(stdout.columns);
   useEffect37(() => {
     const onResize = () => {

package/dist/{start-2WH4BTDB.mjs → start-T34NI3LF.mjs}

@@ -2,8 +2,8 @@
 import {
   parseSprintStartArgs,
   sprintStartCommand
-} from "./chunk-OFILN7QL.mjs";
-import "./chunk-ZLWSPLWI.mjs";
+} from "./chunk-D6QZNEYN.mjs";
+import "./chunk-62HYDA7L.mjs";
 import "./chunk-GQ2WFKBN.mjs";
 import "./chunk-CFUVE2BP.mjs";
 import "./chunk-747KW2RW.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ralphctl",
-  "version": "0.4.5",
+  "version": "0.5.0",
   "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",