cloving 1.3.0 → 1.5.0

package/templates/develop/develop/interruption-tests.ts

@@ -0,0 +1,157 @@
+import assert from "node:assert/strict";
+import {
+  fakeStepBridge,
+  type ScenarioRequest,
+} from "cloving/workflows/testing";
+import { develop } from "../develop.ts";
+import {
+  approved,
+  callName,
+  completeCalls,
+  requestInput,
+  scenarioEffects,
+} from "./option-tests.ts";
+import { developReport, ticketInput } from "./report.ts";
+import { completed, input } from "./scenarios.ts";
+
+const interrupted = {
+  kind: "failed" as const,
+  operationId: "interrupted-turn",
+  reason: "claude-turn-interrupted",
+};
+
+function turns(requests: readonly ScenarioRequest[]) {
+  return requests.flatMap((request) =>
+    request[0] === "effect" && request[1].method === "run-turn"
+      ? [request[1]]
+      : [],
+  );
+}
+
+export const interruptionTests = [
+  {
+    name: "CLV-272 an interrupted turn runs again once in the same work tree",
+    run: async () => {
+      const scenario = scenarioEffects();
+      using bridge = fakeStepBridge({
+        effects: {
+          ...scenario,
+          "claude run-turn": [interrupted, ...scenario["claude run-turn"]],
+        },
+        decisions: [approved, approved],
+      });
+      assert.equal((await develop(requestInput())).kind, "handoff_requested");
+      const expected = completeCalls();
+      expected.splice(expected.indexOf("run-turn"), 0, "run-turn");
+      assert.deepEqual(bridge.requests.map(callName), expected);
+      const [first, second] = turns(bridge.requests);
+      assert.ok(first && second);
+      assert.deepEqual(first.scope, {
+        phase: "implement",
+        operation: "claude-turn",
+        round: 1,
+      });
+      assert.ok(!first.payload.includes("stopped before its report"));
+      assert.deepEqual(second.scope, {
+        phase: "implement",
+        operation: "claude-turn",
+        round: 1,
+        key: "continuation",
+      });
+      assert.equal(second.target, first.target);
+      assert.ok(second.payload.endsWith(first.payload));
+      for (const sentence of [
+        "The earlier turn of round 1 stopped before its report.",
+        "The work tree holds the work of that turn.",
+        "Before you continue, check the work tree, the commits since the start of the round, and the ticket.",
+      ])
+        assert.ok(second.payload.includes(sentence), sentence);
+    },
+  },
+  {
+    name: "CLV-272 a second interruption of the same turn blocks the run",
+    run: async () => {
+      using bridge = fakeStepBridge({
+        effects: {
+          ...scenarioEffects(),
+          "claude run-turn": [interrupted, interrupted],
+        },
+      });
+      assert.deepEqual(await develop(requestInput()), {
+        kind: "blocked",
+        cycleId: requestInput().cycleId,
+        reason: "turn-interrupted",
+        evidenceId: "implement",
+      });
+      assert.deepEqual(bridge.requests.map(callName), stoppedCalls());
+      const labels = bridge.requests.flatMap((request) =>
+        request[0] === "effect" && request[1].method === "label"
+          ? [request[1].payload]
+          : [],
+      );
+      for (const payload of labels.slice(1))
+        assert.match(payload, /"add":\["cloving: blocked"\]/);
+    },
+  },
+  {
+    name: "CLV-272 an interrupted fix turn continues with its round and feedback",
+    run: async () => {
+      using bridge = fakeStepBridge({
+        effects: {
+          "claude run-turn": [
+            interrupted,
+            completed({ summary: "Fixed.\nTicket status: complete" }),
+          ],
+        },
+      });
+      const output = "Check output.\n";
+      const report = await developReport({
+        input: ticketInput(input),
+        round: 2,
+        feedback: { reason: "check-failed", output, remaining: ["Add it."] },
+      });
+      assert.ok(!("kind" in report));
+      assert.equal(report.summary, "Fixed.\nTicket status: complete");
+      const [first, second] = turns(bridge.requests);
+      assert.ok(first && second);
+      assert.equal(first.scope.round, 2);
+      assert.equal(second.scope.round, 2);
+      assert.equal(second.scope.key, "continuation");
+      assert.ok(
+        second.payload.startsWith(
+          "The earlier turn of round 2 stopped before its report.",
+        ),
+      );
+      assert.ok(second.payload.endsWith(first.payload));
+      assert.ok(second.payload.endsWith(output));
+      assert.match(
+        second.payload,
+        /This is fix round 2\. Address check-failed/,
+      );
+    },
+  },
+  ...[
+    { kind: "failed" as const, operationId: "turn", reason: "worker-failed" },
+    { kind: "refused" as const, reason: "budget-exhausted" },
+  ].map((failure) => ({
+    name: `CLV-272 a ${failure.reason} continuation fails the run`,
+    run: async () => {
+      using bridge = fakeStepBridge({
+        effects: {
+          ...scenarioEffects(),
+          "claude run-turn": [interrupted, failure],
+        },
+      });
+      await assert.rejects(develop(requestInput()), {
+        message: failure.reason,
+      });
+      assert.deepEqual(bridge.requests.map(callName), stoppedCalls());
+    },
+  })),
+];
+
+function stoppedCalls(): string[] {
+  const complete = completeCalls();
+  const started = complete.slice(0, complete.indexOf("run-turn") + 1);
+  return started.concat("run-turn", started.includes("label") ? ["label"] : []);
+}

package/templates/develop/develop/local.ts

@@ -13,6 +13,7 @@ export async function localRound(
 ): Promise<CycleOutcome | DevelopFeedback> {
   const { input, round } = state;
   const report = await developReport(state);
+  if ("kind" in report) return report;
   const partial = await partialChoice({ input, round, report });
   if (partial !== null) return partial;
   if (

package/templates/develop/develop/option-tests.ts

@@ -4,12 +4,20 @@ import {
   type ScenarioRequest,
 } from "cloving/workflows/testing";
 import { develop } from "../develop.ts";
-import { commit, input, completed, effects, selection } from "./scenarios.ts";
+import {
+  commit,
+  input,
+  completed,
+  effects,
+  selection,
+  repairVerdicts,
+  verificationEffects,
+} from "./scenarios.ts";
 
 const taskText =
   "Develop the submitted task text.\n\nGitHub issue: acme/demo#42 (open)";
 
-function requestInput() {
+export function requestInput() {
   return selection.input === "ticket"
     ? input
     : {
@@ -19,7 +27,7 @@ function requestInput() {
       };
 }
 
-function scenarioEffects() {
+export function scenarioEffects() {
   return {
     ...effects(),
     "claude run-turn": [
@@ -33,10 +41,13 @@ function scenarioEffects() {
       completed({ summary: "Reviewed.", reviewVerdict: "accept" }),
     ],
     "github partial-issue": [completed({ ticketStatus: "partial" })],
+    "command run:red-green": [
+      completed({ verdict: "accepted", output: "Passed." }),
+    ],
   };
 }
 
-function completeCalls(): string[] {
+export function completeCalls(): string[] {
   const review: Readonly<Record<string, string>> = {
     greptile: "wait-review",
     person: "approval",
@@ -46,15 +57,17 @@ function completeCalls(): string[] {
   if (selection.merge === "local") return acceptance;
   return ["prepare"].concat(
     selection.input === "ticket" ? ["label"] : [],
-    ["run-turn", "open-pr", review[selection.accept] ?? "unknown-review"],
+    ["run-turn", "open-pr"],
+    selection.verify === "red-green" ? ["run:red-green"] : [],
+    [review[selection.accept] ?? "unknown-review"],
     selection.merge === "person" ? ["approval", "merge"] : ["merge"],
     selection.input === "ticket" ? ["close-issue"] : [],
   );
 }
 
-const approved = { decision: "approved" as const, answer: null };
+export const approved = { decision: "approved" as const, answer: null };
 
-function callName(request: ScenarioRequest): string {
+export function callName(request: ScenarioRequest): string {
   if (request[0] === "effect") return request[1].method;
   if (request[0] === "waitForDecision") return request[1].kind;
   return request[0];
@@ -67,7 +80,7 @@ export const optionTests = [
       using bridge = fakeStepBridge({
         effects: scenarioEffects(),
         decisions: [approved, approved],
-        effectLimit: 27,
+        effectLimit: selection.verify === "red-green" ? 35 : 31,
       });
       assert.deepEqual(await develop(requestInput()), {
         kind: "handoff_requested",
@@ -171,4 +184,120 @@ export const optionTests = [
       assert.equal(updates.length, Number(selection.partial === "queue"));
     },
   },
-];
+].concat(selection.verify === "red-green" ? verificationTests() : []);
+
+function verificationTests() {
+  return repairTests().concat(passingTests(), unavailableTests(), limitTests());
+}
+
+function repairTests() {
+  return repairVerdicts.map((verdict) => ({
+    name: `CLV-249 ${verdict} starts a fix turn with the full tool output`,
+    run: async () => {
+      using bridge = fakeStepBridge({
+        effects: verificationEffects([verdict, "accepted"]),
+        decisions: [approved, approved],
+        effectLimit: 35,
+      });
+      assert.equal((await develop(requestInput())).kind, "handoff_requested");
+      const expected = completeCalls();
+      expected.splice(
+        expected.indexOf("run:red-green") + 1,
+        0,
+        "run-turn",
+        "open-pr",
+        "run:red-green",
+      );
+      assert.deepEqual(bridge.requests.map(callName), expected);
+      const fix = bridge.requests.find(
+        (request) =>
+          request[0] === "effect" &&
+          request[1].method === "run-turn" &&
+          request[1].scope.round === 2,
+      );
+      assert.ok(fix && fix[0] === "effect");
+      assert.ok(fix[1].payload.includes(`Address ${verdict}`));
+      assert.ok(fix[1].payload.endsWith(`${verdict}\nFull test output.`));
+    },
+  }));
+}
+
+function passingTests() {
+  return ["accepted", "no-test-change"].map((verdict) => ({
+    name: `CLV-249 ${verdict} continues to review and merge`,
+    run: async () => {
+      using bridge = fakeStepBridge({
+        effects: verificationEffects([verdict]),
+        decisions: [approved, approved],
+      });
+      assert.equal((await develop(requestInput())).kind, "handoff_requested");
+      assert.deepEqual(bridge.requests.map(callName), completeCalls());
+    },
+  }));
+}
+
+function limitTests() {
+  return [
+    {
+      name: "CLV-249 verification repairs stop after four development rounds",
+      run: async () => {
+        using bridge = fakeStepBridge({
+          effects: verificationEffects(Array(4).fill("false-red")),
+          effectLimit: 35,
+        });
+        assert.deepEqual(await develop(requestInput()), {
+          kind: "blocked",
+          cycleId: input.cycleId,
+          reason: "false-red",
+          evidenceId: "merge",
+        });
+        const names = bridge.requests.map(callName);
+        assert.equal(names.filter((name) => name === "run-turn").length, 4);
+        assert.equal(
+          names.filter((name) => name === "run:red-green").length,
+          4,
+        );
+        assert.ok(!names.includes("wait-review") && !names.includes("merge"));
+      },
+    },
+  ];
+}
+
+function unavailableTests() {
+  const unavailable = [
+    completed({
+      verdict: "prepare-failed",
+      output: "Dependency preparation failed.",
+    }),
+    { kind: "failed" as const, operationId: "command", reason: "exit-1" },
+    { kind: "unavailable" as const, reason: "cloving-host-unavailable" },
+    { ...completed(null), result: "invalid JSON" },
+    completed(null),
+    completed({ verdict: "unknown", output: "Unknown verdict." }),
+    completed({ verdict: "accepted" }),
+    completed({ verdict: "false-red", output: 42 }),
+  ];
+  return unavailable.map((result, index) => ({
+    name: `CLV-249 unavailable verification ${String(index)} blocks without a fix turn`,
+    run: async () => {
+      using bridge = fakeStepBridge({
+        effects: {
+          ...verificationEffects(["accepted"]),
+          "command run:red-green": [result],
+        },
+      });
+      assert.deepEqual(await develop(requestInput()), {
+        kind: "blocked",
+        cycleId: input.cycleId,
+        reason: "red-green-unavailable",
+        evidenceId: "red-green",
+      });
+      const complete = completeCalls();
+      const expected = complete.slice(0, complete.indexOf("run:red-green") + 1);
+      assert.deepEqual(
+        bridge.requests.map(callName),
+        expected.concat(selection.input === "ticket" ? ["label"] : []),
+      );
+    },
+  }));
+}

package/templates/develop/develop/pull.ts

@@ -21,6 +21,7 @@ export async function openPull(request: {
   readonly round: number;
 }): Promise<PullRequest> {
   const { input, round } = request;
+  const issue = input.issue;
   const result = await protectedEffect({
     scope: { phase: "pull-request", operation: "github-open-pr", round: round },
     capability: "github",
@@ -30,7 +31,10 @@ export async function openPull(request: {
       title: (input.ticket.split("\n")[0] ?? "Develop task")
         .replace(/^#+\s*/, "")
         .slice(0, 200),
-      body: "Review the committed changes and repository checks for this task.",
+      body:
+        issue === null
+          ? "Cloving made this change for this task."
+          : `Refs ${issue.owner}/${issue.repository}#${String(issue.number)}\n\nCloving made this change for the ticket ${String(issue.number)}.`,
     }),
     units: 1,
   });

package/templates/develop/develop/red-green.ts

@@ -0,0 +1,55 @@
+import { runCommand } from "cloving/workflows/steps/run-command";
+import type { CycleOutcome } from "cloving/workflows";
+
+type VerificationFeedback = {
+  readonly reason: string;
+  readonly output: string;
+};
+
+export async function verifyRedGreen(input: {
+  readonly cycleId: string;
+  readonly head: string;
+  readonly round: number;
+}): Promise<CycleOutcome | VerificationFeedback | null> {
+  const unavailable: CycleOutcome = {
+    kind: "blocked",
+    cycleId: input.cycleId,
+    reason: "red-green-unavailable",
+    evidenceId: "red-green",
+  };
+  try {
+    const result = await runCommand({
+      name: "red-green",
+      scope: { phase: "verify", operation: "red-green", round: input.round },
+      input: { head: input.head },
+    });
+    if (result.kind !== "completed") return unavailable;
+    const feedback = verdictFeedback(result.result);
+    return feedback === undefined ? unavailable : feedback;
+  } catch {
+    return unavailable;
+  }
+}
+
+function verdictFeedback(
+  text: string | null,
+): VerificationFeedback | null | undefined {
+  const value: unknown = JSON.parse(text ?? "null");
+  if (
+    typeof value !== "object" ||
+    value === null ||
+    !("verdict" in value) ||
+    typeof value.verdict !== "string" ||
+    !("output" in value) ||
+    typeof value.output !== "string"
+  )
+    return undefined;
+  if (["accepted", "no-test-change"].includes(value.verdict)) return null;
+  if (
+    ["false-red", "red-not-assertion", "skipped-test", "green-failed"].includes(
+      value.verdict,
+    )
+  )
+    return { reason: value.verdict, output: value.output };
+  return undefined;
+}

package/templates/develop/develop/refusal-tests.ts

@@ -9,6 +9,83 @@ import { effects } from "./scenarios.ts";
 
 export const refusalTests: FlowTest[] = [];
 
+refusalTests.push({
+  name: "CLV-260 a linked pull request names the issue and preserves the ticket title",
+  run: async () => {
+    using bridge = fakeStepBridge({
+      turn: completed({ number: 7, url: "pull/7", commit }),
+    });
+    await openPull({
+      input: {
+        cycleId: input.cycleId,
+        repository: input.repository,
+        ticket:
+          "# CLV-228: Stop the registration of the bundled workflows\n\nGitHub issue: cloving-ai/cloving-ai#375 (open)",
+        issue: { owner: "cloving-ai", repository: "cloving-ai", number: 375 },
+      },
+      round: 1,
+    });
+    assert.equal(bridge.requests.length, 1);
+    const opened = bridge.requests[0];
+    assert.ok(opened && opened[0] === "effect");
+    assert.equal(opened[1].method, "open-pr");
+    assert.deepEqual(JSON.parse(opened[1].payload), {
+      title: "CLV-228: Stop the registration of the bundled workflows",
+      body: "Refs cloving-ai/cloving-ai#375\n\nCloving made this change for the ticket 375.",
+    });
+  },
+});
+
+refusalTests.push({
+  name: "CLV-260 a task without an issue opens a pull request without a reference",
+  run: async () => {
+    using bridge = fakeStepBridge({
+      turn: completed({ number: 7, url: "pull/7", commit }),
+    });
+    await openPull({
+      input: {
+        cycleId: input.cycleId,
+        repository: input.repository,
+        ticket: "### Manual task\n\nGitHub issue: acme/demo#42 (open)",
+        issue: null,
+      },
+      round: 1,
+    });
+    assert.equal(bridge.requests.length, 1);
+    const opened = bridge.requests[0];
+    assert.ok(opened && opened[0] === "effect");
+    assert.equal(opened[1].method, "open-pr");
+    assert.deepEqual(JSON.parse(opened[1].payload), {
+      title: "Manual task",
+      body: "Cloving made this change for this task.",
+    });
+  },
+});
+
+refusalTests.push({
+  name: "CLV-260 pull request titles use at most 200 characters from the first line",
+  run: async () => {
+    using bridge = fakeStepBridge({
+      turn: completed({ number: 7, url: "pull/7", commit }),
+    });
+    await openPull({
+      input: {
+        cycleId: input.cycleId,
+        repository: input.repository,
+        ticket: `### ${"Title".repeat(50)}\nSecond line`,
+        issue: null,
+      },
+      round: 1,
+    });
+    const opened = bridge.requests[0];
+    assert.ok(opened && opened[0] === "effect");
+    assert.deepEqual(JSON.parse(opened[1].payload), {
+      title: "Title".repeat(40),
+      body: "Cloving made this change for this task.",
+    });
+  },
+});
+
 for (const operation of [
   "claude run-turn",
   "github open-pr",

package/templates/develop/develop/report.ts

@@ -4,7 +4,7 @@ import {
   type ProtectedResult,
   type TicketStatus,
 } from "cloving/workflows";
-import { developTurn } from "./turn.ts";
+import { developTurn, type DevelopTurnInput } from "./turn.ts";
 
 export interface DevelopInput {
   readonly cycleId: string;
@@ -72,16 +72,36 @@ export interface DevelopState {
 
 export async function developReport(
   state: DevelopState,
-): Promise<DevelopReport> {
-  const { input, round, feedback } = state;
-  return reportOf(
-    await developTurn({
-      cycleId: input.cycleId,
-      repository: input.repository,
-      ticket: input.ticket,
-      round,
-      feedback,
-    }),
+): Promise<DevelopReport | CycleOutcome> {
+  const first = await developTurn(turnRequest(state, "initial"));
+  if (!interrupted(first)) return reportOf(first);
+  const second = await developTurn(turnRequest(state, "continuation"));
+  if (!interrupted(second)) return reportOf(second);
+  return {
+    kind: "blocked",
+    cycleId: state.input.cycleId,
+    reason: "turn-interrupted",
+    evidenceId: "implement",
+  };
+}
+
+function turnRequest(
+  state: DevelopState,
+  attempt: "initial" | "continuation",
+): DevelopTurnInput {
+  return {
+    cycleId: state.input.cycleId,
+    repository: state.input.repository,
+    ticket: state.input.ticket,
+    round: state.round,
+    attempt,
+    feedback: state.feedback,
+  };
+}
+
+function interrupted(result: ProtectedResult): boolean {
+  return (
+    result.kind !== "completed" && result.reason === "claude-turn-interrupted"
   );
 }
 

package/templates/develop/develop/round.ts

@@ -13,6 +13,7 @@ export async function developRound(state: {
   const { input, round } = state;
   try {
     const report = await developReport(state);
+    if ("kind" in report) return report;
     const pull = await openPull({ input, round });
     const subject = {
       target: pull.target,

package/templates/develop/develop/scenarios.ts

@@ -2,6 +2,7 @@ export const commit = "a".repeat(40);
 export const selection = {
   input: "ticket",
   select: "queue",
+  verify: "none",
   accept: "greptile",
   merge: "green",
   partial: "queue",
@@ -52,6 +53,32 @@ export function effects() {
   };
 }
 
+export const repairVerdicts = [
+  "false-red",
+  "red-not-assertion",
+  "skipped-test",
+  "green-failed",
+];
+
+export function verificationEffects(verdicts: readonly string[]) {
+  const scenario = effects();
+  return {
+    ...scenario,
+    "claude run-turn": verdicts.map(() =>
+      completed({ summary: "Implemented.\nTicket status: complete" }),
+    ),
+    "github open-pr": verdicts.map(() =>
+      completed({ number: 7, url: "pull/7", commit }),
+    ),
+    "command run:red-green": verdicts.map((verdict) =>
+      completed({ verdict, output: `${verdict}\nFull test output.` }),
+    ),
+    "claude run-turn:review": [
+      completed({ summary: "Reviewed.", reviewVerdict: "accept" }),
+    ],
+  };
+}
+
 export function partialEffects(
   pullRequest: number,
   remaining: readonly string[],