cloving 1.3.0 → 1.5.0

package/dist/tools/workflow-candidate-source.js

@@ -1,10 +1,17 @@
+import { passiveCandidateModule, workflowShape, } from "./workflow-candidate-shape.js";
 import ts from "typescript";
 import { dirname, relative, sep } from "node:path";
-import { candidateProgram, resolvedSymbol, } from "./workflow-candidate-program.js";
-import { protectedEffectFact, passiveCandidateModule, unsupportedCandidateNode, workflowShape, } from "./workflow-candidate-syntax.js";
+import { candidateCompiler, candidateProgram, resolvedSymbol, } from "./workflow-candidate-program.js";
+import { protectedEffectFact, commandWaitCall, unsupportedCandidateNode, } from "./workflow-candidate-syntax.js";
+import { literalField } from "./workflow-candidate-fields.js";
 import { sourceEffectNodes } from "./workflow-source-effects.js";
 import { candidateEffectTotals } from "./workflow-candidate-counts.js";
 import { helperEffectTotals } from "./workflow-candidate-helper-counts.js";
+export function createWorkflowCandidateAnalyzer(installed = {}) {
+    const compile = candidateCompiler(installed);
+    const localSources = Object.keys(installed.helpers ?? {});
+    return (text) => analyzeProgram(compile(text), localSources);
+}
 function exportSnapshot(modules, checker) {
     return Object.fromEntries([...modules].map(([name, declaration]) => {
         const symbol = checker.getSymbolAtLocation(declaration);
@@ -32,11 +39,14 @@ function sourceFacts(symbols) {
     const { source } = symbols;
     const imports = [];
     const effects = [];
+    const commandWaits = [];
     const unsupportedForms = [];
     function visit(node) {
         const imported = sourceImport(node);
         if (imported)
             imports.push(imported);
+        if (ts.isCallExpression(node) && commandWaitCall(node, symbols))
+            commandWaits.push(literalField(node.arguments[0], "name"));
         const effect = protectedEffectFact(node, symbols);
         if (effect)
             effects.push(effect);
@@ -47,6 +57,7 @@ function sourceFacts(symbols) {
     visit(source);
     return {
         imports,
+        ...(commandWaits.length === 0 ? {} : { commandWaits }),
         effects,
         directEffects: sourceEffectNodes(source, {
             checker: symbols.checker,
@@ -84,7 +95,10 @@ function mergeHelpers(modules, checker) {
     });
 }
 export function analyzeWorkflowCandidate(text, installed = {}) {
-    const { program, source, sources, modules } = candidateProgram(text, installed);
+    return analyzeProgram(candidateProgram(text, installed), Object.keys(installed.helpers ?? {}));
+}
+function analyzeProgram(compiled, localSources) {
+    const { program, source, sources, modules } = compiled;
     const checker = program.getTypeChecker();
     const symbols = {
         checker,
@@ -99,6 +113,11 @@ export function analyzeWorkflowCandidate(text, installed = {}) {
             subpath: "cloving/workflows/steps/handoff",
             name: "handoff",
         }),
+        commandWaitSymbol: protectedHelper(modules, {
+            checker,
+            subpath: "cloving/workflows/steps/wait-for-command",
+            name: "waitForCommand",
+        }),
         commandSymbol: protectedHelper(modules, {
             checker,
             subpath: "cloving/workflows/steps/run-command",
@@ -114,7 +133,7 @@ export function analyzeWorkflowCandidate(text, installed = {}) {
     const facts = sources.map((entry) => analyzedSource({ ...symbols, source: entry }, { program, workflow: source }));
     return {
         analysis: combineFacts({
-            localSources: Object.keys(installed.helpers ?? {}),
+            localSources,
             facts,
             expanded: helperEffectTotals({
                 symbols: { ...symbols, source },
@@ -154,6 +173,9 @@ function combineFacts(input) {
     const { localSources, facts } = input;
     return {
         localSources,
+        ...(facts.some((entry) => entry.commandWaits !== undefined)
+            ? { commandWaits: facts.flatMap((entry) => entry.commandWaits ?? []) }
+            : {}),
         imports: facts.flatMap((entry) => entry.imports),
         effects: facts.flatMap((entry) => entry.effects),
         directEffects: facts.flatMap((entry) => entry.directEffects),

package/dist/tools/workflow-candidate-syntax.d.ts

@@ -5,6 +5,7 @@ export interface CandidateSymbols {
     readonly source: ts.SourceFile;
     readonly protectedSymbol: ts.Symbol | undefined;
     readonly handoffSymbol: ts.Symbol | undefined;
+    readonly commandWaitSymbol?: ts.Symbol | undefined;
     readonly commandSymbol: ts.Symbol | undefined;
     readonly reviewSymbol: ts.Symbol | undefined;
     readonly mergeSymbols: readonly ts.Symbol[];
@@ -12,10 +13,9 @@ export interface CandidateSymbols {
 export declare function protectedCall(node: ts.Node, symbols: CandidateSymbols): node is ts.CallExpression;
 export declare function handoffCall(node: ts.CallExpression, symbols: CandidateSymbols): boolean;
 export declare function commandCall(node: ts.CallExpression, symbols: CandidateSymbols): boolean;
+export declare function commandWaitCall(node: ts.CallExpression, symbols: CandidateSymbols): boolean;
 export declare function reviewCall(node: ts.CallExpression, symbols: CandidateSymbols): boolean;
 export declare function helperCall(node: ts.CallExpression, symbols: CandidateSymbols): boolean;
 export declare function mergeCall(node: ts.CallExpression, symbols: CandidateSymbols): boolean;
 export declare function protectedEffectFact(node: ts.Node, symbols: CandidateSymbols): CandidateEffect | undefined;
 export declare function unsupportedCandidateNode(node: ts.Node, symbols: CandidateSymbols): boolean;
-export declare function workflowShape(source: ts.SourceFile): boolean;
-export declare function passiveCandidateModule(source: ts.SourceFile, kind?: "workflow" | "helper"): boolean;

package/dist/tools/workflow-candidate-syntax.js

@@ -1,7 +1,7 @@
 import ts from "typescript";
 import { resolvedSymbol } from "./workflow-candidate-program.js";
 import { referenceSymbol } from "./workflow-source-effects.js";
-import { invalidFields, literalField, propertyInitializer, } from "./workflow-candidate-fields.js";
+import { invalidFields, literalField, propertyInitializer, propertyName, } from "./workflow-candidate-fields.js";
 export function protectedCall(node, symbols) {
     if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression))
         return false;
@@ -11,6 +11,7 @@ export function protectedCall(node, symbols) {
             symbols.protectedSymbol,
             symbols.handoffSymbol,
             symbols.commandSymbol,
+            symbols.commandWaitSymbol,
             symbols.reviewSymbol,
             ...symbols.mergeSymbols,
         ].includes(symbol));
@@ -26,6 +27,10 @@ export function commandCall(node, symbols) {
     const symbol = symbols.commandSymbol;
     return symbol !== undefined && calledSymbol(node, symbols) === symbol;
 }
+export function commandWaitCall(node, symbols) {
+    const symbol = symbols.commandWaitSymbol;
+    return symbol !== undefined && calledSymbol(node, symbols) === symbol;
+}
 export function reviewCall(node, symbols) {
     const symbol = symbols.reviewSymbol;
     return symbol !== undefined && calledSymbol(node, symbols) === symbol;
@@ -40,7 +45,7 @@ export function mergeCall(node, symbols) {
 export function protectedEffectFact(node, symbols) {
     if (!protectedCall(node, symbols))
         return undefined;
-    if (handoffCall(node, symbols))
+    if (handoffCall(node, symbols) || commandWaitCall(node, symbols))
         return undefined;
     const argument = node.arguments[0];
     if (!argument || !ts.isObjectLiteralExpression(argument))
@@ -81,6 +86,7 @@ function escapedHelper(node, symbols) {
             symbols.protectedSymbol,
             symbols.handoffSymbol,
             symbols.commandSymbol,
+            symbols.commandWaitSymbol,
             symbols.reviewSymbol,
             ...symbols.mergeSymbols,
         ].includes(symbol))
@@ -115,9 +121,22 @@ function invalidRequest(node, symbols) {
         ? propertyInitializer(argument, "reviewer")
         : undefined;
     return (invalidFields(argument) ||
-        (reviewer !== undefined &&
-            ts.isObjectLiteralExpression(reviewer) &&
-            invalidFields(reviewer)));
+        invalidCommandWaitFields(node, symbols) ||
+        invalidReviewer(reviewer));
+}
+function invalidReviewer(reviewer) {
+    return (reviewer !== undefined &&
+        ts.isObjectLiteralExpression(reviewer) &&
+        invalidFields(reviewer));
+}
+function invalidCommandWaitFields(node, symbols) {
+    if (!commandWaitCall(node, symbols))
+        return false;
+    const argument = node.arguments[0];
+    return (!!argument &&
+        ts.isObjectLiteralExpression(argument) &&
+        argument.properties.some((entry) => entry.name &&
+            !["name", "input"].includes(propertyName(entry.name) ?? "")));
 }
 function workflowBodyCall(node) {
     let child = node;
@@ -172,92 +191,3 @@ export function unsupportedCandidateNode(node, symbols) {
     ];
     return checks.some(Boolean);
 }
-export function workflowShape(source) {
-    const exported = source.statements.filter((node) => ts.isFunctionDeclaration(node) &&
-        (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword));
-    const candidate = exported[0];
-    if (exported.length !== 1 ||
-        !candidate ||
-        !ts.isFunctionDeclaration(candidate))
-        return false;
-    if (!workflowFunction(candidate))
-        return false;
-    const directives = [];
-    function visit(node) {
-        if (ts.isStringLiteral(node) && node.text === "use workflow")
-            directives.push(node);
-        ts.forEachChild(node, visit);
-    }
-    visit(source);
-    return directives.length === 1;
-}
-function workflowFunction(candidate) {
-    if (!candidate.name || !candidate.body || candidate.asteriskToken)
-        return false;
-    const modifiers = ts.getModifiers(candidate) ?? [];
-    if (!modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) ||
-        modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword))
-        return false;
-    const first = candidate.body.statements[0];
-    return first !== undefined && workflowDirective(first);
-}
-function workflowDirective(node) {
-    return (ts.isExpressionStatement(node) &&
-        ts.isStringLiteral(node.expression) &&
-        node.expression.text === "use workflow");
-}
-function unwrappedInitializer(node) {
-    if (ts.isParenthesizedExpression(node) ||
-        ts.isAsExpression(node) ||
-        ts.isSatisfiesExpression(node) ||
-        ts.isTypeAssertionExpression(node))
-        return node.expression;
-    return undefined;
-}
-function passiveCompound(node) {
-    if (ts.isArrayLiteralExpression(node))
-        return node.elements.every((element) => ts.isOmittedExpression(element) || passiveInitializer(element));
-    if (ts.isObjectLiteralExpression(node))
-        return node.properties.every((property) => ts.isPropertyAssignment(property) &&
-            !ts.isComputedPropertyName(property.name) &&
-            passiveInitializer(property.initializer));
-    return false;
-}
-function passiveInitializer(node) {
-    if (!node)
-        return false;
-    if (ts.isLiteralExpression(node))
-        return true;
-    if ([
-        ts.SyntaxKind.TrueKeyword,
-        ts.SyntaxKind.FalseKeyword,
-        ts.SyntaxKind.NullKeyword,
-    ].includes(node.kind))
-        return true;
-    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node))
-        return true;
-    if (ts.isPrefixUnaryExpression(node))
-        return ([ts.SyntaxKind.PlusToken, ts.SyntaxKind.MinusToken].includes(node.operator) && ts.isNumericLiteral(node.operand));
-    const inner = unwrappedInitializer(node);
-    return inner ? passiveInitializer(inner) : passiveCompound(node);
-}
-function passiveStatement(node, kind) {
-    if (ts.isVariableStatement(node))
-        return ((node.declarationList.flags & ts.NodeFlags.Const) !== 0 &&
-            node.declarationList.declarations.every((declaration) => (kind === "helper" ||
-                (ts.getCombinedModifierFlags(declaration) &
-                    ts.ModifierFlags.Export) ===
-                    0) &&
-                ts.isIdentifier(declaration.name) &&
-                passiveInitializer(declaration.initializer)));
-    if (ts.isExpressionStatement(node))
-        return ts.isStringLiteral(node.expression);
-    return (ts.isImportDeclaration(node) ||
-        ts.isTypeAliasDeclaration(node) ||
-        ts.isInterfaceDeclaration(node) ||
-        ts.isFunctionDeclaration(node) ||
-        ts.isEmptyStatement(node));
-}
-export function passiveCandidateModule(source, kind = "workflow") {
-    return source.statements.every((node) => passiveStatement(node, kind));
-}

package/dist/tools/workflow-command.js

@@ -80,8 +80,7 @@ function presentWorkflows(workflows, options) {
 }
 async function testWorkflows(workflows, options) {
     const { id, repository } = options;
-    const selected = workflows.filter((workflow) => workflow.scope !== "bundled" &&
-        (id === undefined || workflow.workflowId === id));
+    const selected = workflows.filter((workflow) => id === undefined || workflow.workflowId === id);
     if (id !== undefined &&
         !workflows.some((workflow) => workflow.workflowId === id)) {
         process.stderr.write("unknown-workflow: " + id + "\n");

package/dist/tools/workflow-folders.d.ts

@@ -1,6 +1,6 @@
 import type { WorkflowDeclaration } from "../src/workflow-declaration.ts";
 import { type CandidateDeclaration, type WorkflowCandidateCode } from "../src/workflow-candidate.ts";
-import { type WorkflowConflictCode, type WorkflowReservation } from "../src/workflow-discovery.ts";
+import { type WorkflowConflictCode } from "../src/workflow-discovery.ts";
 import type { CandidatePackageOptions } from "./workflow-candidate-program.ts";
 import { type WorkflowCaptureCode } from "./workflow-folder-capture.ts";
 export interface WorkflowFolderInput {
@@ -8,7 +8,6 @@ export interface WorkflowFolderInput {
     readonly home: string;
     readonly xdgConfigHome?: string | undefined;
     readonly userFolder?: string | undefined;
-    readonly bundled: readonly WorkflowReservation[];
 }
 interface WorkflowLabel {
     readonly scope: "project" | "user";
@@ -28,7 +27,7 @@ export interface WorkflowFolderRefusal extends WorkflowLabel {
     readonly codes: readonly (WorkflowCandidateCode | WorkflowCaptureCode | WorkflowConflictCode | "compile-failed")[];
 }
 export interface WorkflowListing {
-    readonly scope: "bundled" | "project" | "user";
+    readonly scope: "project" | "user";
     readonly workflowId: string | null;
     readonly file: string;
     readonly admitted: boolean;

package/dist/tools/workflow-folders.js

@@ -162,7 +162,7 @@ export async function loadWorkflowFolders(input, installed = {}) {
     const candidates = [];
     const refusals = [];
     const { repository, snapshots } = await scanFolders(input, refusals);
-    const conflicts = workflowConflicts(snapshots.map(identity), input.bundled);
+    const conflicts = workflowConflicts(snapshots.map(identity));
     for (const [index, entry] of snapshots.entries()) {
         const label = entry.kind === "captured" ? entry.snapshot : entry;
         const codes = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloving",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "Local durable development workflow service",
   "license": "MIT",
   "repository": {
@@ -31,10 +31,6 @@
       "types": "./dist/src/steps/protected-effect.d.ts",
       "import": "./dist/src/steps/protected-effect.js"
     },
-    "./workflows/steps/decision-gate": {
-      "types": "./dist/src/steps/decision-gate.d.ts",
-      "import": "./dist/src/steps/decision-gate.js"
-    },
     "./workflows/steps/review-subject": {
       "types": "./dist/src/steps/review-subject.d.ts",
       "import": "./dist/src/steps/review-subject.js"
@@ -55,6 +51,10 @@
       "types": "./dist/src/steps/merge-when-green.d.ts",
       "import": "./dist/src/steps/merge-when-green.js"
     },
+    "./workflows/steps/open-decision-wait": {
+      "types": "./dist/src/steps/open-decision-wait.d.ts",
+      "import": "./dist/src/steps/open-decision-wait.js"
+    },
     "./workflows/steps/wait-for-decision": {
       "types": "./dist/src/steps/wait-for-decision.d.ts",
       "import": "./dist/src/steps/wait-for-decision.js"
@@ -78,12 +78,19 @@
     "./workflows/steps/sleep": {
       "types": "./dist/src/steps/sleep.d.ts",
       "import": "./dist/src/steps/sleep.js"
+    },
+    "./workflows/steps/wait-for-command": {
+      "types": "./dist/src/steps/wait-for-command.d.ts",
+      "import": "./dist/src/steps/wait-for-command.js"
+    },
+    "./workflows/steps/command-wait": {
+      "types": "./dist/src/steps/command-wait.d.ts",
+      "import": "./dist/src/steps/command-wait.js"
     }
   },
   "files": [
     "dist/src",
     "dist/tools",
-    "dist/workflows",
     "templates",
     "assets/watch-fonts/fira-code-latin-400-normal.woff2",
     "assets/watch-fonts/fira-code-latin-500-normal.woff2",
@@ -112,7 +119,7 @@
     "x64"
   ],
   "scripts": {
-    "build": "tsc --project tsconfig.build.json && node tools/copy-workflow-declarations.ts workflows dist/workflows",
+    "build": "tsc --project tsconfig.build.json",
     "build:workflows": "node tools/compile-workflows.ts",
     "check:setup": "node tools/check-shells.ts && tsc --project tsconfig.json --noEmit",
     "check:quality": "node tools/check-quality.ts",
@@ -121,7 +128,7 @@
     "check:format": "prettier --check src tools quality test eslint.config.mjs package.json tsconfig.json tsconfig.build.json",
     "test:quality": "node --test test/quality/*.test.ts",
     "record:test-durations": "node tools/record-test-durations.ts",
-    "test:scale": "node --test --test-concurrency=1 test/authority-opening-scale.benchmark.ts",
+    "test:scale": "node --test --test-concurrency=1 test/authority-opening-scale.benchmark.ts test/status-scale.benchmark.ts",
     "check": "node tools/quality-pending.ts",
     "test:concurrency": "node tools/quality-pending.ts"
   },
@@ -150,6 +157,7 @@
     "preact": "11.0.0",
     "solid-objects": "1.0.2",
     "typescript": "6.0.3",
-    "workflow": "5.1.0"
+    "workflow": "5.1.0",
+    "yaml": "2.9.1"
   }
 }

package/templates/develop/README.md

@@ -1,6 +1,6 @@
 # Develop template decisions
 
-`template.json` describes the five decisions used by the develop template.
+`template.json` describes the six decisions used by the develop template.
 The default workflow in `develop.ts` accepts the declared ticket input, selects
 from the queue, opens a pull request, waits for Greptile at 5/5, and calls
 `mergeWhenGreen` with `check: "beforeMerge"`. Its declaration and helper files
@@ -14,13 +14,26 @@ review or repairable merge result gives its full output and remaining work to
 the next worker turn. Review, local-check, conflict and CI fixes share a limit
 of three fix rounds. Pending CI and an unconfigured check stop the run.
 
+`develop/pull.ts` keeps the first line of the ticket as the pull request title,
+removes leading `#` characters and limits it to 200 characters. For a task with
+a GitHub issue, the pull request body links that issue and names its number:
+
+```text
+Refs cloving-ai/cloving-ai#375
+
+Cloving made this change for the ticket 375.
+```
+
+A task without a GitHub issue uses only `Cloving made this change for this task.`
+
 `develop.test.ts` and `develop/flow-tests.ts` test the default composition through the public fake
 step bridge. The alternative configurations use `develop/option-tests.ts`, with the selected
 point IDs in `develop/scenarios.ts`. For an edited copy, replace the default
 `flowTests` and `refusalTests` imports in `develop.test.ts` with
 `optionTests as flowTests`, then run every `flowTests` scenario. Keep the shared
-turn and partial-helper tests. Package tests apply each source edit, validate
-its requirements, and test seven complete configurations through the folder
+turn, partial-helper and interruption tests. `develop/interruption-tests.ts`
+follows the selected point IDs, so it tests each configuration. Package tests apply each source edit, validate
+its requirements, and test ten complete configurations through the folder
 loader and the installed package, covering every option.
 
 `develop/turn.ts` implements the development turn for either a resolved
@@ -32,6 +45,22 @@ allow the initial turn and three fix turns; the workflow must stop after that.
 The package tests also load small compositions of this helper through folder
 admission for both input forms and test both forms in complete workflows.
 
+`developReport` in `develop/report.ts` runs the turn again once when its result
+has the reason `claude-turn-interrupted`. This occurs when the daemon cannot
+resume an open turn after a restart. Before the daemon reports this reason, it
+stops the processes of the earlier turn in the work tree. The new turn has the same target, so the
+daemon gives it the same work tree. Its scope adds the key `continuation`, and
+its prompt tells the worker that the earlier turn stopped before its report.
+The worker checks the work tree, the commits since the start of the round, and
+the ticket before it continues.
+
+After a second interruption of the same turn, `developReport` returns a blocked
+outcome with the reason `turn-interrupted`. `develop/round.ts` and
+`develop/local.ts` return this outcome before they use the report. A
+pull-request workflow then adds `cloving: blocked` to the GitHub issue of the
+ticket. Other results that are not `completed` fail the run. The default effect
+limit of 31 includes one more turn in each of the four rounds.
+
 `develop/partial.ts` implements the person's partial-work question.
 `develop/partial-choice.ts` connects its answer to a development report and the
 next round, or returns a blocked outcome without opening a review or merging. `reviewPartial`
@@ -56,10 +85,70 @@ Task text keeps its full contents, including any issue-looking lines, without
 selecting an issue to label, close or return to the queue.
 
 The first option of each point is the default: ticket input, queue selection,
-Greptile at 5/5, merge after checks, and return partial work to the queue.
+no additional verification, Greptile at 5/5, merge after checks, and return
+partial work to the queue.
 Selecting `person` at selection, acceptance and partial work, with `local` at
 merge, describes the existing reviewed local-branch process.
 
+The `verify` point defaults to `none`, preserving the current round and
+declaration. Select `red-green` with either `green` or `person` at `merge`.
+Import `verifyRedGreen` from `develop/red-green.ts` in `develop/round.ts`.
+Immediately after `openPull`, before constructing the review subject or
+calling `acceptWork`, add:
+
+```typescript
+const verification = await verifyRedGreen({
+  cycleId: input.cycleId,
+  head: pull.commit,
+  round,
+});
+if (verification !== null && "kind" in verification) return verification;
+if (verification !== null)
+  return repair({ cycleId: input.cycleId, round, report, result: verification });
+```
+
+Add `"command"` to `workflow.capabilities`, `"commands": ["red-green"]` to
+`workflow`, and `"command": ["run:red-green"]` to `methods` in
+`develop.declaration.json`. Increase `workflow.effectLimit` by 4, from 31 to
+35, allowing one verification command in each of the four development rounds.
+Set `selection.verify` to `"red-green"` in `develop/scenarios.ts` and run the
+option tests. The local merge option does not support this verification.
+
+The helper calls the operator command on the pull request's immutable head with
+scope `{ phase: "verify", operation: "red-green", round }`.
+`accepted` and `no-test-change` proceed to review. `false-red`,
+`red-not-assertion`, `skipped-test` and `green-failed` pass the verdict and full
+tool output through `repair` to the next fix turn. These fixes share the
+existing four-round limit with review and merge fixes. `prepare-failed`, a
+failed command or an invalid result blocks immediately with
+`red-green-unavailable`, without a fix turn.
+
+Register `red-green` in `CLOVING_COMMANDS` as an argument array containing the
+absolute path of the installed `cloving` executable followed by `"red-green"`.
+Configure the project file `.cloving/config.json`, for example:
+
+```json
+{
+  "version": 1,
+  "checks": {
+    "redGreen": {
+      "test": ["node", "--test"],
+      "testFiles": ["test/"],
+      "prepare": ["npm", "ci", "--ignore-scripts"]
+    }
+  }
+}
+```
+
+The tool appends changed test paths to `test`; optional `prepare` runs in each
+temporary worktree. The daemon passes this configuration as
+`CLOVING_RED_GREEN`. For direct tool use, set that variable to the `redGreen`
+object. The repository needs `refs/remotes/origin/HEAD` to identify the base.
+Increase `CLOVING_COMMAND_SECONDS`, for example to `600`, to cover both
+preparation and test runs. Optional `assertionPattern` and `skipPattern`
+override the defaults for non-terminal `node --test` output. See the package
+README's `cloving red-green` documentation for the tool's complete contract.
+
 Each option has an `id`, `label`, `summary`, `change`, `requires` and `needs`.
 `change` describes the step call or declaration edit for the setup agent.
 It is guidance for editing source, rather than an executable patch.

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

@@ -116,6 +116,10 @@ flowTests.push({
       (request) => request[0] === "effect" && request[1].method === "open-pr",
     );
     assert.ok(opened && opened[0] === "effect");
+    assert.deepEqual(JSON.parse(opened[1].payload), {
+      title: "Fix the counter",
+      body: "Refs acme/demo#42\n\nCloving made this change for the ticket 42.",
+    });
     assert.doesNotMatch(opened[1].payload, /private-check-output/);
   },
 });
@@ -123,7 +127,7 @@ flowTests.push({
 flowTests.push({
   name: "CLV-221 the default workflow merges only a reviewed pull after the checks",
   run: async () => {
-    using bridge = fakeStepBridge({ effects: effects(), effectLimit: 27 });
+    using bridge = fakeStepBridge({ effects: effects(), effectLimit: 31 });
     assert.deepEqual(await develop(input), {
       kind: "handoff_requested",
       cycleId: input.cycleId,
@@ -355,3 +359,36 @@ flowTests.push({
     });
   },
 });
+
+flowTests.push({
+  name: "the develop turns keep fail-closed checks and operator steps out of the remaining list",
+  run: async () => {
+    const scenario = effects();
+    for (const key of [
+      "claude run-turn",
+      "github open-pr",
+      "github wait-review",
+    ] as const)
+      scenario[key] = [...scenario[key], ...scenario[key]];
+    scenario["github merge"] = [
+      completed({ reason: "check-failed", output: "Check output.\n" }),
+      ...scenario["github merge"],
+    ];
+    using bridge = fakeStepBridge({ effects: scenario });
+    await develop(input);
+    const payloads = bridge.requests.flatMap((request) =>
+      request[0] === "effect" && request[1].method === "run-turn"
+        ? [request[1].payload]
+        : [],
+    );
+    for (const sentence of [
+      "List as remaining only work that the task asks for.",
+      "A check that the repository keeps fail-closed on purpose is not remaining work.",
+      "A step that the task gives to the operator is not remaining work.",
+    ])
+      assert.ok(payloads[0]?.includes(sentence), sentence);
+    assert.ok(
+      payloads[1]?.includes("Drop an item that the task does not ask for"),
+    );
+  },
+});