ralphctl 0.4.6 → 0.5.0

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

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

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

@@ -1091,6 +1091,16 @@ ${ctx.existingAgentsMd}
     FILE_NAME: ctx.fileName
   });
 }
+function buildEvaluationResumePrompt(ctx) {
+  const template = loadTemplate("task-evaluation-resume");
+  const commitInstruction = ctx.needsCommit ? "\n   - **Then commit the fix** with a descriptive message before signaling completion." : "";
+  return composePrompt(template, {
+    HARNESS_CONTEXT: loadPartial("harness-context"),
+    SIGNALS: loadPartial("signals-task"),
+    CRITIQUE: ctx.critique,
+    COMMIT_INSTRUCTION: commitInstruction
+  });
+}
 
 export {
   buildInteractivePrompt,
@@ -1103,6 +1113,7 @@ export {
   buildSprintFeedbackPrompt,
   buildCheckScriptDiscoverPrompt,
   buildRepoOnboardPrompt,
+  buildEvaluationResumePrompt,
   processLifecycleAdapter,
   resolveProvider,
   providerDisplayName,

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

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

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

@@ -3,6 +3,7 @@ import {
   ProviderAiSessionAdapter,
   SignalParser,
   buildAutoPrompt,
+  buildEvaluationResumePrompt,
   buildEvaluatorPrompt,
   buildIdeateAutoPrompt,
   buildIdeatePrompt,
@@ -13,7 +14,7 @@ import {
   buildTicketRefinePrompt,
   getActiveProvider,
   spawnInteractive
-} from "./chunk-ZLWSPLWI.mjs";
+} from "./chunk-62HYDA7L.mjs";
 import {
   fetchIssueFromUrl,
   formatIssueContext,
@@ -2488,10 +2489,9 @@ var EvaluateTaskUseCase = class {
           options
         );
         if (!fixSuccess) {
-          const reason = "Generator could not fix issues after feedback";
-          await this.persistEvaluationStub(sprintId, taskId, i + 2, reason);
-          break;
+          log2.debug(`Fix attempt ${String(i + 1)}: generator did not signal completion \u2014 re-evaluating anyway`);
         }
+        if (i === maxIterations - 1) break;
         const previousEvalResult = evalResult;
         const stopReeval = log2.time("evaluator-re-spawn");
         evalResult = await this.runSingleEvaluation(
@@ -2515,7 +2515,7 @@ var EvaluateTaskUseCase = class {
       }
       const finalStatus = plateaued ? "plateau" : evalResult.status;
       await this.updateTaskEvaluation(sprintId, taskId, evalResult, finalStatus);
-      this.reportResult(task.name, evalResult, maxIterations, plateaued);
+      this.reportResult(task.name, evalResult, totalIterations, plateaued);
       return Result.ok({
         taskId,
         status: finalStatus,
@@ -2559,47 +2559,47 @@ var EvaluateTaskUseCase = class {
     }
   }
   /**
-   * Spawn a single evaluator session and parse the result.
-   *
-   * `checkScriptSection` and `projectToolingSection` are passed in
-   * pre-resolved — both are stable across fix-loop iterations, so the
-   * caller computes them once and threads them through.
+   * Spawn a single evaluator session and parse the result. Stable inputs
+   * (`checkScriptSection`, `projectToolingSection`) are passed in
+   * pre-resolved so the fix loop doesn't re-compute them per iteration.
    */
   async runSingleEvaluation(task, sprint, repoPath, generatorModel, provider, checkScriptSection, projectToolingSection, options) {
     const evaluatorModel = getEvaluatorModel(generatorModel, provider);
-    const sprintDir = this.fs.getSprintDir(sprint.id);
     const prompt = this.promptBuilder.buildTaskEvaluationPrompt(
       task,
       repoPath,
       checkScriptSection,
       projectToolingSection
     );
-    const args = ["--add-dir", sprintDir];
+    const args = ["--add-dir", this.fs.getSprintDir(sprint.id)];
     if (provider === "claude") {
-      if (evaluatorModel) {
-        args.push("--model", evaluatorModel);
-      }
+      if (evaluatorModel) args.push("--model", evaluatorModel);
       args.push("--max-turns", String(options?.maxTurns ?? EVALUATOR_MAX_TURNS));
     }
-    let result;
+    const result = await this.spawnOrNull(prompt, {
+      cwd: repoPath,
+      args,
+      env: this.aiSession.getSpawnEnv(),
+      abortSignal: options?.abortSignal
+    });
+    if (!result.ok) {
+      this.logger.warning(`Evaluator spawn failed for ${task.name}: ${result.message} \u2014 marking malformed`);
+      return { status: "malformed", dimensions: [], rawOutput: `Evaluator spawn failed: ${result.message}` };
+    }
+    return this.parser.parseEvaluation(result.value.output);
+  }
+  /**
+   * Wrap `spawnWithRetry` in a try/catch so callers can handle spawn
+   * failures without nested error handling. Returns a small discriminated
+   * union — ok with the session result, or !ok with the message.
+   */
+  async spawnOrNull(prompt, opts) {
     try {
-      result = await this.aiSession.spawnWithRetry(prompt, {
-        cwd: repoPath,
-        args,
-        env: this.aiSession.getSpawnEnv(),
-        abortSignal: options?.abortSignal
-      });
+      const value = await this.aiSession.spawnWithRetry(prompt, opts);
+      return { ok: true, value };
     } catch (err) {
-      this.logger.warning(
-        `Evaluator spawn failed for ${task.name}: ${err instanceof Error ? err.message : String(err)} \u2014 marking malformed`
-      );
-      return {
-        status: "malformed",
-        dimensions: [],
-        rawOutput: `Evaluator spawn failed: ${err instanceof Error ? err.message : String(err)}`
-      };
+      return { ok: false, message: err instanceof Error ? err.message : String(err) };
     }
-    return this.parser.parseEvaluation(result.output);
   }
   /**
    * Resolve the repo's `checkScript` and render it as the evaluator's
@@ -2628,33 +2628,39 @@ var EvaluateTaskUseCase = class {
   }
   /**
    * Resume the generator session with the evaluator critique.
-   * Returns true if the generator signaled completion.
+   *
+   * Two load-bearing properties (covered by `fix-loop fence` tests):
+   *   1. Prompt comes from `buildTaskEvaluationResumePrompt` — full template
+   *      with signals / fix-protocol / commit instruction. A regression to
+   *      an inline string silently drops signal requirements.
+   *   2. When `options.generatorSessionId` is set, `resumeSessionId` is
+   *      threaded so the fix continues the original session (`--resume`).
+   *      Absent an ID, spawn fresh and log at debug.
+   *
+   * Returns true iff the generator signaled `<task-complete>` — used as a
+   * diagnostic only; the evaluator settles whether the fix actually worked.
    */
   async resumeGeneratorWithCritique(task, sprint, repoPath, critique, options) {
-    const sprintDir = this.fs.getSprintDir(sprint.id);
-    const resumePrompt = [
-      "The evaluator found issues with your implementation. Fix them and signal completion.",
-      "",
-      "## Evaluator Critique",
-      critique
-    ].join("\n");
-    let spinner = null;
-    try {
-      spinner = this.logger.spinner(`Fixing evaluation issues: ${task.name}`);
-      const result = await this.aiSession.spawnWithRetry(resumePrompt, {
-        cwd: repoPath,
-        args: ["--add-dir", sprintDir],
-        env: this.aiSession.getSpawnEnv(),
-        maxTurns: options?.maxTurns,
-        abortSignal: options?.abortSignal
-      });
-      spinner.succeed(`Fix attempt completed: ${task.name}`);
-      const signals = this.parser.parseExecutionSignals(result.output);
-      return signals.complete;
-    } catch {
-      spinner?.fail(`Fix attempt failed: ${task.name}`);
+    const resumePrompt = this.promptBuilder.buildTaskEvaluationResumePrompt(critique, options?.needsCommit ?? true);
+    const resumeSessionId = options?.generatorSessionId;
+    this.logger.debug(
+      resumeSessionId ? `Resuming generator session ${resumeSessionId} for fix attempt: ${task.name}` : `No generator session ID \u2014 spawning fresh fix attempt: ${task.name}`
+    );
+    const spinner = this.logger.spinner(`Fixing evaluation issues: ${task.name}`);
+    const result = await this.spawnOrNull(resumePrompt, {
+      cwd: repoPath,
+      args: ["--add-dir", this.fs.getSprintDir(sprint.id)],
+      env: this.aiSession.getSpawnEnv(),
+      maxTurns: options?.maxTurns,
+      resumeSessionId,
+      abortSignal: options?.abortSignal
+    });
+    if (!result.ok) {
+      spinner.fail(`Fix attempt failed: ${task.name}`);
       return false;
     }
+    spinner.succeed(`Fix attempt completed: ${task.name}`);
+    return this.parser.parseExecutionSignals(result.value.output).complete;
   }
   /**
    * Persist a real evaluation entry to the sidecar file.
@@ -2674,49 +2680,46 @@ var EvaluateTaskUseCase = class {
     }
   }
   /**
-   * Persist a stub entry when the fix loop bails early.
-   */
-  async persistEvaluationStub(sprintId, taskId, iteration, reason) {
-    try {
-      await this.persistence.writeEvaluation(sprintId, taskId, iteration, "failed", `_(no re-evaluation: ${reason})_`);
-    } catch {
-      this.logger.warning(`Could not persist evaluation stub for task ${taskId}`);
-    }
-  }
-  /**
-   * Update the task record with evaluation fields.
-   *
-   * `statusOverride` is set when plateau detection fires: the critique body
-   * is still saved (truncated) for traceability, but the discriminator in
-   * `tasks.json` records `'plateau'` so consumers can distinguish it from
-   * a plain `'failed'` run.
+   * Update the task record with evaluation fields. `statusOverride` is set
+   * for plateau — the body is still the real critique, but the status
+   * column records `'plateau'` so readers can distinguish it from a plain
+   * failure.
    */
   async updateTaskEvaluation(sprintId, taskId, evalResult, statusOverride) {
-    const status = statusOverride ?? evalResult.status;
-    const tasks = await this.persistence.getTasks(sprintId);
-    const updatedTasks = tasks.map(
-      (t) => t.id === taskId ? {
-        ...t,
+    await this.persistence.updateTask(
+      taskId,
+      {
         evaluated: true,
-        evaluationStatus: status,
+        evaluationStatus: statusOverride ?? evalResult.status,
         evaluationOutput: evalResult.rawOutput.slice(0, MAX_EVAL_OUTPUT)
-      } : t
+      },
+      sprintId
     );
-    await this.persistence.saveTasks(updatedTasks, sprintId);
   }
   /**
    * Report the evaluation outcome to the user.
+   *
+   * `totalIterations` is the *actual* number of evaluator spawns (initial +
+   * any re-evaluations after fix attempts), NOT the configured maximum.
+   * When the loop breaks early (plateau), runs out of fix budget, or skips
+   * the final re-eval, these two diverge — and the log line must reflect
+   * reality so "6 fix attempts" never shows up when only 1 actually ran.
+   *
+   * The evaluator is advisory: a failing outcome doesn't stop the task
+   * from being marked done; the sprint proceeds. The critique is persisted
+   * in the sidecar for later review, and the warning log lets the user
+   * see what didn't pass without scrolling the evaluations directory.
    */
-  reportResult(taskName, evalResult, maxIterations, plateaued) {
+  reportResult(taskName, evalResult, totalIterations, plateaued) {
     if (plateaued) {
       this.logger.warning(
-        `Evaluation plateaued on the same failures \u2014 further fix attempts were skipped. Marking done: ${taskName}`
+        `Evaluation plateaued on the same failures after ${String(totalIterations)} iteration(s): ${taskName}`
       );
     } else if (evalResult.status === "malformed") {
-      this.logger.warning(`Evaluator output was malformed for ${taskName} \u2014 marking done`);
+      this.logger.warning(`Evaluator output was malformed for ${taskName}`);
     } else if (!isPassed(evalResult)) {
       this.logger.warning(
-        `Evaluation did not pass after ${String(maxIterations)} fix attempt(s) \u2014 marking done: ${taskName}`
+        `Evaluation did not pass after ${String(totalIterations)} iteration(s) \u2014 marking done: ${taskName}`
       );
     } else {
       this.logger.success(`Evaluation passed: ${taskName}`);
@@ -2739,40 +2742,24 @@ function loadTaskStep(persistence) {
 function checkAlreadyEvaluatedStep(options) {
   return step("check-already-evaluated", (ctx) => {
     const task = ctx.tasks?.[0];
-    if (!task) {
-      const empty2 = {};
-      return Result.ok(empty2);
+    if (task && task.evaluated && !options.force) {
+      const summary = { taskId: task.id, status: "skipped", iterations: 0 };
+      return Result.ok({ evaluationSummary: summary });
     }
-    if (task.evaluated && !options.force) {
-      const summary = {
-        taskId: task.id,
-        status: "skipped",
-        iterations: 0
-      };
-      const partial = { evaluationSummary: summary };
-      return Result.ok(partial);
-    }
-    const empty = {};
-    return Result.ok(empty);
+    return Result.ok({});
   });
 }
 function runEvaluatorLoopStep(useCase, options) {
   return step("run-evaluator-loop", async (ctx) => {
     if (ctx.evaluationSummary?.status === "skipped") {
-      const empty = {};
-      return Result.ok(empty);
+      return Result.ok({});
     }
     const result = await useCase.execute(ctx.sprintId, ctx.taskId, {
-      iterations: options.iterations,
-      maxTurns: options.maxTurns,
-      fallbackModel: ctx.generatorModel ?? void 0,
+      ...options,
       abortSignal: ctx.abortSignal ?? options.abortSignal
     });
-    if (!result.ok) {
-      return Result.error(result.error);
-    }
-    const partial = { evaluationSummary: result.value };
-    return Result.ok(partial);
+    if (!result.ok) return Result.error(result.error);
+    return Result.ok({ evaluationSummary: result.value });
   });
 }
 function createEvaluatorPipeline(deps, options = {}) {
@@ -2798,10 +2785,7 @@ function createEvaluatorPipeline(deps, options = {}) {
 function evaluateTask(deps) {
   return step("evaluate-task", async (ctx) => {
     const evalCfg = await deps.useCase.getEvaluationConfig(deps.options);
-    if (!evalCfg.enabled) {
-      const empty = {};
-      return Result.ok(empty);
-    }
+    if (!evalCfg.enabled) return Result.ok({});
     const innerPipeline = createEvaluatorPipeline(
       {
         persistence: deps.persistence,
@@ -2816,38 +2800,52 @@ function evaluateTask(deps) {
       {
         iterations: evalCfg.iterations,
         maxTurns: deps.options.maxTurns,
+        // noCommit (ExecutionOptions) inverted — if the generator committed
+        // the initial work, the fix must commit too.
+        needsCommit: !deps.options.noCommit,
+        // Model ladder input: evaluator uses a cheaper model than the
+        // generator's. Null when the generator didn't report one (Copilot,
+        // blocked tasks).
+        fallbackModel: ctx.generatorModel ?? void 0,
+        // --resume <id> so the fix continues the generator's session
+        // rather than cold-starting. Undefined → fresh spawn (rare fallback).
+        generatorSessionId: ctx.executionResult?.sessionId,
         abortSignal: ctx.abortSignal
       }
     );
     const innerCtx = {
       sprintId: ctx.sprint.id,
       taskId: ctx.task.id,
-      generatorModel: ctx.generatorModel ?? null,
       abortSignal: ctx.abortSignal
     };
-    let stepNames = [];
     try {
-      const result = await executePipeline(innerPipeline, innerCtx);
-      stepNames = result.ok ? result.value.stepResults.map((r) => r.stepName) : (
-        // Even on failure the framework populates stepResults up to and
-        // including the failing step. Extract them opportunistically —
-        // if unavailable, proceed with an empty list.
-        []
-      );
-      if (!result.ok) {
+      const innerResult = await executePipeline(innerPipeline, innerCtx);
+      if (!innerResult.ok) {
         deps.logger.warning(
-          `Evaluation failed for ${ctx.task.name}: ${result.error.message}. Proceeding with task completion.`
+          `Evaluator pipeline errored for ${ctx.task.name}: ${innerResult.error.message} \u2014 proceeding with task completion`
         );
+        return Result.ok({ evaluationStepNames: [] });
       }
+      logIfNonTerminal(deps.logger, ctx.task.name, innerResult.value.context.evaluationSummary);
+      return Result.ok({
+        evaluationStepNames: innerResult.value.stepResults.map((r) => r.stepName)
+      });
     } catch (err) {
       deps.logger.warning(
-        `Evaluator threw for ${ctx.task.name}: ${err instanceof Error ? err.message : String(err)}. Proceeding with task completion.`
+        `Evaluator threw for ${ctx.task.name}: ${err instanceof Error ? err.message : String(err)} \u2014 proceeding with task completion`
       );
+      return Result.ok({ evaluationStepNames: [] });
     }
-    const partial = { evaluationStepNames: stepNames };
-    return Result.ok(partial);
   });
 }
+function logIfNonTerminal(logger, taskName, summary) {
+  if (!summary) return;
+  if (summary.status === "failed" || summary.status === "malformed" || summary.status === "plateau") {
+    logger.warning(
+      `Evaluation ${summary.status} for ${taskName} after ${String(summary.iterations)} iteration(s) \u2014 proceeding with task completion`
+    );
+  }
+}
 
 // src/business/pipelines/execute/steps/recover-dirty-tree.ts
 function recoverDirtyTree2(deps) {
@@ -4033,6 +4031,9 @@ var TextPromptBuilderAdapter = class {
       extraDimensions: task.extraDimensions ?? []
     });
   }
+  buildTaskEvaluationResumePrompt(critique, needsCommit) {
+    return buildEvaluationResumePrompt({ critique, needsCommit });
+  }
   buildFeedbackPrompt(sprintName, completedTasks, feedback, branch) {
     return buildSprintFeedbackPrompt(sprintName, completedTasks, feedback, branch);
   }

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

@@ -6,7 +6,7 @@ import {
   getAllConfigSchemaEntries,
   getConfigDefaultValue,
   parseConfigValue
-} from "./chunk-PYZEQ2VK.mjs";
+} from "./chunk-BT5FKIZX.mjs";
 import {
   editorInput
 } from "./chunk-OGEXYSFS.mjs";
@@ -41,14 +41,14 @@ import {
   updateTask,
   updateTaskStatus,
   validateImportTasks
-} from "./chunk-B3RCOHW3.mjs";
+} from "./chunk-D6QZNEYN.mjs";
 import {
   SignalParser,
   buildTicketRefinePrompt,
   processLifecycleAdapter,
   providerDisplayName,
   resolveProvider
-} from "./chunk-ZLWSPLWI.mjs";
+} from "./chunk-62HYDA7L.mjs";
 import {
   fetchIssueFromUrl,
   formatIssueContext,
@@ -185,7 +185,7 @@ import {
 // package.json
 var package_default = {
   name: "ralphctl",
-  version: "0.4.6",
+  version: "0.5.0",
   description: "Agent harness for long-running AI coding tasks \u2014 orchestrates Claude Code & GitHub Copilot across repositories",
   homepage: "https://github.com/lukas-grigis/ralphctl",
   type: "module",
@@ -2214,7 +2214,7 @@ async function selectProject(message = "Select project:") {
       default: true
     });
     if (create) {
-      const { projectAddCommand } = await import("./add-YVXM34RP.mjs");
+      const { projectAddCommand } = await import("./add-67UFUI54.mjs");
       await projectAddCommand({ interactive: true });
       const updated = await listProjects();
       if (updated.length === 0) return null;

package/dist/cli.mjs

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

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

@@ -62,7 +62,7 @@ import {
   ticketRemoveCommand,
   ticketShowCommand,
   useCurrentPrompt
-} from "./chunk-O566EEDL.mjs";
+} from "./chunk-ZE2BRQA2.mjs";
 import {
   PromptCancelledError,
   detectCheckScriptCandidates,
@@ -73,7 +73,7 @@ import {
   projectAddCommand,
   suggestCheckScript,
   validateConfigValue
-} from "./chunk-PYZEQ2VK.mjs";
+} from "./chunk-BT5FKIZX.mjs";
 import {
   sprintCreateCommand
 } from "./chunk-FNAAA32W.mjs";
@@ -99,7 +99,7 @@ import {
   reorderTask,
   sprintStartCommand,
   updateTaskStatus
-} from "./chunk-B3RCOHW3.mjs";
+} from "./chunk-D6QZNEYN.mjs";
 import {
   ProviderAiSessionAdapter,
   SignalParser,
@@ -107,7 +107,7 @@ import {
   exitAltScreen,
   registerTuiInstance,
   withSuspendedTui
-} from "./chunk-ZLWSPLWI.mjs";
+} from "./chunk-62HYDA7L.mjs";
 import {
   addTicket,
   allRequirementsApproved,

package/dist/{start-FP7MVN5P.mjs → start-T34NI3LF.mjs}

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

package/package.json

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