cloving 1.4.0 → 1.5.0

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/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/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[],

package/templates/develop/develop/turn.ts

@@ -7,6 +7,7 @@ export interface DevelopTurnInput {
   readonly ticket?: string;
   readonly prompt?: string;
   readonly round: number;
+  readonly attempt?: "initial" | "continuation";
   readonly feedback: {
     readonly reason: string;
     readonly output: string;
@@ -50,19 +51,38 @@ function turnPrompt(input: DevelopTurnInput): string {
   ].join("\n");
 }
 
+function attemptPrompt(input: DevelopTurnInput): string {
+  const prompt = turnPrompt(input);
+  if (input.attempt !== "continuation") return prompt;
+  return [
+    `The earlier turn of round ${String(input.round)} 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.",
+    "",
+    prompt,
+  ].join("\n");
+}
+
+function turnScope(input: DevelopTurnInput) {
+  if (input.attempt !== "continuation")
+    return { phase: "implement", operation: "claude-turn", round: input.round };
+  return {
+    phase: "implement",
+    operation: "claude-turn",
+    round: input.round,
+    key: "continuation",
+  };
+}
+
 export async function developTurn(
   input: DevelopTurnInput,
 ): Promise<ProtectedResult> {
   return await protectedEffect({
-    scope: {
-      phase: "implement",
-      operation: "claude-turn",
-      round: input.round,
-    },
+    scope: turnScope(input),
     capability: "claude",
     method: "run-turn",
     target: input.cycleId,
-    payload: turnPrompt(input),
+    payload: attemptPrompt(input),
     units: 1,
   });
 }

package/templates/develop/develop.declaration.json

@@ -1,7 +1,7 @@
 {
   "workflow": {
     "workflowId": "develop",
-    "effectLimit": 27,
+    "effectLimit": 31,
     "capabilities": ["claude", "github"],
     "queue": true,
     "input": {

package/templates/develop/develop.test.ts

@@ -1,5 +1,6 @@
 import { flowTests } from "./develop/flow-tests.ts";
 import { refusalTests } from "./develop/refusal-tests.ts";
+import { interruptionTests } from "./develop/interruption-tests.ts";
 import assert from "node:assert/strict";
 import { test } from "node:test";
 import { fakeStepBridge } from "cloving/workflows/testing";
@@ -10,6 +11,9 @@ import { queuePartial } from "./develop/queue-partial.ts";
 for (const scenario of flowTests.concat(refusalTests))
   await test(scenario.name, scenario.run);
 
+for (const scenario of interruptionTests)
+  await test(scenario.name, scenario.run);
+
 await test("CLV-221 invalid partial rounds never dispatch an effect or open a question", async () => {
   using bridge = fakeStepBridge({});
   for (const round of [0, -1, 1.5, 5, NaN, Infinity]) {

package/templates/develop/template.json

@@ -1,7 +1,7 @@
 {
   "version": 1,
   "name": "develop",
-  "summary": "Develop a ticket or task with explicit choices for selection, acceptance, merge and partial work. The first option at each point is the hands-off default.",
+  "summary": "Develop a ticket or task with explicit choices for selection, verification, acceptance, merge and partial work. The first option at each point is the hands-off default.",
   "points": [
     {
       "id": "input",
@@ -52,6 +52,33 @@
         }
       ]
     },
+    {
+      "id": "verify",
+      "question": "How should the tests be verified before review?",
+      "options": [
+        {
+          "id": "none",
+          "label": "No additional verification",
+          "summary": "Keep the current development, review and merge checks.",
+          "change": "Leave develop/round.ts and the declaration unchanged for verification.",
+          "requires": {},
+          "needs": []
+        },
+        {
+          "id": "red-green",
+          "label": "Red and green test check",
+          "summary": "Verify an assertion failure on the base and passing tests on the pull request head before review.",
+          "change": "In develop/round.ts import verifyRedGreen from develop/red-green.ts. After openPull and before acceptWork, call verifyRedGreen({ cycleId: input.cycleId, head: pull.commit, round }). Return a blocked outcome immediately; pass non-null feedback to repair({ cycleId: input.cycleId, round, report, result: verification }). In develop.declaration.json add the command capability to workflow.capabilities and \"commands\": [\"red-green\"] to workflow, and command: [\"run:red-green\"] to methods. Add 4 to workflow.effectLimit. Configure the operator red-green command and checks.redGreen.",
+          "requires": {
+            "merge": [
+              "green",
+              "person"
+            ]
+          },
+          "needs": []
+        }
+      ]
+    },
     {
       "id": "accept",
       "question": "Who accepts the developed work?",
@@ -143,7 +170,7 @@
           "id": "person",
           "label": "A person decides",
           "summary": "Ask what to do with partial work. Use the answer as feedback for a bounded continuation, or stop and leave it for the person.",
-          "change": "For a pull-request workflow, in develop/round.ts import partialChoice from develop/partial-choice.ts. Immediately after developReport, call partialChoice({ input, round, report }) and return any non-null result. develop/local.ts already does this. The helper calls waitForDecision({ gateId: partialGateId, kind: \"question\", prompt: partialQuestion }); an explicit answer feeds the next bounded turn and an empty answer stops.",
+          "change": "For a pull-request workflow, in develop/round.ts import partialChoice from develop/partial-choice.ts. Immediately after the line that returns a blocked outcome of developReport, call partialChoice({ input, round, report }) and return any non-null result. develop/local.ts already does this. The helper calls waitForDecision({ gateId: partialGateId, kind: \"question\", prompt: partialQuestion }); an explicit answer feeds the next bounded turn and an empty answer stops.",
           "requires": {},
           "needs": []
         }