ralphctl 0.6.2 → 0.6.3

package/dist/cli.mjs

@@ -212,8 +212,8 @@ async function directoryHasEntries(p) {
   try {
     const s = await stat(p);
     if (!s.isDirectory()) return false;
-    const { readdir: readdir6 } = await import("fs/promises");
-    const entries = await readdir6(p);
+    const { readdir: readdir5 } = await import("fs/promises");
+    const entries = await readdir5(p);
     return entries.length > 0;
   } catch {
     return false;
@@ -410,10 +410,9 @@ function renderEvaluateWorkspaceSection(workspaceDir) {
     "",
     "- `task.md` \u2014 the current task being evaluated (description, steps, verification criteria, status)",
     "- `requirements/<ticket-id>.md` \u2014 the refined requirements + raw ticket text that motivated this task",
-    "- `tasks.md` / `tasks.json` \u2014 the full task plan, for cross-task consistency checks",
+    "- `tasks.md` \u2014 the full task plan, including any sibling tasks' evaluator output rendered inline where present (cross-task consistency + quality bar so far)",
     "- `project-context.md` \u2014 the project's CLAUDE.md / .github/copilot-instructions.md (when present in the target repo)",
-    "- `dimensions.md` \u2014 the four floor dimensions plus any extra dimensions the planner emitted on this task",
-    "- `evaluations/<task-id>.md` \u2014 prior task evaluations from earlier in this sprint (the quality bar so far)"
+    "- `dimensions.md` \u2014 the four floor dimensions plus any extra dimensions the planner emitted on this task"
   ].join("\n");
 }
 function renderDoneCriteriaSection(doneCriteriaBullet) {
@@ -572,8 +571,8 @@ ${input.task.steps.map((s, i) => `${String(i + 1)}. ${s}`).join("\n")}` : "";
 ${input.task.verificationCriteria.map((c34) => `- ${c34}`).join("\n")}` : "";
     const branchLine = input.sprint.branch !== null ? `**Branch:** \`${input.sprint.branch}\`` : "";
     const checkScriptSection = renderCheckScriptSection(input.checkScript);
-    const checkRanAtForRepo = input.sprint.checkRanAt.get(input.task.projectPath);
-    const environmentStatus = checkRanAtForRepo !== void 0 ? `Pre-task environment check passed at ${String(checkRanAtForRepo)}.` : "Not run.";
+    const setupRanAtForRepo = input.sprint.setupRanAt.get(input.task.projectPath);
+    const environmentStatus = setupRanAtForRepo !== void 0 ? `Setup script ran at ${String(setupRanAtForRepo)}.` : "Not run.";
     const rendered = substitute(tpl.value, {
       TASK_NAME: input.task.name,
       TASK_ID: String(input.task.id),
@@ -915,8 +914,7 @@ function getAdapter(name) {
 
 // src/integration/persistence/session-md-writer.ts
 import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
-import { dirname as dirname2, join as join5 } from "path";
-import { readdir as readdir2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
 var FRONTMATTER_DELIM = "---";
 function renderFrontmatter(fields) {
   const lines = [FRONTMATTER_DELIM];
@@ -996,7 +994,8 @@ async function writeSessionFinish(args) {
     const fm2 = renderFrontmatter({
       finished: args.finished,
       exitCode: args.exitCode,
-      sessionId: args.sessionId
+      sessionId: args.sessionId,
+      model: args.model
     });
     return writeFileSafe(args.path, `${fm2}
 
@@ -1010,6 +1009,7 @@ _(no prompt recorded \u2014 session finish without start)_
   merged["finished"] = args.finished;
   merged["exitCode"] = args.exitCode;
   if (args.sessionId !== void 0) merged["sessionId"] = args.sessionId;
+  if (args.model !== void 0) merged["model"] = args.model;
   const fm = renderFrontmatter(merged);
   const content = `${fm}
 
@@ -1056,22 +1056,6 @@ function unquote(s) {
   }
   return s;
 }
-async function nextSessionPath(unitDir) {
-  let entries;
-  try {
-    entries = await readdir2(unitDir);
-  } catch {
-    return join5(unitDir, "session-1.md");
-  }
-  let max = 0;
-  for (const entry of entries) {
-    const m = /^session-(\d+)\.md$/.exec(entry);
-    if (!m) continue;
-    const n = Number(m[1]);
-    if (Number.isFinite(n) && n > max) max = n;
-  }
-  return join5(unitDir, `session-${String(max + 1)}.md`);
-}
 
 // src/integration/ai/session/session-runner.ts
 import { spawn } from "child_process";
@@ -1367,26 +1351,28 @@ var ProviderAiSessionAdapter = class {
    * The actual provider exit code isn't surfaced through the runner's
    * typed Result — `1` is a faithful "spawn failed" stand-in for audit
    * purposes; the underlying error's message is already in the logs.
+   *
+   * `model` is the first audit hint we have for headless spawns where
+   * the runner picks the model — `writeSessionFinish` merges it into
+   * the frontmatter alongside the other finish fields in a single write.
    */
   async writeSessionMdFinishHeadless(options, result) {
     const path = options.sessionMdPath;
     if (path === void 0) return;
     const sessionId = result.ok ? result.value.sessionId : void 0;
+    const model = result.ok ? result.value.model : void 0;
     const written = await writeSessionFinish({
       path: String(path),
       finished: (/* @__PURE__ */ new Date()).toISOString(),
       exitCode: result.ok ? 0 : 1,
-      ...sessionId !== void 0 ? { sessionId } : {}
+      ...sessionId !== void 0 ? { sessionId } : {},
+      ...model !== void 0 ? { model } : {}
     });
     if (!written.ok) {
       this.opts.logger?.warn("failed to write session.md (finish) \u2014 spawn already settled", {
         path: String(path),
         error: written.error.message
       });
-      return;
-    }
-    if (result.ok && result.value.model !== void 0) {
-      await this.patchSessionMdModel(String(path), result.value.model);
     }
   }
   /**
@@ -1409,33 +1395,6 @@ var ProviderAiSessionAdapter = class {
       });
     }
   }
-  /**
-   * Patch the resolved `model` into an existing `session.md`. Reuses
-   * `writeSessionFinish` to round-trip frontmatter without touching the
-   * prompt body. Best-effort — write failures log a warn.
-   *
-   * Implementation note: `writeSessionFinish` was scoped to the
-   * standard finish fields only. The narrow `model` patch here goes
-   * through `writeSessionStart` would clobber the body, so we re-read,
-   * splice the field, and re-emit via the same writer surface. This
-   * keeps the YAML-handling logic in one place (`session-md-writer`)
-   * even at the cost of a second IO round-trip — the audit pack is
-   * cold-path and we'd rather centralise format knowledge.
-   */
-  async patchSessionMdModel(path, model) {
-    try {
-      const fs = await import("fs/promises");
-      const existing = await fs.readFile(path, "utf-8");
-      const patched = upsertFrontmatterField(existing, "model", model);
-      if (patched === existing) return;
-      await fs.writeFile(path, patched, { encoding: "utf-8", mode: 384 });
-    } catch (err) {
-      this.opts.logger?.warn("failed to patch session.md model field", {
-        path,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
   /**
    * Build the flag list audited into session.md. Headless: the runner
    * appends `--resume <id>` when `resumeSessionId` is set, so we mirror
@@ -1482,28 +1441,6 @@ function stripTrailingPromptSlot(args) {
   if (end > 0 && args[end - 1] === "--") end -= 1;
   return args.slice(0, end);
 }
-function upsertFrontmatterField(content, key, value) {
-  const lines = content.split("\n");
-  if (lines[0]?.trim() !== "---") return content;
-  let closeIdx = -1;
-  for (let i = 1; i < lines.length; i += 1) {
-    if (lines[i]?.trim() === "---") {
-      closeIdx = i;
-      break;
-    }
-  }
-  if (closeIdx < 0) return content;
-  const keyRegex = new RegExp(`^${key}\\s*:`);
-  for (let i = 1; i < closeIdx; i += 1) {
-    const line = lines[i] ?? "";
-    if (keyRegex.test(line.trim())) {
-      lines[i] = `${key}: ${value}`;
-      return lines.join("\n");
-    }
-  }
-  lines.splice(closeIdx, 0, `${key}: ${value}`);
-  return lines.join("\n");
-}
 
 // src/integration/ai/session/process-runner.ts
 import { spawn as spawn2 } from "child_process";
@@ -1605,20 +1542,20 @@ var NodeProcessRunner = class {
 
 // src/integration/ai/skills/bundled-skills-copier.ts
 import { existsSync as existsSync3 } from "fs";
-import { readdir as readdir4, rm, rmdir } from "fs/promises";
-import { dirname as dirname3, join as join8 } from "path";
+import { readdir as readdir3, rm, rmdir } from "fs/promises";
+import { dirname as dirname3, join as join7 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/integration/ai/skills/copy-tree.ts
-import { copyFile, mkdir as mkdir2, readdir as readdir3, stat as stat2 } from "fs/promises";
-import { join as join6 } from "path";
+import { copyFile, mkdir as mkdir2, readdir as readdir2, stat as stat2 } from "fs/promises";
+import { join as join5 } from "path";
 async function copyTree(src, dst) {
   try {
     await mkdir2(dst, { recursive: true });
-    const dirents = await readdir3(src, { withFileTypes: true });
+    const dirents = await readdir2(src, { withFileTypes: true });
     for (const d of dirents) {
-      const s = join6(src, d.name);
-      const t = join6(dst, d.name);
+      const s = join5(src, d.name);
+      const t = join5(dst, d.name);
       if (d.isDirectory()) {
         const r = await copyTree(s, t);
         if (!r.ok) return r;
@@ -1654,12 +1591,12 @@ async function copyTree(src, dst) {
 // src/integration/ai/skills/skill-git-exclude.ts
 import { existsSync as existsSync2 } from "fs";
 import { mkdir as mkdir3, readFile as readFile3, stat as stat3, writeFile as writeFile2 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join6 } from "path";
 var BEGIN_MARKER = "# >>> ralphctl-managed-skills (do not edit) >>>";
 var END_MARKER = "# <<< ralphctl-managed-skills <<<";
 var EXCLUDE_PATTERNS = [".claude/skills/"];
 async function gitInfoDir(cwd) {
-  const dotGit = join7(cwd, ".git");
+  const dotGit = join6(cwd, ".git");
   if (!existsSync2(dotGit)) return null;
   try {
     const s = await stat3(dotGit);
@@ -1667,12 +1604,12 @@ async function gitInfoDir(cwd) {
   } catch {
     return null;
   }
-  return join7(dotGit, "info");
+  return join6(dotGit, "info");
 }
 async function addRalphctlSkillsExclude(cwd) {
   const infoDir = await gitInfoDir(cwd);
   if (infoDir === null) return Result.ok();
-  const excludeFile = join7(infoDir, "exclude");
+  const excludeFile = join6(infoDir, "exclude");
   try {
     await mkdir3(infoDir, { recursive: true });
     const existing = existsSync2(excludeFile) ? await readFile3(excludeFile, "utf8") : "";
@@ -1699,7 +1636,7 @@ ${block}`;
 async function removeRalphctlSkillsExclude(cwd) {
   const infoDir = await gitInfoDir(cwd);
   if (infoDir === null) return Result.ok();
-  const excludeFile = join7(infoDir, "exclude");
+  const excludeFile = join6(infoDir, "exclude");
   if (!existsSync2(excludeFile)) return Result.ok();
   try {
     const body = await readFile3(excludeFile, "utf8");
@@ -1737,10 +1674,10 @@ function stripMarkerBlock(body) {
 }
 
 // src/integration/ai/skills/bundled-skills-copier.ts
-var SKILLS_SUBDIR = join8(".claude", "skills");
+var SKILLS_SUBDIR = join7(".claude", "skills");
 var HERE2 = dirname3(fileURLToPath2(import.meta.url));
 function bundledSkillsRootDir() {
-  const distRoot = join8(HERE2, "skills");
+  const distRoot = join7(HERE2, "skills");
   if (existsSync3(distRoot)) return AbsolutePath.trustString(distRoot);
   return AbsolutePath.trustString(HERE2);
 }
@@ -1756,12 +1693,12 @@ var FileBundledSkillsCopier = class {
     this.bundledRootDir = opts.bundledRootDir ?? bundledSkillsRootDir();
   }
   async install(sessionDir, phase) {
-    const skillsDir = join8(sessionDir, SKILLS_SUBDIR);
+    const skillsDir = join7(sessionDir, SKILLS_SUBDIR);
     const sources = await this.collectSourceSkills(phase);
     if (!sources.ok) return Result.error(sources.error);
     const tracked = this.installed.get(String(sessionDir)) ?? /* @__PURE__ */ new Set();
     for (const [name, srcDir] of sources.value) {
-      const dst = join8(skillsDir, name);
+      const dst = join7(skillsDir, name);
       if (existsSync3(dst)) {
         continue;
       }
@@ -1788,10 +1725,10 @@ var FileBundledSkillsCopier = class {
       await removeRalphctlSkillsExclude(sessionDir);
       return Result.ok();
     }
-    const skillsDir = join8(sessionDir, SKILLS_SUBDIR);
+    const skillsDir = join7(sessionDir, SKILLS_SUBDIR);
     try {
       for (const name of tracked) {
-        await rm(join8(skillsDir, name), { recursive: true, force: true });
+        await rm(join7(skillsDir, name), { recursive: true, force: true });
       }
       this.installed.delete(key);
     } catch (err) {
@@ -1805,7 +1742,7 @@ var FileBundledSkillsCopier = class {
       );
     }
     await tryRmdirIfEmpty(skillsDir);
-    await tryRmdirIfEmpty(join8(sessionDir, ".claude"));
+    await tryRmdirIfEmpty(join7(sessionDir, ".claude"));
     await removeRalphctlSkillsExclude(sessionDir);
     return Result.ok();
   }
@@ -1819,7 +1756,7 @@ var FileBundledSkillsCopier = class {
   async collectSourceSkills(phase) {
     const sources = /* @__PURE__ */ new Map();
     for (const sub of ["default", phase]) {
-      const dir = join8(this.bundledRootDir, sub);
+      const dir = join7(this.bundledRootDir, sub);
       const r = await listSkillDirs(dir);
       if (!r.ok) return Result.error(r.error);
       for (const [name, abs] of r.value) {
@@ -1832,10 +1769,10 @@ var FileBundledSkillsCopier = class {
 async function listSkillDirs(dir) {
   if (!existsSync3(dir)) return Result.ok([]);
   try {
-    const dirents = await readdir4(dir, { withFileTypes: true });
+    const dirents = await readdir3(dir, { withFileTypes: true });
     const out = [];
     for (const d of dirents) {
-      if (d.isDirectory()) out.push([d.name, join8(dir, d.name)]);
+      if (d.isDirectory()) out.push([d.name, join7(dir, d.name)]);
     }
     return Result.ok(out);
   } catch (err) {
@@ -1852,7 +1789,7 @@ async function listSkillDirs(dir) {
 async function tryRmdirIfEmpty(dir) {
   if (!existsSync3(dir)) return;
   try {
-    const entries = await readdir4(dir);
+    const entries = await readdir3(dir);
     if (entries.length === 0) await rmdir(dir);
   } catch {
   }
@@ -2156,7 +2093,12 @@ var DefaultExternalAdapter = class {
   formatIssueContext(issue) {
     return this.issues.format(issue);
   }
-  // --- Check script execution -----------------------------------------
+  // --- Setup / check script execution ---------------------------------
+  async runSetupScript(projectPath, script, timeout) {
+    const r = await this.checkScripts.run(projectPath, script, "setup", timeout);
+    if (r.ok) return r.value;
+    return { passed: false, output: `[setup-script error: ${r.error.message}]` };
+  }
   async runCheckScript(projectPath, script, phase, timeout) {
     const r = await this.checkScripts.run(projectPath, script, phase, timeout);
     if (r.ok) return r.value;
@@ -2932,9 +2874,9 @@ var JsonLogger = class _JsonLogger {
 
 // src/integration/logging/jsonl-file-writer.ts
 import { appendFile, mkdir as mkdir4 } from "fs/promises";
-import { dirname as dirname4, join as join9 } from "path";
+import { dirname as dirname4, join as join8 } from "path";
 function fileFor(opts) {
-  return AbsolutePath.trustString(join9(opts.logsDir, `${opts.sessionId}.jsonl`));
+  return AbsolutePath.trustString(join8(opts.logsDir, `${opts.sessionId}.jsonl`));
 }
 var JsonlFileWriter = class {
   constructor(opts) {
@@ -3304,7 +3246,7 @@ var NotFoundError = class extends Error {
 
 // src/integration/persistence/json-io.ts
 import { mkdir as mkdir6, readFile as readFile5, rename, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname6, join as join10 } from "path";
+import { dirname as dirname6, join as join9 } from "path";
 async function readJsonFile(path, schema2) {
   let raw;
   try {
@@ -3362,7 +3304,7 @@ ${issues}`,
     );
   }
   const dir = dirname6(path);
-  const tmp = join10(dir, `.${pathBasename(path)}.${String(process.pid)}.${String(Date.now())}.${randomTail()}.tmp`);
+  const tmp = join9(dir, `.${pathBasename(path)}.${String(process.pid)}.${String(Date.now())}.${randomTail()}.tmp`);
   try {
     await mkdir6(dir, { recursive: true });
     await writeFile4(tmp, JSON.stringify(validated.data, null, 2) + "\n", {
@@ -4038,7 +3980,7 @@ function errnoCode3(err) {
 }
 
 // src/integration/persistence/file-sprint-repository.ts
-import { mkdir as mkdir7, readdir as readdir5, rm as rm2 } from "fs/promises";
+import { mkdir as mkdir7, readdir as readdir4, rm as rm2 } from "fs/promises";
 
 // src/integration/persistence/schemas/sprint-schema.ts
 import { z as z3 } from "zod";
@@ -4139,7 +4081,12 @@ var Sprint = class _Sprint {
   activatedAt;
   closedAt;
   tickets;
-  checkRanAt;
+  /**
+   * Audit trail of sprint-start setup-script runs, keyed by repo path.
+   * Filled in by the `setup-scripts-sprint-start` chain leaf. Cleared on
+   * sprint close so a re-opened sprint starts a fresh setup record.
+   */
+  setupRanAt;
   branch;
   /**
    * Pull / merge request URL recorded after `sprint create-pr` runs.
@@ -4167,7 +4114,7 @@ var Sprint = class _Sprint {
     this.activatedAt = props.activatedAt;
     this.closedAt = props.closedAt;
     this.tickets = props.tickets;
-    this.checkRanAt = props.checkRanAt;
+    this.setupRanAt = props.setupRanAt;
     this.branch = props.branch;
     this.pullRequestUrl = props.pullRequestUrl;
     this.projectName = props.projectName;
@@ -4194,7 +4141,7 @@ var Sprint = class _Sprint {
         activatedAt: null,
         closedAt: null,
         tickets: [],
-        checkRanAt: /* @__PURE__ */ new Map(),
+        setupRanAt: /* @__PURE__ */ new Map(),
         branch: null,
         pullRequestUrl: null,
         projectName: input.projectName,
@@ -4231,7 +4178,7 @@ var Sprint = class _Sprint {
       this.with({
         status: "closed",
         closedAt: now,
-        checkRanAt: /* @__PURE__ */ new Map()
+        setupRanAt: /* @__PURE__ */ new Map()
       })
     );
   }
@@ -4270,7 +4217,7 @@ var Sprint = class _Sprint {
         activatedAt: this.activatedAt,
         closedAt: this.closedAt,
         tickets: this.tickets,
-        checkRanAt: this.checkRanAt,
+        setupRanAt: this.setupRanAt,
         branch: this.branch,
         pullRequestUrl: this.pullRequestUrl,
         projectName: this.projectName,
@@ -4366,13 +4313,13 @@ var Sprint = class _Sprint {
     return Result8.ok(this.with({ branch }));
   }
   /**
-   * Stamp a check-script run for one repo. Never fails — the harness owns
+   * Stamp a setup-script run for one repo. Never fails — the harness owns
    * this audit trail and the entity should not gate it.
    */
-  recordCheckRun(repo, at) {
-    const next = new Map(this.checkRanAt);
+  recordSetupRun(repo, at) {
+    const next = new Map(this.setupRanAt);
     next.set(repo, at);
-    return this.with({ checkRanAt: next });
+    return this.with({ setupRanAt: next });
   }
   /**
    * Record the pull / merge request URL published for the sprint branch.
@@ -4458,7 +4405,7 @@ var Sprint = class _Sprint {
       activatedAt: "activatedAt" in partial ? partial.activatedAt ?? null : this.activatedAt,
       closedAt: "closedAt" in partial ? partial.closedAt ?? null : this.closedAt,
       tickets: partial.tickets ?? this.tickets,
-      checkRanAt: partial.checkRanAt ?? this.checkRanAt,
+      setupRanAt: partial.setupRanAt ?? this.setupRanAt,
       branch: "branch" in partial ? partial.branch ?? null : this.branch,
       pullRequestUrl: "pullRequestUrl" in partial ? partial.pullRequestUrl ?? null : this.pullRequestUrl,
       projectName: this.projectName,
@@ -4642,7 +4589,13 @@ var sprintJsonSchema = z3.object({
   // to `[]` on a fresh draft sprint, populated post-plan).
   affectedRepositories: z3.array(z3.string()),
   // `Map<AbsolutePath, IsoTimestamp>` — serialised as a plain object map.
-  checkRanAt: z3.record(z3.string(), z3.string()),
+  // Backwards-compat: v0.6.2 wrote this audit map under the legacy key
+  // `checkRanAt` and may not have emitted any key at all on older drafts.
+  // `.optional().default({})` accepts both shapes; Zod silently strips the
+  // legacy `checkRanAt` payload on the next save (a stale audit trail under
+  // the wrong key has no migration value — the worst case is one extra
+  // setup run on first resume).
+  setupRanAt: z3.record(z3.string(), z3.string()).optional().default({}),
   tickets: z3.array(ticketJsonSchema)
 });
 var SYNTHETIC_SLUG_R = Slug.parse("rehydrate");
@@ -4655,9 +4608,9 @@ function toSprint(parsed) {
     if (!r.ok) return Result.error(r.error);
     tickets.push(r.value);
   }
-  const checkRanAt = /* @__PURE__ */ new Map();
-  for (const [k, v] of Object.entries(parsed.checkRanAt)) {
-    checkRanAt.set(AbsolutePath.trustString(k), IsoTimestamp.trustString(v));
+  const setupRanAt = /* @__PURE__ */ new Map();
+  for (const [k, v] of Object.entries(parsed.setupRanAt)) {
+    setupRanAt.set(AbsolutePath.trustString(k), IsoTimestamp.trustString(v));
   }
   const created = Sprint.create({
     id: SprintId.trustString(parsed.id),
@@ -4692,8 +4645,8 @@ function toSprint(parsed) {
     const r = s.close(IsoTimestamp.trustString(at));
     if (r.ok) s = r.value;
   }
-  for (const [path, at] of checkRanAt) {
-    s = s.recordCheckRun(path, at);
+  for (const [path, at] of setupRanAt) {
+    s = s.recordSetupRun(path, at);
   }
   if (parsed.branch !== null) {
     const r = s.setBranch(parsed.branch);
@@ -4706,9 +4659,9 @@ function toSprint(parsed) {
   return Result.ok(s);
 }
 function fromSprint(sprint) {
-  const checkRanAt = {};
-  for (const [k, v] of sprint.checkRanAt) {
-    checkRanAt[k] = v;
+  const setupRanAt = {};
+  for (const [k, v] of sprint.setupRanAt) {
+    setupRanAt[k] = v;
   }
   return {
     id: sprint.id,
@@ -4721,7 +4674,7 @@ function fromSprint(sprint) {
     pullRequestUrl: sprint.pullRequestUrl,
     projectName: sprint.projectName,
     affectedRepositories: [...sprint.affectedRepositories],
-    checkRanAt,
+    setupRanAt,
     tickets: sprint.tickets.map(fromTicket)
   };
 }
@@ -4809,7 +4762,7 @@ var FileSprintRepository = class {
   async list() {
     let entries;
     try {
-      const dirents = await readdir5(this.paths.sprintsDir, {
+      const dirents = await readdir4(this.paths.sprintsDir, {
         withFileTypes: true
       });
       entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
@@ -5498,8 +5451,8 @@ var FileWriteContextFileAdapter = class {
 };
 
 // src/integration/persistence/execution-unit-builder.ts
-import { readFile as readFile6, rm as rm4 } from "fs/promises";
-import { join as join12 } from "path";
+import { readFile as readFile6 } from "fs/promises";
+import { join as join11 } from "path";
 
 // src/integration/persistence/unit-slug.ts
 function unitSlug(id, name) {
@@ -5516,10 +5469,10 @@ function toSlug(name) {
 
 // src/integration/persistence/session-folder-helpers.ts
 import { cp, mkdir as mkdir10, rm as rm3, writeFile as writeFile6 } from "fs/promises";
-import { basename as basename2, dirname as dirname8, join as join11 } from "path";
+import { basename as basename2, dirname as dirname8, join as join10 } from "path";
 function contextFileFor(provider) {
   if (provider === "claude") return { path: "CLAUDE.md", needsGithubDir: false };
-  return { path: join11(".github", "copilot-instructions.md"), needsGithubDir: true };
+  return { path: join10(".github", "copilot-instructions.md"), needsGithubDir: true };
 }
 function renderContextFile(args) {
   const { sprint, phase, affectedRepos, copilot } = args;
@@ -5541,7 +5494,7 @@ function renderInputsLine(phase) {
     return "- Input: `./ticket.md` \u2014 the seed idea. Write the proposed sprint output to `./output.json`.\n";
   if (phase === "plan")
     return "- Inputs: per-ticket refined requirements live alongside this folder under `../refinement/<unit>/requirements.json`. Write your generated `tasks.json` to `./tasks.json` in this folder.\n";
-  return "- Inputs are in `./task.md` (the task under review), `./tasks.md` / `./tasks.json` (full task plan), `./requirements/` (per-ticket requirements), `./project-context.md` (target repo context), `./dimensions.md` (grading rubric), and `./evaluations/` (prior evaluations from this sprint).\n";
+  return "- Inputs are in `./task.md` (the task under review), `./tasks.md` (full task plan including any sibling evaluator output), `./requirements/` (per-ticket requirements), `./project-context.md` (target repo context), and `./dimensions.md` (grading rubric).\n";
 }
 function renderRepoLine(phase, affectedRepos, copilot) {
   if (phase === "refine" || phase === "ideate")
@@ -5651,7 +5604,7 @@ async function mirrorRepo(src, dst) {
 async function writeContextFile(args) {
   const { path, needsGithubDir } = contextFileFor(args.provider);
   if (needsGithubDir) {
-    const ensure = await ensureDirSafe(join11(args.root, ".github"));
+    const ensure = await ensureDirSafe(join10(args.root, ".github"));
     if (!ensure.ok) return Result.error(ensure.error);
   }
   const body = renderContextFile({
@@ -5660,7 +5613,7 @@ async function writeContextFile(args) {
     affectedRepos: args.affectedRepos,
     copilot: args.provider === "copilot"
   });
-  return writeFileSafe2(join11(args.root, path), body);
+  return writeFileSafe2(join10(args.root, path), body);
 }
 
 // src/integration/persistence/execution-unit-builder.ts
@@ -5723,7 +5676,7 @@ function renderTaskInput(task) {
   }
   return lines.join("\n");
 }
-function renderTasksList(tasks) {
+function renderTasksList(tasks, priorEvaluations) {
   const ordered = [...tasks].sort((a, b) => a.order - b.order);
   const lines = ["# Task plan", ""];
   for (const t of ordered) {
@@ -5747,6 +5700,10 @@ function renderTasksList(tasks) {
       for (const c34 of t.verificationCriteria) lines.push(`- ${c34}`);
       lines.push("");
     }
+    const priorEval = priorEvaluations.get(t.id);
+    if (priorEval !== void 0 && priorEval.length > 0) {
+      lines.push("### Evaluator output", "", "```text", priorEval, "```", "");
+    }
   }
   return lines.join("\n");
 }
@@ -5777,7 +5734,7 @@ function renderDimensions(task) {
   return lines.join("\n");
 }
 async function readProjectContext(repoPath, provider) {
-  const target = provider === "claude" ? join12(repoPath, "CLAUDE.md") : join12(repoPath, ".github", "copilot-instructions.md");
+  const target = provider === "claude" ? join11(repoPath, "CLAUDE.md") : join11(repoPath, ".github", "copilot-instructions.md");
   try {
     const body = await readFile6(target, "utf-8");
     return [`<!-- copied from ${target} -->`, "", body].join("\n");
@@ -5792,59 +5749,20 @@ async function readProjectContext(repoPath, provider) {
     ].join("\n");
   }
 }
-function serialiseTasks(tasks) {
-  return [...tasks].sort((a, b) => a.order - b.order).map((t) => ({
-    id: t.id,
-    name: t.name,
-    description: t.description,
-    steps: t.steps,
-    verificationCriteria: t.verificationCriteria,
-    status: t.status,
-    order: t.order,
-    ticketId: t.ticketId,
-    blockedBy: t.blockedBy,
-    projectPath: t.projectPath,
-    extraDimensions: t.extraDimensions
-  }));
-}
 async function writeExecutionVolatile(args) {
-  const taskMd = await writeFileSafe2(join12(args.root, "task.md"), renderTaskInput(args.task));
+  const taskMd = await writeFileSafe2(join11(args.root, "task.md"), renderTaskInput(args.task));
   if (!taskMd.ok) return Result.error(taskMd.error);
-  const tasksMd = await writeFileSafe2(join12(args.root, "tasks.md"), renderTasksList(args.tasks));
+  const tasksMd = await writeFileSafe2(join11(args.root, "tasks.md"), renderTasksList(args.tasks, args.priorEvaluations));
   if (!tasksMd.ok) return Result.error(tasksMd.error);
-  const tasksJson = await writeFileSafe2(
-    join12(args.root, "tasks.json"),
-    JSON.stringify(serialiseTasks(args.tasks), null, 2)
-  );
-  if (!tasksJson.ok) return Result.error(tasksJson.error);
   const projectContext = await readProjectContext(args.task.projectPath, args.aiProvider);
-  const projectCtxFile = await writeFileSafe2(join12(args.root, "project-context.md"), projectContext);
+  const projectCtxFile = await writeFileSafe2(join11(args.root, "project-context.md"), projectContext);
   if (!projectCtxFile.ok) return Result.error(projectCtxFile.error);
-  const evaluationsDir = join12(args.root, "evaluations");
-  try {
-    await rm4(evaluationsDir, { recursive: true, force: true });
-  } catch (err) {
-    return Result.error(
-      new StorageError({
-        subCode: "io",
-        message: `failed to clear ${evaluationsDir}: ${err instanceof Error ? err.message : String(err)}`,
-        path: evaluationsDir,
-        cause: err
-      })
-    );
-  }
-  const ensureEvals = await ensureDirSafe(evaluationsDir);
-  if (!ensureEvals.ok) return Result.error(ensureEvals.error);
-  for (const [taskId, body] of args.priorEvaluations) {
-    const w = await writeFileSafe2(join12(evaluationsDir, `${taskId}.md`), body);
-    if (!w.ok) return Result.error(w.error);
-  }
   return Result.ok();
 }
 async function buildExecutionUnit(storage2, input) {
   const slug = unitSlug(String(input.task.id), input.task.name);
   const root = storage2.executionUnitDir(input.sprint.id, slug);
-  const requirementsDir = AbsolutePath.trustString(join12(root, "requirements"));
+  const requirementsDir = AbsolutePath.trustString(join11(root, "requirements"));
   const ensure = await ensureDirSafe(requirementsDir);
   if (!ensure.ok) return Result.error(ensure.error);
   const ctx = await writeContextFile({
@@ -5856,14 +5774,14 @@ async function buildExecutionUnit(storage2, input) {
   });
   if (!ctx.ok) return Result.error(ctx.error);
   for (const ticket of input.sprint.tickets) {
-    const filePath = join12(requirementsDir, `${ticket.id}.md`);
+    const filePath = join11(requirementsDir, `${ticket.id}.md`);
     const w = await writeFileSafe2(filePath, renderRequirementsInput(ticket));
     if (!w.ok) return Result.error(w.error);
   }
-  const dims = await writeFileSafe2(join12(root, "dimensions.md"), renderDimensions(input.task));
+  const dims = await writeFileSafe2(join11(root, "dimensions.md"), renderDimensions(input.task));
   if (!dims.ok) return Result.error(dims.error);
   const sprintCriteriaPath = String(storage2.doneCriteriaFile(input.sprint.id));
-  const unitCriteriaPath = join12(root, "done-criteria.md");
+  const unitCriteriaPath = join11(root, "done-criteria.md");
   const copied = await copyFileSafe(sprintCriteriaPath, unitCriteriaPath);
   if (!copied.ok) {
     const msg = `build-execution-unit: done-criteria.md not found for sprint ${String(input.sprint.id)} \u2014 evaluator will grade without per-task criteria reference`;
@@ -5883,7 +5801,7 @@ async function buildExecutionUnit(storage2, input) {
   let addDirs;
   let sessionCwd;
   if (input.aiProvider === "copilot") {
-    const repoMirror = join12(root, "repo");
+    const repoMirror = join11(root, "repo");
     const m = await mirrorRepo(input.task.projectPath, repoMirror);
     if (!m.ok) return Result.error(m.error);
     addDirs = [];
@@ -5895,8 +5813,7 @@ async function buildExecutionUnit(storage2, input) {
   return Result.ok({
     root,
     addDirs,
-    sessionCwd,
-    evaluationMdPath: AbsolutePath.trustString(join12(root, "evaluation.md"))
+    sessionCwd
   });
 }
 async function refreshExecutionUnit(storage2, input) {
@@ -5913,7 +5830,7 @@ async function refreshExecutionUnit(storage2, input) {
 }
 
 // src/integration/persistence/ideate-unit-builder.ts
-import { join as join13 } from "path";
+import { join as join12 } from "path";
 async function buildIdeationUnit(storage2, input) {
   const slug = unitSlug(String(input.ticket.id), input.ticket.title);
   const root = storage2.ideationUnitDir(input.sprint.id, slug);
@@ -5927,19 +5844,19 @@ async function buildIdeationUnit(storage2, input) {
     affectedRepos: []
   });
   if (!ctx.ok) return Result.error(ctx.error);
-  const ticketMdPath = AbsolutePath.trustString(join13(root, "ticket.md"));
+  const ticketMdPath = AbsolutePath.trustString(join12(root, "ticket.md"));
   const wrote = await writeFileSafe2(ticketMdPath, renderTicketInput(input.ticket));
   if (!wrote.ok) return Result.error(wrote.error);
   return Result.ok({
     root,
-    sessionMdPath: AbsolutePath.trustString(join13(root, "session.md")),
+    sessionMdPath: AbsolutePath.trustString(join12(root, "session.md")),
     ticketMdPath,
-    outputJsonPath: AbsolutePath.trustString(join13(root, "output.json"))
+    outputJsonPath: AbsolutePath.trustString(join12(root, "output.json"))
   });
 }
 
 // src/integration/persistence/planning-folder-builder.ts
-import { basename as basename3, join as join14 } from "path";
+import { basename as basename3, join as join13 } from "path";
 
 // src/business/usecases/sprint/sprint-requirements-aggregate.ts
 function buildSprintRequirementsAggregate(sprint, now = /* @__PURE__ */ new Date()) {
@@ -6015,7 +5932,7 @@ async function buildPlanningFolder(storage2, input) {
   });
   if (!ctx.ok) return Result.error(ctx.error);
   const reqSrc = String(storage2.requirementsAggregateFile(input.sprint.id));
-  const reqDst = join14(root, "requirements.json");
+  const reqDst = join13(root, "requirements.json");
   const copied = await copyFileSafe(reqSrc, reqDst);
   if (!copied.ok) {
     const inlineBody = serialiseSprintRequirementsAggregate(buildSprintRequirementsAggregate(input.sprint));
@@ -6024,11 +5941,11 @@ async function buildPlanningFolder(storage2, input) {
   }
   let addDirs;
   if (isCopilot) {
-    const reposDir = join14(root, "repos");
+    const reposDir = join13(root, "repos");
     const ensureRepos = await ensureDirSafe(reposDir);
     if (!ensureRepos.ok) return Result.error(ensureRepos.error);
     for (const repoPath of input.sprint.affectedRepositories) {
-      const dst = join14(reposDir, basename3(repoPath));
+      const dst = join13(reposDir, basename3(repoPath));
       const m = await mirrorRepo(repoPath, dst);
       if (!m.ok) return Result.error(m.error);
     }
@@ -6038,14 +5955,14 @@ async function buildPlanningFolder(storage2, input) {
   }
   return Result.ok({
     root,
-    sessionMdPath: AbsolutePath.trustString(join14(root, "session.md")),
-    rawTasksJsonPath: AbsolutePath.trustString(join14(root, "tasks.json")),
+    sessionMdPath: AbsolutePath.trustString(join13(root, "session.md")),
+    rawTasksJsonPath: AbsolutePath.trustString(join13(root, "tasks.json")),
     addDirs
   });
 }
 
 // src/integration/persistence/refine-unit-builder.ts
-import { join as join15 } from "path";
+import { join as join14 } from "path";
 async function buildRefinementUnit(storage2, input) {
   const slug = unitSlug(String(input.ticket.id), input.ticket.title);
   const root = storage2.refinementUnitDir(input.sprint.id, slug);
@@ -6059,14 +5976,14 @@ async function buildRefinementUnit(storage2, input) {
     affectedRepos: []
   });
   if (!ctx.ok) return Result.error(ctx.error);
-  const ticketMdPath = AbsolutePath.trustString(join15(root, "ticket.md"));
+  const ticketMdPath = AbsolutePath.trustString(join14(root, "ticket.md"));
   const wrote = await writeFileSafe2(ticketMdPath, renderTicketInput(input.ticket));
   if (!wrote.ok) return Result.error(wrote.error);
   return Result.ok({
     root,
-    sessionMdPath: AbsolutePath.trustString(join15(root, "session.md")),
+    sessionMdPath: AbsolutePath.trustString(join14(root, "session.md")),
     ticketMdPath,
-    requirementsJsonPath: AbsolutePath.trustString(join15(root, "requirements.json"))
+    requirementsJsonPath: AbsolutePath.trustString(join14(root, "requirements.json"))
   });
 }
 
@@ -6198,15 +6115,11 @@ var InMemorySignalBus = class {
 };
 
 // src/integration/signals/file-system-handler.ts
-import { appendFile as appendFile2, mkdir as mkdir11, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname9, join as join16 } from "path";
+import { appendFile as appendFile2, mkdir as mkdir11 } from "fs/promises";
+import { dirname as dirname9 } from "path";
 function progressPath(paths, sprintId) {
   return paths.progressFile(sprintId);
 }
-function evaluationPath(paths, sprintId, taskId, taskName) {
-  const slug = unitSlug(taskId, taskName);
-  return AbsolutePath.trustString(join16(paths.executionUnitDir(sprintId, slug), "evaluation.md"));
-}
 async function appendLine(path, line) {
   try {
     await mkdir11(dirname9(path), { recursive: true });
@@ -6224,26 +6137,6 @@ async function appendLine(path, line) {
     );
   }
 }
-async function writeText(path, body) {
-  try {
-    await mkdir11(dirname9(path), { recursive: true });
-    await writeFile7(path, body.endsWith("\n") ? body : `${body}
-`, {
-      encoding: "utf-8",
-      mode: 384
-    });
-    return Result.ok();
-  } catch (err) {
-    return Result.error(
-      new StorageError({
-        subCode: "io",
-        message: `failed to write ${path}: ${err instanceof Error ? err.message : String(err)}`,
-        path,
-        cause: err
-      })
-    );
-  }
-}
 var FileSystemSignalHandler = class {
   constructor(paths, fileLocker = new FileLocker()) {
     this.paths = paths;
@@ -6275,14 +6168,10 @@ var FileSystemSignalHandler = class {
           return Result.error(
             new StorageError({
               subCode: "io",
-              message: "evaluation signal requires taskName in meta to derive the execution unit slug"
+              message: "evaluation signal requires taskName in meta"
             })
           );
         }
-        const file = evaluationPath(this.paths, meta.sprintId, String(meta.taskId), meta.taskName);
-        const body = renderEvaluationBody(signal);
-        const w = await writeText(file, body);
-        if (!w.ok) return w;
         const scoreSuffix = signal.overallScore !== void 0 ? `, score ${String(signal.overallScore)}/5` : "";
         return this.appendProgress(
           meta.sprintId,
@@ -6321,33 +6210,6 @@ function formatProgress(timestamp, message, files) {
   const filesSuffix = files !== void 0 && files.length > 0 ? ` (files: ${files.join(", ")})` : "";
   return `- ${timestamp} \u2014 ${message}${filesSuffix}`;
 }
-function renderEvaluationBody(signal) {
-  const lines = [];
-  lines.push(`# Evaluation \u2014 ${signal.status}`);
-  lines.push("");
-  lines.push(`Recorded: ${signal.timestamp}`);
-  if (signal.overallScore !== void 0) {
-    lines.push(`Overall score: ${String(signal.overallScore)}/5`);
-  }
-  lines.push("");
-  if (signal.dimensions.length > 0) {
-    lines.push("## Dimensions");
-    lines.push("");
-    for (const d of signal.dimensions) {
-      const verdict = d.passed ? "PASS" : "FAIL";
-      const scoreLabel = d.score !== void 0 ? ` (score ${String(d.score)}/5)` : "";
-      lines.push(`- **${d.dimension}**${scoreLabel}: ${verdict} \u2014 ${d.finding}`);
-    }
-    lines.push("");
-  }
-  if (signal.critique !== void 0 && signal.critique.length > 0) {
-    lines.push("## Critique");
-    lines.push("");
-    lines.push(signal.critique);
-    lines.push("");
-  }
-  return lines.join("\n");
-}
 
 // src/integration/signals/parser.ts
 function buildPatterns() {
@@ -7357,18 +7219,18 @@ async function isFirstLaunch(deps) {
 // src/application/runtime/legacy-detector.ts
 import { access } from "fs/promises";
 import { homedir } from "os";
-import { join as join17 } from "path";
+import { join as join15 } from "path";
 var NOT_LEGACY = { isLegacy: false, legacyConfigPath: null, hint: "" };
 function defaultRoot() {
   const fromEnv = process.env["RALPHCTL_ROOT"];
   if (fromEnv !== void 0 && fromEnv.length > 0) {
     return AbsolutePath.trustString(fromEnv);
   }
-  return AbsolutePath.trustString(join17(homedir(), ".ralphctl"));
+  return AbsolutePath.trustString(join15(homedir(), ".ralphctl"));
 }
 async function detectLegacyLayout(deps = {}) {
   const root = deps.root ?? defaultRoot();
-  const legacyConfigPath = AbsolutePath.trustString(join17(root, "config.json"));
+  const legacyConfigPath = AbsolutePath.trustString(join15(root, "config.json"));
   try {
     await access(legacyConfigPath);
   } catch {
@@ -7389,7 +7251,7 @@ Then re-run ralphctl to start fresh, and use 'ralphctl project add' to register
 // src/integration/ai/dist-asset-manifest.ts
 import { existsSync as existsSync4 } from "fs";
 import { readFile as readFile7, stat as stat4 } from "fs/promises";
-import { dirname as dirname10, join as join18 } from "path";
+import { dirname as dirname10, join as join16 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var HERE3 = dirname10(fileURLToPath3(import.meta.url));
 var cached2 = { state: "unverified" };
@@ -7397,7 +7259,7 @@ async function verifyDistAssets(distRootOverride) {
   if (cached2.state === "pass") return Result.ok();
   if (cached2.state === "fail") return Result.error(cached2.error);
   const distRoot = distRootOverride ?? HERE3;
-  const manifestPath = join18(distRoot, "manifest.json");
+  const manifestPath = join16(distRoot, "manifest.json");
   if (!existsSync4(manifestPath)) {
     cached2 = { state: "pass" };
     return Result.ok();
@@ -7409,7 +7271,7 @@ async function verifyDistAssets(distRootOverride) {
   }
   const missing = [];
   for (const rel of parsed.value.assets) {
-    const abs = join18(distRoot, rel);
+    const abs = join16(distRoot, rel);
     try {
       const s = await stat4(abs);
       if (!s.isFile()) missing.push(rel);
@@ -9683,7 +9545,22 @@ function unlinkSkillsLeaf(deps, opts = {}) {
 }
 
 // src/application/chains/execute/per-task-flow.ts
-import { dirname as dirname11, join as join21 } from "path";
+import { join as join20 } from "path";
+
+// src/kernel/algorithms/execution-round-paths.ts
+import { join as join17 } from "path";
+function roundDir(unitRoot, round) {
+  return join17(unitRoot, "rounds", String(round));
+}
+function generatorRoundDir(unitRoot, round) {
+  return join17(roundDir(unitRoot, round), "generator");
+}
+function evaluatorRoundDir(unitRoot, round) {
+  return join17(roundDir(unitRoot, round), "evaluator");
+}
+function evaluatorVerdictSprintRelative(slug, round) {
+  return join17("execution", slug, "rounds", String(round), "evaluator", "evaluation.md");
+}
 
 // src/integration/persistence/done-criteria-reader.ts
 import { readFile as readFile8 } from "fs/promises";
@@ -9737,7 +9614,7 @@ var BranchPreflightUseCase = class {
 };
 
 // src/business/usecases/evaluate/evaluate-and-fix-loop.ts
-import { join as join19 } from "path";
+import { join as join18 } from "path";
 
 // src/business/usecases/_shared/add-dir-args.ts
 function buildAdditionalCwdArgs(paths) {
@@ -9758,6 +9635,24 @@ function renderFileHandoffWrapper(promptFilePath) {
     "Follow the protocol in that file exactly."
   ].join("\n");
 }
+function renderFixHandoffWrapper(promptFilePath, critique) {
+  const safeCritique = critique.replace(/<\/evaluator-critique>/g, "<\\/evaluator-critique>");
+  return [
+    "You are an agent under the ralphctl harness \u2014 resuming on a fix round.",
+    "",
+    "The evaluator from the previous round flagged the work as not yet complete.",
+    "Its critique follows verbatim \u2014 read it FIRST, before doing anything else:",
+    "",
+    "<evaluator-critique>",
+    safeCritique,
+    "</evaluator-critique>",
+    "",
+    `Then re-read the task spec at \`${promptFilePath}\` to refresh the success criteria.`,
+    "",
+    "Address every dimension flagged failed. Do not regress the dimensions that already passed.",
+    "When the work is complete, emit `<task-complete>` per the spec."
+  ].join("\n");
+}
 
 // src/business/usecases/evaluate/evaluate-task.ts
 var MAX_MALFORMED_CRITIQUE_CHARS = 500;
@@ -9897,9 +9792,6 @@ var EvaluateAndFixLoopUseCase = class {
         history: []
       });
     }
-    const evaluatorPromptPath = AbsolutePath.trustString(
-      input.evaluateWorkspaceDir !== void 0 ? join19(input.evaluateWorkspaceDir, "evaluator-prompt.md") : join19(String(input.contextsDir), `evaluate-${String(input.task.id)}.md`)
-    );
     const history = [];
     let previousSignal;
     let previousCritique;
@@ -9923,18 +9815,21 @@ var EvaluateAndFixLoopUseCase = class {
           });
         }
       }
+      const evaluatorPromptPath = AbsolutePath.trustString(
+        join18(evaluatorRoundDir(input.evaluateWorkspaceDir, round), "prompt.md")
+      );
       const evalPromptResult = await this.prompts.buildEvaluatePrompt({
         task: input.task,
         sprint: input.sprint,
+        evaluateWorkspaceDir: input.evaluateWorkspaceDir,
         ...previousCritique !== void 0 ? { previousCritique } : {},
-        ...input.evaluateWorkspaceDir !== void 0 ? { evaluateWorkspaceDir: input.evaluateWorkspaceDir } : {},
         ...input.doneCriteriaBullet !== void 0 ? { doneCriteriaBullet: input.doneCriteriaBullet } : {}
       });
       if (!evalPromptResult.ok) return Result.error(evalPromptResult.error);
       const written = await this.writeContextFile.write(evaluatorPromptPath, evalPromptResult.value);
       if (!written.ok) return Result.error(written.error);
       const evaluatorCwd = input.evaluateSessionCwd ?? input.cwd;
-      const evaluatorSessionMdPath = input.nextSessionMdPath ? await input.nextSessionMdPath("evaluator") : void 0;
+      const evaluatorSessionMdPath = input.nextSessionMdPath ? await input.nextSessionMdPath("evaluator", round) : void 0;
       const evalResult = await this.evaluator.execute({
         task: input.task,
         sprint: input.sprint,
@@ -9947,6 +9842,16 @@ var EvaluateAndFixLoopUseCase = class {
       if (!evalResult.ok) return Result.error(evalResult.error);
       const { outcome, signal, fullCritique } = evalResult.value;
       history.push({ round, outcome, signal, critique: fullCritique });
+      const verdictPath = AbsolutePath.trustString(
+        join18(evaluatorRoundDir(input.evaluateWorkspaceDir, round), "evaluation.md")
+      );
+      const verdictWritten = await this.writeContextFile.write(verdictPath, fullCritique);
+      if (!verdictWritten.ok) {
+        log.warn("failed to persist per-round evaluator verdict", {
+          round,
+          error: verdictWritten.error.message
+        });
+      }
       log.info(`evaluator round complete for task ${String(input.task.id)}`, { round, outcome });
       if (outcome === "passed") break;
       if (outcome === "malformed") {
@@ -9972,7 +9877,8 @@ var EvaluateAndFixLoopUseCase = class {
         break;
       }
       log.info("resuming generator with critique", { round });
-      const generatorSessionMdPath = input.nextSessionMdPath ? await input.nextSessionMdPath("generator") : void 0;
+      const fixRound = round + 1;
+      const generatorSessionMdPath = input.nextSessionMdPath ? await input.nextSessionMdPath("generator", fixRound) : void 0;
       const fixResult = await this.generator.execute({
         task: input.task,
         sprint: input.sprint,
@@ -9980,6 +9886,7 @@ var EvaluateAndFixLoopUseCase = class {
         promptFilePath: input.executePromptFilePath,
         ...resumeSessionId !== void 0 ? { resumeSessionId } : {},
         ...generatorSessionMdPath !== void 0 ? { sessionMdPath: generatorSessionMdPath } : {},
+        fixContext: { critique: fullCritique },
         ...input.abortSignal !== void 0 ? { abortSignal: input.abortSignal } : {}
       });
       if (!fixResult.ok) return Result.error(fixResult.error);
@@ -9991,8 +9898,8 @@ var EvaluateAndFixLoopUseCase = class {
           projectPath: input.cwd,
           checkScript: input.checkScript
         });
-        if (!checkResult.ok) return Result.error(checkResult.error);
-        if (!checkResult.value.passed) {
+        if (!checkResult.ok) {
+          if (checkResult.error.code !== "check-failed") return Result.error(checkResult.error);
           log.warn("post-task check failed after fix attempt \u2014 re-evaluating anyway", { round });
         }
       }
@@ -10039,7 +9946,7 @@ var ExecuteSingleTaskUseCase = class {
       taskId: input.task.id,
       projectPath: input.cwd
     });
-    const wrapper = renderFileHandoffWrapper(input.promptFilePath);
+    const wrapper = input.fixContext !== void 0 ? renderFixHandoffWrapper(input.promptFilePath, input.fixContext.critique) : renderFileHandoffWrapper(input.promptFilePath);
     log.info(`executing task ${String(input.task.id)}${formatNameSuffix2(input.task.name)}`);
     const sessionOptions = {
       cwd: input.cwd,
@@ -10109,6 +10016,22 @@ function formatNameSuffix2(name) {
   return ` \u2014 "${slice}"`;
 }
 
+// src/domain/errors/check-failed-error.ts
+var CheckFailedError = class extends Error {
+  /** Discriminator. `as const` keeps it narrow at the type level. */
+  code = "check-failed";
+  /** Captured output of the failing script — surfaced to logs / progress. */
+  output;
+  constructor(opts) {
+    super(opts.message ?? "post-task check script failed");
+    this.name = "CheckFailedError";
+    this.output = opts.output;
+    if (opts.cause !== void 0) {
+      this.cause = opts.cause;
+    }
+  }
+};
+
 // src/business/usecases/execute/post-task-check.ts
 var PostTaskCheckUseCase = class {
   constructor(external, logger) {
@@ -10131,10 +10054,11 @@ var PostTaskCheckUseCase = class {
       input.timeoutMs
     );
     if (!result.passed) {
-      log.warn("post-task check failed");
+      log.warn("post-task check failed", { output: result.output });
+      return Result.error(new CheckFailedError({ output: result.output }));
     }
     return Result.ok({
-      passed: result.passed,
+      passed: true,
       output: result.output,
       skipped: false
     });
@@ -10292,8 +10216,7 @@ function buildExecutionUnitLeaf(deps, opts = {}) {
       ...ctx,
       executionUnitRoot: out.root,
       executionAddDirs: out.addDirs,
-      executionSessionCwd: out.sessionCwd,
-      executionEvaluationMdPath: out.evaluationMdPath
+      executionSessionCwd: out.sessionCwd
     })
   });
 }
@@ -10307,8 +10230,21 @@ function collectPriorEvaluations(tasks) {
   return map;
 }
 
+// src/application/chains/leaves/noop-leaf.ts
+function noopLeaf(name) {
+  return new Leaf(name, {
+    useCase: {
+      execute(input) {
+        return Promise.resolve(Result.ok(input));
+      }
+    },
+    input: (ctx) => ctx,
+    output: (_, ctx) => ctx
+  });
+}
+
 // src/application/chains/leaves/render-prompt-to-file.ts
-import { join as join20 } from "path";
+import { join as join19 } from "path";
 function renderPromptToFileLeaf(deps, opts) {
   return new Leaf("render-prompt-to-file", {
     useCase: {
@@ -10338,7 +10274,7 @@ function defaultPromptPath(ctx, opts) {
   const sprintDir = storagePaths.sprintDir(ctx.sprintId);
   const id = opts.identifier(ctx);
   const basename4 = id.length > 0 ? `${opts.flowName}-${id}.md` : `${opts.flowName}.md`;
-  return AbsolutePath.trustString(join20(sprintDir, "contexts", basename4));
+  return AbsolutePath.trustString(join19(sprintDir, "contexts", basename4));
 }
 
 // src/application/chains/execute/per-task-flow.ts
@@ -10385,18 +10321,30 @@ function createPerTaskFlow(deps, opts) {
     catchIf: (err) => err.code === "aborted",
     fallback: markCancelledFallbackLeaf(deps)
   });
-  const buildEvalWorkspaceStep = buildExecutionUnitLeaf({
-    sessionFolderBuilder: deps.sessionFolderBuilder,
-    aiSession: deps.aiSession
-  });
-  const evaluatorAsLeaf = new OnError(
-    new Sequential("evaluate", [buildEvalWorkspaceStep, evaluateLoopLeaf(deps, evaluateLoop)]),
+  const buildEvalWorkspaceStep = new OnError(
+    buildExecutionUnitLeaf({
+      sessionFolderBuilder: deps.sessionFolderBuilder,
+      aiSession: deps.aiSession
+    }),
     {
       catchIf: (err) => err.code !== "aborted",
-      fallback: noopLeaf("evaluate-task-noop")
+      fallback: noopLeaf("build-execution-unit-noop")
+    }
+  );
+  const evaluateLoopStep = new OnError(evaluateLoopLeaf(deps, evaluateLoop), {
+    catchIf: (err) => err.code !== "aborted",
+    fallback: noopLeaf("evaluate-task-noop")
+  });
+  const postTaskStep = new OnError(
+    new OnError(postTaskCheckLeaf(postCheck), {
+      catchIf: (err) => err.code === "check-failed",
+      fallback: postTaskCheckBlockedFallbackLeaf(deps)
+    }),
+    {
+      catchIf: (err) => err.code !== "aborted" && err.code !== "check-failed",
+      fallback: noopLeaf("post-task-check-noop")
     }
   );
-  const postTaskStep = postTaskCheckLeaf(postCheck);
   const renderPromptStep = renderPromptToFileLeaf(
     { writeContextFile: deps.writeContextFile },
     {
@@ -10405,7 +10353,7 @@ function createPerTaskFlow(deps, opts) {
       path: (ctx) => {
         const slug = unitSlug(String(ctx.task.id), ctx.task.name);
         const root = resolveStoragePaths().executionUnitDir(ctx.sprintId, slug);
-        return AbsolutePath.trustString(join21(String(root), "prompt.md"));
+        return AbsolutePath.trustString(join20(String(root), "prompt.md"));
       },
       buildPrompt: (ctx) => deps.prompts.buildExecutePrompt({
         task: ctx.task,
@@ -10418,9 +10366,10 @@ function createPerTaskFlow(deps, opts) {
     branchPreflightStep,
     markInProgressLeaf(deps),
     renderPromptStep,
+    buildEvalWorkspaceStep,
     executeTaskStep,
     postTaskStep,
-    evaluatorAsLeaf,
+    evaluateLoopStep,
     commitTaskLeaf(deps),
     markDoneLeaf(deps)
   ]);
@@ -10463,6 +10412,22 @@ function markBlockedFallbackLeaf(deps) {
     output: (ctx, task) => ({ ...ctx, task, taskBlocked: true })
   });
 }
+function postTaskCheckBlockedFallbackLeaf(deps) {
+  return new Leaf("mark-blocked-check", {
+    useCase: {
+      async execute(input) {
+        const transitioned = input.task.markBlocked("post-task check failed");
+        if (!transitioned.ok) return Result.error(transitioned.error);
+        const saved = await deps.taskRepo.update(input.sprintId, transitioned.value);
+        if (!saved.ok) return Result.error(saved.error);
+        deps.signalBus.emit({ type: "task-finished", taskId: transitioned.value.id, status: "blocked" });
+        return Result.ok(transitioned.value);
+      }
+    },
+    input: (ctx) => ({ sprintId: ctx.sprintId, task: ctx.task }),
+    output: (ctx, task) => ({ ...ctx, task, taskBlocked: true })
+  });
+}
 function markCancelledFallbackLeaf(deps) {
   return new Leaf("mark-cancelled", {
     useCase: {
@@ -10498,6 +10463,7 @@ function markInProgressLeaf(deps) {
   });
 }
 function executeTaskLeaf(useCase) {
+  let attempt = 0;
   return new Leaf("execute-task", {
     useCase: {
       async execute(input) {
@@ -10510,7 +10476,9 @@ function executeTaskLeaf(useCase) {
             message: "execute-task: promptFilePath is missing \u2014 render-prompt-to-file must run first"
           });
         }
-        const sessionMdPath = input.executionUnitRoot !== void 0 ? AbsolutePath.trustString(await nextSessionPath(String(input.executionUnitRoot))) : void 0;
+        attempt += 1;
+        const filename = attempt === 1 ? "session.md" : `session-attempt-${String(attempt)}.md`;
+        const sessionMdPath = input.executionUnitRoot !== void 0 ? AbsolutePath.trustString(join20(generatorRoundDir(String(input.executionUnitRoot), 1), filename)) : void 0;
         const result = await useCase.execute({
           sprint: input.sprint,
           task: input.task,
@@ -10618,19 +10586,21 @@ function evaluateLoopLeaf(deps, loop) {
         if (input.taskBlocked) {
           return Result.ok({ task: input.task });
         }
-        const doneCriteriaBullet = input.executionUnitRoot !== void 0 ? await readDoneCriteriaBullet(
-          join21(String(input.executionUnitRoot), "done-criteria.md"),
-          String(input.task.id)
-        ) : "";
+        if (input.executionUnitRoot === void 0) {
+          return Result.ok({ task: input.task });
+        }
         if (input.promptFilePath === void 0) {
           return Result.error({
             code: "invalid-state",
             message: "evaluate-task: promptFilePath is missing \u2014 render-prompt-to-file must run first"
           });
         }
-        const contextsDir = AbsolutePath.trustString(dirname11(String(input.promptFilePath)));
-        const unitMounted = input.executionUnitRoot !== void 0;
-        const refreshWorkspace = unitMounted ? async () => {
+        const unitRoot = input.executionUnitRoot;
+        const doneCriteriaBullet = await readDoneCriteriaBullet(
+          join20(String(unitRoot), "done-criteria.md"),
+          String(input.task.id)
+        );
+        const refreshWorkspace = async () => {
           await deps.aiSession.ensureReady();
           const aiProvider = deps.aiSession.getProviderName();
           const priorEvaluations = collectPriorEvaluations2(input.tasks);
@@ -10641,30 +10611,34 @@ function evaluateLoopLeaf(deps, loop) {
             aiProvider,
             priorEvaluations
           });
-        } : void 0;
-        const unitRoot = input.executionUnitRoot;
-        const nextSessionMdPath = unitRoot ? async () => AbsolutePath.trustString(await nextSessionPath(String(unitRoot))) : void 0;
+        };
+        const nextSessionMdPath = (kind, round) => {
+          const dir = kind === "generator" ? generatorRoundDir : evaluatorRoundDir;
+          return Promise.resolve(AbsolutePath.trustString(join20(dir(String(unitRoot), round), "session.md")));
+        };
         const result = await loop.execute({
           task: input.task,
           sprint: input.sprint,
           cwd: input.cwd,
           executePromptFilePath: String(input.promptFilePath),
-          contextsDir,
+          evaluateWorkspaceDir: String(unitRoot),
+          refreshWorkspace,
+          nextSessionMdPath,
           ...input.checkScript !== void 0 ? { checkScript: input.checkScript } : {},
           ...input.resumeSessionId !== void 0 ? { resumeSessionId: input.resumeSessionId } : {},
           ...input.executionAddDirs !== void 0 ? { addDirs: input.executionAddDirs } : {},
           ...input.executionSessionCwd !== void 0 ? { evaluateSessionCwd: input.executionSessionCwd } : {},
-          ...input.executionUnitRoot !== void 0 ? { evaluateWorkspaceDir: String(input.executionUnitRoot) } : {},
-          ...refreshWorkspace !== void 0 ? { refreshWorkspace } : {},
-          ...nextSessionMdPath !== void 0 ? { nextSessionMdPath } : {},
           ...doneCriteriaBullet.length > 0 ? { doneCriteriaBullet } : {}
         });
         if (!result.ok) return Result.error(result.error);
         if (result.value.rounds > 0 && result.value.finalSignal !== null) {
+          const finalRound = result.value.rounds;
+          const slug = unitSlug(String(input.task.id), input.task.name);
+          const file = evaluatorVerdictSprintRelative(slug, finalRound);
           const recorded = input.task.recordEvaluation({
             status: result.value.finalSignal.status,
             output: result.value.finalCritique.slice(0, MAX_PREVIEW_CHARS),
-            file: input.executionEvaluationMdPath !== void 0 ? String(input.executionEvaluationMdPath) : `execution/${String(input.task.id)}/evaluation.md`
+            file
           });
           const saved = await deps.taskRepo.update(input.sprintId, recorded);
           if (!saved.ok) return Result.error(saved.error);
@@ -10685,8 +10659,7 @@ function evaluateLoopLeaf(deps, loop) {
       taskBlocked: ctx.taskBlocked === true,
       ...ctx.executionUnitRoot !== void 0 ? { executionUnitRoot: ctx.executionUnitRoot } : {},
       ...ctx.executionAddDirs !== void 0 ? { executionAddDirs: ctx.executionAddDirs } : {},
-      ...ctx.executionSessionCwd !== void 0 ? { executionSessionCwd: ctx.executionSessionCwd } : {},
-      ...ctx.executionEvaluationMdPath !== void 0 ? { executionEvaluationMdPath: ctx.executionEvaluationMdPath } : {}
+      ...ctx.executionSessionCwd !== void 0 ? { executionSessionCwd: ctx.executionSessionCwd } : {}
     }),
     // Push the recorded task back onto the context so the downstream
     // `mark-done` leaf carries the evaluation forward when it flips
@@ -10751,17 +10724,6 @@ function commitTaskLeaf(deps) {
     output: (ctx, task) => ({ ...ctx, task })
   });
 }
-function noopLeaf(name) {
-  return new Leaf(name, {
-    useCase: {
-      execute(input) {
-        return Promise.resolve(Result.ok(input));
-      }
-    },
-    input: (ctx) => ctx,
-    output: (_, ctx) => ctx
-  });
-}
 
 // src/application/chains/execute/execute-flow.ts
 function createExecuteFlow(deps, opts) {
@@ -10784,7 +10746,8 @@ function createExecuteFlow(deps, opts) {
   const initializeStep = new Sequential("initialize", [
     resolveBranchLeaf(deps),
     dirtyTreePreflightLeaf(deps, opts),
-    checkScriptsSprintStartLeaf(deps)
+    resolveCheckScriptsLeaf(deps),
+    setupScriptsSprintStartLeaf(deps)
   ]);
   return new Sequential("execute", [
     loadSprintLeaf({ sprintRepo: deps.sprintRepo }),
@@ -10974,14 +10937,16 @@ function bridgePerTaskChain(task, inner, opts, taskRepo) {
       async execute(input) {
         const fresh = await taskRepo.findBySprintId(input.sprintId);
         const liveTasks = fresh.ok ? fresh.value : input.tasks ?? opts.tasks;
+        const liveSprint = input.sprint ?? opts.sprint;
+        const resolvedCheckScript = input.checkScript ?? input.checkScripts?.get(task.projectPath);
         const innerCtx = {
           sprintId: input.sprintId,
-          sprint: opts.sprint,
+          sprint: liveSprint,
           task,
           tasks: liveTasks,
           cwd: task.projectPath,
           expectedBranch: input.expectedBranch,
-          ...input.checkScript !== void 0 ? { checkScript: input.checkScript } : {},
+          ...resolvedCheckScript !== void 0 ? { checkScript: resolvedCheckScript } : {},
           ...input.noCommit === true ? { noCommit: true } : {}
         };
         const innerResult = await inner.execute(innerCtx);
@@ -11083,33 +11048,118 @@ function assertTasksAcyclicLeaf(sortResult) {
     output: (ctx) => ctx
   });
 }
-function checkScriptsSprintStartLeaf(deps) {
+function resolveCheckScriptsLeaf(deps) {
+  return new Leaf("resolve-check-scripts", {
+    useCase: {
+      async execute(input) {
+        const map = /* @__PURE__ */ new Map();
+        const repoPaths = input.sprint.affectedRepositories;
+        if (repoPaths.length === 0) {
+          return Result.ok(map);
+        }
+        const project = await deps.projectRepo.findByName(input.sprint.projectName);
+        if (!project.ok) {
+          deps.logger.warn(
+            `resolve-check-scripts: project ${String(input.sprint.projectName)} not found \u2014 per-task gate will skip`,
+            { error: project.error.message }
+          );
+          return Result.ok(map);
+        }
+        for (const repoPath of repoPaths) {
+          const repo = project.value.repositories.find((r) => r.path === repoPath);
+          if (repo === void 0) continue;
+          const script = repo.checkScript;
+          if (script === void 0 || script.length === 0) continue;
+          map.set(repoPath, script);
+        }
+        return Result.ok(map);
+      }
+    },
+    input: (ctx) => {
+      if (!ctx.sprint) throw new Error("resolve-check-scripts: ctx.sprint must be loaded first");
+      return { sprint: ctx.sprint };
+    },
+    output: (ctx, checkScripts) => ({ ...ctx, checkScripts })
+  });
+}
+function setupScriptsSprintStartLeaf(deps) {
   return new Leaf(
-    "check-scripts-sprint-start",
+    "setup-scripts-sprint-start",
     {
       useCase: {
         async execute(input) {
-          if (input.checkScript === void 0 || input.checkScript.length === 0) {
-            return Promise.resolve(Result.ok(void 0));
+          const repoPaths = input.sprint.affectedRepositories;
+          if (repoPaths.length === 0) {
+            return Result.ok(void 0);
           }
-          const r = await deps.external.runCheckScript(input.cwd, input.checkScript, "sprint-start");
-          if (!r.passed) {
-            return Result.error(
-              new InvalidStateError({
-                entity: "sprint",
-                currentState: "check-failed",
-                attemptedAction: "execute",
-                message: "sprint-start check script failed"
-              })
+          const project = await deps.projectRepo.findByName(input.sprint.projectName);
+          if (!project.ok) {
+            deps.logger.warn(
+              `setup-scripts-sprint-start: project ${String(input.sprint.projectName)} not found \u2014 skipping setup`,
+              { error: project.error.message }
             );
+            return Result.ok(void 0);
+          }
+          let sprint = input.sprint;
+          const now = IsoTimestamp.trustString((/* @__PURE__ */ new Date()).toISOString());
+          for (const repoPath of repoPaths) {
+            if (input.sprint.setupRanAt.has(repoPath)) {
+              const stampedAt = input.sprint.setupRanAt.get(repoPath);
+              deps.logger.debug(
+                `setup-scripts-sprint-start: skipping ${String(repoPath)} \u2014 already stamped at ${String(stampedAt)}`
+              );
+              continue;
+            }
+            const repo = project.value.repositories.find((r) => r.path === repoPath);
+            if (repo === void 0) {
+              continue;
+            }
+            const script = repo.setupScript;
+            if (script === void 0 || script.length === 0) {
+              continue;
+            }
+            let outcome;
+            try {
+              outcome = await deps.external.runSetupScript(repoPath, script, repo.checkTimeout);
+            } catch (err) {
+              return Result.error(
+                new InvalidStateError({
+                  entity: "sprint",
+                  currentState: "setup-failed",
+                  attemptedAction: "execute",
+                  message: `sprint-start setup script failed in ${String(repoPath)}: ${err instanceof Error ? err.message : String(err)}`,
+                  hint: "Fix the setup script (configured via `project onboard` / `project repo add`) and retry. Setup runs once at sprint start; the per-task `checkScript` is a separate gate."
+                })
+              );
+            }
+            if (!outcome.passed) {
+              return Result.error(
+                new InvalidStateError({
+                  entity: "sprint",
+                  currentState: "setup-failed",
+                  attemptedAction: "execute",
+                  message: `sprint-start setup script failed in ${String(repoPath)}`,
+                  hint: "Fix the setup script (configured via `project onboard` / `project repo add`) and retry. Setup runs once at sprint start; the per-task `checkScript` is a separate gate."
+                })
+              );
+            }
+            sprint = sprint.recordSetupRun(repoPath, now);
+          }
+          if (sprint !== input.sprint) {
+            const saved = await deps.sprintRepo.save(sprint);
+            if (!saved.ok) {
+              deps.logger.warn("setup-scripts-sprint-start: failed to persist setup audit stamps", {
+                error: saved.error.message
+              });
+            }
           }
           return Result.ok(void 0);
         }
       },
-      input: (ctx) => ({
-        cwd: ctx.cwd,
-        ...ctx.checkScript !== void 0 ? { checkScript: ctx.checkScript } : {}
-      }),
+      input: (ctx) => {
+        if (!ctx.sprint) throw new Error("setup-scripts-sprint-start: ctx.sprint must be loaded first");
+        return { sprintId: ctx.sprintId, sprint: ctx.sprint };
+      },
       output: (ctx) => ctx
     }
   );
@@ -11206,10 +11256,10 @@ function applyFeedbackLeaf(useCase) {
           });
         }
         const { resolveStoragePaths: resolveStoragePaths2 } = await import("./storage-paths-IPNZZM5D.mjs");
-        const { join: join35 } = await import("path");
+        const { join: join34 } = await import("path");
         const sprintDir = resolveStoragePaths2().sprintDir(input.sprintId);
         const { AbsolutePath: APV } = await import("./absolute-path-WUTZQ37D.mjs");
-        const sessionMdPath = APV.trustString(join35(sprintDir, "feedback", `session-${String(input.iteration)}.md`));
+        const sessionMdPath = APV.trustString(join34(sprintDir, "feedback", `session-${String(input.iteration)}.md`));
         const result = await useCase.execute({
           sprint: input.sprint,
           promptFilePath: String(input.promptFilePath),
@@ -11246,7 +11296,7 @@ function recordFeedbackIterationLeaf(logger) {
           try {
             const { resolveStoragePaths: resolveStoragePaths2 } = await import("./storage-paths-IPNZZM5D.mjs");
             const { mkdir: mkdir16, appendFile: appendFile4 } = await import("fs/promises");
-            const { dirname: dirname17 } = await import("path");
+            const { dirname: dirname16 } = await import("path");
             const path = resolveStoragePaths2().feedbackFile(input.sprintId);
             const stamp = (/* @__PURE__ */ new Date()).toISOString();
             const block = `
@@ -11256,7 +11306,7 @@ function recordFeedbackIterationLeaf(logger) {
 
 ${input.feedbackText.trim()}
 `;
-            await mkdir16(dirname17(path), { recursive: true });
+            await mkdir16(dirname16(path), { recursive: true });
             await appendFile4(path, block, "utf-8");
           } catch (err) {
             logger.warn("feedback: failed to append to feedback.md", {
@@ -11718,8 +11768,8 @@ function saveSprintLeaf(deps, name = "save-sprint") {
 }
 
 // src/application/chains/leaves/save-tasks.ts
-import { writeFile as writeFile8 } from "fs/promises";
-import { dirname as dirname12 } from "path";
+import { writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname11 } from "path";
 import { mkdir as mkdir12 } from "fs/promises";
 var FALLBACK_CRITERION = "(no explicit criteria \u2014 use task description as proxy)";
 function renderDoneCriteria(tasks) {
@@ -11745,9 +11795,9 @@ function saveTasksLeaf(deps, name = "save-tasks") {
         const storage2 = resolveStoragePaths();
         const criteriaPath = String(storage2.doneCriteriaFile(input.sprintId));
         try {
-          await mkdir12(dirname12(criteriaPath), { recursive: true });
+          await mkdir12(dirname11(criteriaPath), { recursive: true });
           const body = renderDoneCriteria(input.tasks);
-          await writeFile8(criteriaPath, body, { encoding: "utf-8", mode: 384 });
+          await writeFile7(criteriaPath, body, { encoding: "utf-8", mode: 384 });
         } catch (err) {
           return Result.error(
             new StorageError({
@@ -11850,11 +11900,11 @@ function ideateAndPlanLeaf(useCase) {
 
 // src/application/chains/onboard/onboard-load-leaves.ts
 import { readFile as readFile9 } from "fs/promises";
-import { join as join23 } from "path";
+import { join as join22 } from "path";
 
 // src/application/chains/onboard/onboard-persist-leaves.ts
-import { mkdir as mkdir13, writeFile as writeFile9 } from "fs/promises";
-import { dirname as dirname13, join as join22 } from "path";
+import { mkdir as mkdir13, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname12, join as join21 } from "path";
 var HARNESS_MARKER_PREFIX = "<!-- ralphctl onboard:";
 function makeMarker(now = () => /* @__PURE__ */ new Date()) {
   return `${HARNESS_MARKER_PREFIX} ${now().toISOString()} -->`;
@@ -11867,14 +11917,14 @@ function writeContextFileLeaf(now = () => /* @__PURE__ */ new Date()) {
         if (proposals === void 0 || accepted === null || accepted === void 0 || accepted.length === 0) {
           return Result.ok(void 0);
         }
-        const targetPath = join22(repo.path, proposals.contextFilePath);
+        const targetPath = join21(repo.path, proposals.contextFilePath);
         try {
-          await mkdir13(dirname13(targetPath), { recursive: true });
+          await mkdir13(dirname12(targetPath), { recursive: true });
           const marker = makeMarker(now);
           const firstLine = accepted.split("\n", 1)[0] ?? "";
           const body = firstLine.startsWith(HARNESS_MARKER_PREFIX) ? accepted : `${marker}
 ${accepted}`;
-          await writeFile9(targetPath, body, "utf-8");
+          await writeFile8(targetPath, body, "utf-8");
           return Result.ok(void 0);
         } catch (err) {
           return Result.error(
@@ -11946,7 +11996,7 @@ var PRE_EXISTING_CONTEXT_FILES = ["CLAUDE.md", ".github/copilot-instructions.md"
 async function findExistingContextFiles(repoPath) {
   const found = [];
   for (const relPath of PRE_EXISTING_CONTEXT_FILES) {
-    const fullPath = join23(repoPath, relPath);
+    const fullPath = join22(repoPath, relPath);
     let body;
     try {
       body = await readFile9(fullPath, "utf-8");
@@ -12066,7 +12116,7 @@ function detectExistingFilesLeaf(deps) {
 
 // src/application/chains/onboard/onboard-ai-leaves.ts
 import { readFile as readFile10 } from "fs/promises";
-import { join as join24 } from "path";
+import { join as join23 } from "path";
 
 // src/business/usecases/onboard/onboard-repo.ts
 function contextFilePathFor(provider) {
@@ -12223,7 +12273,7 @@ function runOnboardAiLeaf(deps) {
         await deps.aiSession.ensureReady();
         const provider = deps.aiSession.getProviderName();
         const fileName = contextFilePathFor(provider);
-        const targetPath = join24(input.repo.path, fileName);
+        const targetPath = join23(input.repo.path, fileName);
         const detected = await detectModeAndBody(targetPath);
         const result = await useCase.execute({
           project: input.project,
@@ -12380,11 +12430,11 @@ function createOnboardFlow(deps, opts) {
 
 // src/application/chains/plan/plan-flow.ts
 import { mkdir as mkdir14 } from "fs/promises";
-import { dirname as dirname15, join as join25 } from "path";
+import { dirname as dirname14, join as join24 } from "path";
 
 // src/business/usecases/plan/plan-sprint-tasks.ts
 import { readFile as readFile11 } from "fs/promises";
-import { dirname as dirname14 } from "path";
+import { dirname as dirname13 } from "path";
 var PlanSprintTasksUseCase = class {
   constructor(ai, logger) {
     this.ai = ai;
@@ -12456,8 +12506,8 @@ var PlanSprintTasksUseCase = class {
   // the whole spec before the user sees any response.
   async runInteractive(input, wrapper, log) {
     const handover = input.runInTerminal ?? (async (fn) => fn());
-    const promptDir = dirname14(input.promptFilePath);
-    const outputDir = input.outputFilePath !== void 0 ? dirname14(input.outputFilePath) : promptDir;
+    const promptDir = dirname13(input.promptFilePath);
+    const outputDir = input.outputFilePath !== void 0 ? dirname13(input.outputFilePath) : promptDir;
     const repoArgs = buildAdditionalCwdArgs(input.additionalRepoPaths);
     const extraArgs = [...repoArgs, "--add-dir", promptDir];
     if (outputDir !== promptDir) {
@@ -12628,7 +12678,7 @@ function createPlanFlow(deps, opts) {
         if (!ctx.planningFolderRoot) {
           throw new Error("render-prompt-to-file: ctx.planningFolderRoot must be set by build-planning-folder");
         }
-        return AbsolutePath.trustString(join25(String(ctx.planningFolderRoot), "prompt.md"));
+        return AbsolutePath.trustString(join24(String(ctx.planningFolderRoot), "prompt.md"));
       },
       buildPrompt: (ctx) => {
         if (!ctx.sprint) {
@@ -12750,7 +12800,7 @@ function planTasksLeaf(useCase, opts) {
     useCase: {
       async execute(input) {
         if (opts.outputFilePath !== void 0 && opts.outputFilePath !== "") {
-          await mkdir14(dirname15(opts.outputFilePath), { recursive: true });
+          await mkdir14(dirname14(opts.outputFilePath), { recursive: true });
         }
         const result = await useCase.execute({
           sprint: input.sprint,
@@ -12914,11 +12964,11 @@ function assertAllTicketsApprovedLeaf() {
 }
 
 // src/application/chains/refine/refine-flow.ts
-import { join as join26 } from "path";
+import { join as join25 } from "path";
 
 // src/business/usecases/refine/refine-single-ticket.ts
 import { readFile as readFile12 } from "fs/promises";
-import { dirname as dirname16 } from "path";
+import { dirname as dirname15 } from "path";
 var RefineSingleTicketUseCase = class {
   constructor(ai, logger) {
     this.ai = ai;
@@ -12981,8 +13031,8 @@ var RefineSingleTicketUseCase = class {
   // scroll past before it responds.
   async runInteractive(input, wrapper, log) {
     const handover = input.runInTerminal ?? (async (fn) => fn());
-    const promptDir = dirname16(input.promptFilePath);
-    const outputDir = input.outputFilePath !== void 0 ? dirname16(input.outputFilePath) : promptDir;
+    const promptDir = dirname15(input.promptFilePath);
+    const outputDir = input.outputFilePath !== void 0 ? dirname15(input.outputFilePath) : promptDir;
     const addDirArgs = ["--add-dir", promptDir];
     if (outputDir !== promptDir) {
       addDirArgs.push("--add-dir", outputDir);
@@ -13195,7 +13245,7 @@ function buildPerTicketChain(deps, refineUseCase, ticket, opts) {
           if (!ctx.refinementUnitRoot) {
             throw new Error(`refine-${String(ticket.id)}: ctx.refinementUnitRoot must be set by build-refinement-unit`);
           }
-          return AbsolutePath.trustString(join26(String(ctx.refinementUnitRoot), "prompt.md"));
+          return AbsolutePath.trustString(join25(String(ctx.refinementUnitRoot), "prompt.md"));
         },
         buildPrompt: (ctx) => {
           const outputFilePath = ctx.refinementRequirementsJsonPath !== void 0 ? String(ctx.refinementRequirementsJsonPath) : void 0;
@@ -14485,18 +14535,24 @@ function stepGlyph(status, spinnerFrame) {
     return /* @__PURE__ */ jsx19(Text17, { color: inkColors.muted, bold: true, children: glyphs.emDash });
   return /* @__PURE__ */ jsx19(Text17, { color: inkColors.muted, bold: true, children: glyphs.phasePending });
 }
+var MAX_RENDERED_STEPS = 50;
 function StepTrace({ steps, isRunning }) {
   const spinnerFrame = useSpinnerFrame();
   if (steps.length === 0) {
     if (isRunning) return /* @__PURE__ */ jsx19(Spinner, { label: "Starting\u2026" });
     return /* @__PURE__ */ jsx19(Text17, { dimColor: true, children: "No steps recorded." });
   }
-  return /* @__PURE__ */ jsx19(Box18, { flexDirection: "column", children: steps.map((step, i) => /* @__PURE__ */ jsxs18(Box18, { children: [
-    stepGlyph(step.status, spinnerFrame),
-    /* @__PURE__ */ jsx19(Text17, { bold: step.status === void 0, children: `  ${step.name}` }),
-    step.durationMs !== void 0 ? /* @__PURE__ */ jsx19(Text17, { dimColor: true, children: `  ${glyphs.inlineDot} ${durationLabel(step.durationMs)}` }) : null,
-    step.errorMessage ? /* @__PURE__ */ jsx19(Text17, { color: inkColors.error, children: `  ${glyphs.emDash} ${step.errorMessage}` }) : null
-  ] }, i)) });
+  const visible = steps.length > MAX_RENDERED_STEPS ? steps.slice(-MAX_RENDERED_STEPS) : steps;
+  const elided = steps.length - visible.length;
+  return /* @__PURE__ */ jsxs18(Box18, { flexDirection: "column", children: [
+    elided > 0 ? /* @__PURE__ */ jsx19(Text17, { dimColor: true, children: `\u2026 ${String(elided)} earlier steps` }) : null,
+    visible.map((step, i) => /* @__PURE__ */ jsxs18(Box18, { children: [
+      stepGlyph(step.status, spinnerFrame),
+      /* @__PURE__ */ jsx19(Text17, { bold: step.status === void 0, children: `  ${step.name}` }),
+      step.durationMs !== void 0 ? /* @__PURE__ */ jsx19(Text17, { dimColor: true, children: `  ${glyphs.inlineDot} ${durationLabel(step.durationMs)}` }) : null,
+      step.errorMessage ? /* @__PURE__ */ jsx19(Text17, { color: inkColors.error, children: `  ${glyphs.emDash} ${step.errorMessage}` }) : null
+    ] }, i))
+  ] });
 }
 function CompactStepSummary({ steps }) {
   if (steps.length === 0) return /* @__PURE__ */ jsx19(Text17, { dimColor: true, children: "No steps recorded." });
@@ -14976,6 +15032,7 @@ var EXECUTE_HINTS_TERMINAL = [
 function isTaskStep2(name) {
   return /^task-[a-zA-Z0-9_-]+$/.test(name);
 }
+var MAX_LIVE_STEPS = 200;
 function ExecuteView({ sessionId, sessionManager, signalBus }) {
   const router = useRouterOptional();
   const cancelInFlight = useRef2(false);
@@ -15045,12 +15102,14 @@ function ExecuteView({ sessionId, sessionManager, signalBus }) {
             durationMs: entry.durationMs,
             errorMessage: entry.error?.message
           };
+          let next;
           if (idx >= 0) {
-            const next = [...prev];
+            next = [...prev];
             next[idx] = settled;
-            return next;
+          } else {
+            next = [...prev, settled];
           }
-          return [...prev, settled];
+          return next.length > MAX_LIVE_STEPS ? next.slice(-MAX_LIVE_STEPS) : next;
         });
         if (signalBus === void 0 || signalBus === null) {
           if (entry.stepName === "rate-limit-paused") setRateLimitVisible(true);
@@ -18544,13 +18603,13 @@ async function currentSprintReadableCheck(deps) {
 }
 
 // src/application/doctor/checks/data-dir-writable.ts
-import { mkdir as mkdir15, unlink as unlink3, writeFile as writeFile10 } from "fs/promises";
-import { join as join27 } from "path";
+import { mkdir as mkdir15, unlink as unlink3, writeFile as writeFile9 } from "fs/promises";
+import { join as join26 } from "path";
 async function dataDirWritableCheck(deps) {
-  const probe = join27(deps.storage.dataDir, `.doctor-write-${String(process.pid)}-${String(Date.now())}.tmp`);
+  const probe = join26(deps.storage.dataDir, `.doctor-write-${String(process.pid)}-${String(Date.now())}.tmp`);
   try {
     await mkdir15(deps.storage.dataDir, { recursive: true });
-    await writeFile10(probe, "doctor", { encoding: "utf-8", mode: 384 });
+    await writeFile9(probe, "doctor", { encoding: "utf-8", mode: 384 });
   } catch (err) {
     return {
       name: "Data directory",
@@ -18657,7 +18716,7 @@ function nodeVersionCheck() {
 
 // src/application/doctor/checks/onboarding-status.ts
 import { readFile as readFile13 } from "fs/promises";
-import { join as join28 } from "path";
+import { join as join27 } from "path";
 var HARNESS_MARKER_PREFIX2 = "<!-- ralphctl onboard:";
 var MIN_HYBRID_PROSE_CHARS = 200;
 var CONTEXT_FILE_BY_PROVIDER = {
@@ -18678,7 +18737,7 @@ function extractPreamble(body) {
   return body.slice(0, idx);
 }
 async function classifyContextFile(repoPath, relPath) {
-  const fullPath = join28(repoPath, relPath);
+  const fullPath = join27(repoPath, relPath);
   let body;
   try {
     body = await readFile13(fullPath, "utf-8");
@@ -18761,10 +18820,10 @@ async function onboardingStatusCheck(deps) {
 
 // src/application/doctor/checks/project-paths-exist.ts
 import { stat as stat5 } from "fs/promises";
-import { join as join29 } from "path";
+import { join as join28 } from "path";
 async function isGitDir(path) {
   try {
-    const s = await stat5(join29(path, ".git"));
+    const s = await stat5(join28(path, ".git"));
     return s.isDirectory() || s.isFile();
   } catch {
     return false;
@@ -18825,9 +18884,9 @@ async function projectPathsExistCheck(deps) {
 }
 
 // src/application/doctor/checks/session-log-path.ts
-import { join as join30 } from "path";
+import { join as join29 } from "path";
 function sessionLogPathCheck(deps) {
-  const file = join30(deps.storage.logsDir, `${deps.sessionId}.jsonl`);
+  const file = join29(deps.storage.logsDir, `${deps.sessionId}.jsonl`);
   return Promise.resolve({
     name: "Session log path",
     status: "pass",
@@ -18967,12 +19026,12 @@ function DoctorView() {
 
 // src/application/tui/views/browse/progress-view.tsx
 import { useEffect as useEffect39, useState as useState25 } from "react";
-import { join as join32 } from "path";
+import { join as join31 } from "path";
 import { Box as Box34, Text as Text29 } from "ink";
 
 // src/business/usecases/sprint/show-progress.ts
 import { readFile as readFile14 } from "fs/promises";
-import { join as join31 } from "path";
+import { join as join30 } from "path";
 var DEFAULT_STALE_THRESHOLD_HOURS = 24;
 var STALE_THRESHOLD_HOURS = DEFAULT_STALE_THRESHOLD_HOURS;
 var ISO_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})$/;
@@ -19058,7 +19117,7 @@ function detectBranchInconsistency(sprint, projects, external) {
   return out;
 }
 var ShowProgressUseCase = class {
-  constructor(sprints, tasks, projects, external, readFileImpl = (path) => readFile14(path, "utf-8"), progressPathForSprint = (sprintId) => join31(process.env["RALPHCTL_ROOT"] ?? "", "data", "sprints", String(sprintId), "progress.md")) {
+  constructor(sprints, tasks, projects, external, readFileImpl = (path) => readFile14(path, "utf-8"), progressPathForSprint = (sprintId) => join30(process.env["RALPHCTL_ROOT"] ?? "", "data", "sprints", String(sprintId), "progress.md")) {
     this.sprints = sprints;
     this.tasks = tasks;
     this.projects = projects;
@@ -19154,7 +19213,7 @@ function ProgressView() {
           deps.projectRepo,
           deps.external,
           void 0,
-          (id) => join32(String(deps.storage.sprintsDir), String(id), "progress.md")
+          (id) => join31(String(deps.storage.sprintsDir), String(id), "progress.md")
         );
         const result = await uc.execute({ sprintId, now: IsoTimestamp.now() });
         if (cancel.current) return;
@@ -19257,14 +19316,14 @@ function Timeline({ report }) {
 
 // src/application/tui/views/crud/sprint-export-requirements-view.tsx
 import { useEffect as useEffect40 } from "react";
-import { writeFile as writeFile11 } from "fs/promises";
+import { writeFile as writeFile10 } from "fs/promises";
 import { isAbsolute, resolve } from "path";
 
 // src/business/usecases/sprint/export-requirements.ts
 import { readFile as readFile15 } from "fs/promises";
 var ExportRequirementsUseCase = class {
-  constructor(writeFile15, readJsonFile2 = (p) => readFile15(p, "utf-8")) {
-    this.writeFile = writeFile15;
+  constructor(writeFile14, readJsonFile2 = (p) => readFile15(p, "utf-8")) {
+    this.writeFile = writeFile14;
     this.readJsonFile = readJsonFile2;
   }
   writeFile;
@@ -19337,7 +19396,7 @@ function SprintExportRequirementsView() {
       const finalPath = trimmed.length === 0 ? defaultPath : isAbsolute(trimmed) ? trimmed : resolve(process.cwd(), trimmed);
       setStep("Writing file\u2026");
       const aggregatePath = resolveStoragePaths().requirementsAggregateFile(sprintId);
-      const uc = new ExportRequirementsUseCase((p, b) => writeFile11(p, b, "utf-8"));
+      const uc = new ExportRequirementsUseCase((p, b) => writeFile10(p, b, "utf-8"));
       const result = await uc.execute({
         aggregatePath,
         outputPath: AbsolutePath.trustString(finalPath)
@@ -19374,16 +19433,16 @@ function SprintExportRequirementsView() {
 
 // src/application/tui/views/crud/sprint-export-context-view.tsx
 import { useEffect as useEffect41 } from "react";
-import { writeFile as writeFile12 } from "fs/promises";
+import { writeFile as writeFile11 } from "fs/promises";
 import { isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
 
 // src/business/usecases/sprint/export-context.ts
 var ExportContextUseCase = class {
-  constructor(sprints, tasks, projects, writeFile15) {
+  constructor(sprints, tasks, projects, writeFile14) {
     this.sprints = sprints;
     this.tasks = tasks;
     this.projects = projects;
-    this.writeFile = writeFile15;
+    this.writeFile = writeFile14;
   }
   sprints;
   tasks;
@@ -19545,7 +19604,7 @@ function SprintExportContextView() {
         deps.sprintRepo,
         deps.taskRepo,
         deps.projectRepo,
-        (p, b) => writeFile12(p, b, "utf-8")
+        (p, b) => writeFile11(p, b, "utf-8")
       );
       const result = await uc.execute({
         sprintId,
@@ -20128,7 +20187,7 @@ async function handleCompletionRequest(program, deps) {
 // src/application/cli/commands/completion-install.ts
 import { appendFile as appendFile3, readFile as readFile16 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { join as join33 } from "path";
+import { join as join32 } from "path";
 import * as c from "colorette";
 
 // src/application/cli/exit-codes.ts
@@ -20238,11 +20297,11 @@ function rcFileForShell(shell) {
   const home = homedir2();
   switch (shell) {
     case "bash":
-      return join33(home, ".bashrc");
+      return join32(home, ".bashrc");
     case "zsh":
-      return join33(home, ".zshrc");
+      return join32(home, ".zshrc");
     case "fish":
-      return join33(home, ".config", "fish", "config.fish");
+      return join32(home, ".config", "fish", "config.fish");
   }
 }
 function runCompletionShow(requestedShell) {
@@ -21133,12 +21192,12 @@ async function runSprintClose(deps, id) {
 }
 
 // src/application/cli/commands/sprint-context.ts
-import { writeFile as writeFile14 } from "fs/promises";
+import { writeFile as writeFile13 } from "fs/promises";
 import { isAbsolute as isAbsolute4, resolve as resolve4 } from "path";
 import * as c16 from "colorette";
 
 // src/application/cli/commands/sprint-requirements.ts
-import { writeFile as writeFile13 } from "fs/promises";
+import { writeFile as writeFile12 } from "fs/promises";
 import { isAbsolute as isAbsolute3, resolve as resolve3 } from "path";
 import * as c15 from "colorette";
 function attachSprintRequirements(group, deps) {
@@ -21155,7 +21214,7 @@ async function runSprintRequirements(deps, id, opts) {
       if (!sprintR.ok) return sprintR;
       const outPath = resolveOutputPath(opts.output, `${String(sprintR.value)}-requirements.md`);
       const aggregatePath = resolveStoragePaths().requirementsAggregateFile(sprintR.value);
-      const uc = new ExportRequirementsUseCase((path, body) => writeFile13(path, body, "utf-8"));
+      const uc = new ExportRequirementsUseCase((path, body) => writeFile12(path, body, "utf-8"));
       return uc.execute({ aggregatePath, outputPath: outPath });
     },
     format: (_d, out) => `${c15.green("wrote")} ${String(out.path)} (${String(out.byteCount)} bytes)`
@@ -21222,7 +21281,7 @@ async function runSprintContext(deps, id, opts) {
         deps.sprintRepo,
         deps.taskRepo,
         deps.projectRepo,
-        (path, body) => writeFile14(path, body, "utf-8")
+        (path, body) => writeFile13(path, body, "utf-8")
       );
       return uc.execute({ sprintId: sprintR.value, outputPath: outPath });
     },
@@ -21490,7 +21549,7 @@ async function runSprintPlan(deps, opts) {
 }
 
 // src/application/cli/commands/sprint-progress.ts
-import { join as join34 } from "path";
+import { join as join33 } from "path";
 import * as c19 from "colorette";
 function attachSprintProgress(group, deps) {
   group.command("progress [id]").description("show sprint progress, blockers, stale tasks, and dependency cycles").option("--log", "print the full timeline only (no diagnostics summary)").option("--lines <n>", "cap the number of timeline entries shown", "50").action(async (id, opts) => {
@@ -21534,7 +21593,7 @@ async function runSprintProgress(deps, id, opts) {
         deps.projectRepo,
         deps.external,
         void 0,
-        (sprintId) => join34(String(deps.storage.sprintsDir), String(sprintId), "progress.md")
+        (sprintId) => join33(String(deps.storage.sprintsDir), String(sprintId), "progress.md")
       );
       return uc.execute({ sprintId: idR.value, now: IsoTimestamp.now() });
     },
@@ -21751,7 +21810,10 @@ ${formatTicketsTable(sprint)}`
 // src/application/cli/commands/sprint-start.ts
 import * as c23 from "colorette";
 function attachSprintStart(group, deps) {
-  group.command("start").description("execute the active sprint").requiredOption("--sprint <id>", "sprint id").option("--cwd <abs>", "working directory for AI sessions", process.cwd()).option("--branch", "auto-generate sprint branch name (`ralphctl/<sprint-id>`)").option("--branch-name <name>", "use a custom branch name").option("--check-script <cmd>", "sprint-start check script").option("--no-commit", "do not auto-commit each task after the evaluator round").action(async (opts) => {
+  group.command("start").description("execute the active sprint").requiredOption("--sprint <id>", "sprint id").option("--cwd <abs>", "working directory for AI sessions", process.cwd()).option("--branch", "auto-generate sprint branch name (`ralphctl/<sprint-id>`)").option("--branch-name <name>", "use a custom branch name").option(
+    "--check-script <cmd>",
+    "override the post-task check script for every task (otherwise auto-sourced from each repo)"
+  ).option("--no-commit", "do not auto-commit each task after the evaluator round").action(async (opts) => {
     const code = await runSprintStart(deps, opts);
     if (code !== EXIT_SUCCESS) process.exitCode = code;
   });
@@ -22269,7 +22331,7 @@ async function runTicketRemove(deps, opts) {
 // package.json
 var package_default = {
   name: "ralphctl",
-  version: "0.6.2",
+  version: "0.6.3",
   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",