cloving 1.4.0 → 1.5.0

package/dist/tools/self-host-project.js

@@ -113,6 +113,19 @@ function operatorDeclaration(staged, compiled) {
         functionName: workflow.workflowId.slice(workflow.workflowId.lastIndexOf("//") + 2),
     };
 }
+async function recordProject(settings) {
+    const { project, recordedProject } = settings;
+    if (recordedProject === undefined)
+        return;
+    for (const name of [
+        "flow.mjs.__wf_tmp.js.debug.json",
+        "steps.mjs.debug.json",
+    ]) {
+        const path = join(project, "artifacts", name);
+        const text = await readFile(path, "utf8");
+        await writeFile(path, text.replaceAll(`${project}/`, `${recordedProject}/`));
+    }
+}
 async function writeManifests(project, compiled) {
     const manifests = {};
     for (const [functionName, manifest] of Object.entries(compiled)) {
@@ -126,6 +139,13 @@ async function writeManifests(project, compiled) {
     return manifests;
 }
 export async function preparedProject(settings) {
+    const prepared = await preparedBundle(settings);
+    const modules = join(dirname(settings.project), "workflow-bundles/node_modules");
+    await rm(modules, { force: true });
+    await symlink(join(settings.project, "node_modules"), modules);
+    return prepared;
+}
+export async function preparedBundle(settings) {
     const { product, project } = settings;
     await initializeProject(settings);
     const folders = await loadWorkflowFolders(settings, {
@@ -133,6 +153,7 @@ export async function preparedProject(settings) {
     });
     const staged = await stageCandidates(project, folders.candidates);
     const compiled = await compile(settings);
+    await recordProject(settings);
     const combined = staged.map((candidate) => operatorDeclaration({ ...candidate, project }, compiled));
     const manifests = await writeManifests(project, workflowManifests(compiled, combined));
     await writeFile(join(project, "declarations.json"), JSON.stringify(combined));
@@ -145,9 +166,6 @@ export async function preparedProject(settings) {
         repository: folders.repository,
         directory: join(dirname(project), "workflow-bundles"),
     });
-    const modules = join(dirname(project), "workflow-bundles/node_modules");
-    await rm(modules, { force: true });
-    await symlink(join(project, "node_modules"), modules);
     return {
         workflows: folders.workflows,
         repository: folders.repository,

package/dist/tools/self-host.js

@@ -1,10 +1,9 @@
 import { turnHarness, harnessDefaults, nativeHarness, } from "../src/harness-defaults.js";
 import { absoluteWorkflowFolder } from "../src/project-settings.js";
-import { projectConfiguration, projectRoot, topLevel, } from "./project-configuration.js";
-import { isProfilesFile } from "../src/turn-profile.js";
+import { retentionSettings, } from "../src/record-retention.js";
+import { configurationDigests, configuredTurnSettings, projectConfiguration, projectRoot, topLevel, } from "./project-configuration.js";
 import { parseCommands, parseCommandSeconds, } from "../src/command-settings.js";
-import { parseFallbackModels, parseTokenPrices, } from "../src/token-prices.js";
-import { readFile, writeFile } from "node:fs/promises";
+import { writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, extname, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -66,19 +65,12 @@ function checkedWorker(name) {
         });
     }
 }
-async function profilesFile() {
-    const path = environment["CLOVING_PROFILES"];
-    if (path === undefined)
-        return configuration.profiles;
-    try {
-        const value = JSON.parse(await readFile(path, "utf8"));
-        if (isProfilesFile(value))
-            return value.profiles;
-    }
-    catch {
-        throw new Error("The daemon did not start: invalid-profiles");
-    }
-    throw new Error("The daemon did not start: invalid-profiles");
+function startRefusal(error) {
+    if (error instanceof Error && error.message === "invalid-profiles")
+        throw new Error("The daemon did not start: invalid-profiles", {
+            cause: error,
+        });
+    throw error;
 }
 function queueLanes() {
     const value = environment["CLOVING_QUEUE_LANES"];
@@ -153,6 +145,8 @@ if (opening.kind !== "started") {
   process.exit(1);
 }
 process.stdout.write(${JSON.stringify(guide(workflows))});
+process.send?.("started");
+process.channel?.unref();
 const stop = async () => { await opening.daemon.close(); process.exit(0); };
 process.once("SIGINT", stop);
 process.once("SIGTERM", stop);
@@ -193,11 +187,9 @@ function guide(workflows) {
         "",
     ].join("\n");
 }
-const tokenPrices = parseTokenPrices(environment["CLOVING_TOKEN_PRICES"]);
+const { tokenPrices, fallbackModels, profiles } = await configuredTurnSettings(configuration).catch(startRefusal);
 const commands = parseCommands(environment["CLOVING_COMMANDS"]);
 const commandSeconds = parseCommandSeconds(environment["CLOVING_COMMAND_SECONDS"]);
-const fallbackModels = parseFallbackModels(environment["CLOVING_FALLBACK_MODELS"]);
-const profiles = await profilesFile();
 const schedules = parseSchedulesSetting(environment["CLOVING_SCHEDULES"]);
 const worker = selectedWorker();
 function nativeCommands() {
@@ -219,14 +211,18 @@ const ticketCommand = listed("CLOVING_TICKET_COMMAND");
 const queueDailySpendLimitUsd = queueSpendLimit();
 const lanes = queueLanes();
 const queueMilliseconds = queueInterval();
-const manifests = await preparedProject({
-    product,
-    project,
+const retention = retentionSettings(environment);
+const places = {
     repository,
     home: homedir(),
     xdgConfigHome: environment["XDG_CONFIG_HOME"],
+};
+const folders = {
+    ...places,
     userFolder: absoluteWorkflowFolder(environment["CLOVING_WORKFLOW_FOLDER"]),
-});
+};
+const profilesPath = environment["CLOVING_PROFILES"];
+const manifests = await preparedProject({ product, project, ...folders });
 await launchers({
     commands,
     commandSeconds,
@@ -238,6 +234,7 @@ await launchers({
     harness,
     shell: environment["SHELL"] ?? "/bin/sh",
     profiles,
+    settingDigests: configurationDigests(configuration, profiles),
     command,
     ticketCommand,
     nextCommand,
@@ -245,11 +242,24 @@ await launchers({
     queueLanes: lanes,
     queueDailySpendLimitUsd,
     resetQueue: flags.includes("--reset-queue"),
+    retention,
     notifyCommand: listed("CLOVING_NOTIFY_COMMAND"),
     githubCommand: listed("CLOVING_GH_COMMAND"),
     requiredChecks: listed("CLOVING_REQUIRED_CHECKS") ?? null,
     checkCommand: listed("CLOVING_CHECK_COMMAND"),
     privateTexts: listed("CLOVING_PRIVATE_TEXTS"),
+    reloadCommand: [
+        process.execPath,
+        join(product, `tools/self-host-reload${extname(import.meta.filename)}`),
+        JSON.stringify({
+            directory,
+            ...places,
+            ...(profilesPath === undefined
+                ? {}
+                : { profilesFile: resolve(profilesPath) }),
+            fileVariables: Object.keys(environment).filter((name) => process.env[name] === undefined),
+        }),
+    ],
 }, manifests);
 process.exitCode = await hostedPrograms({
     environment,

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

@@ -5,9 +5,11 @@ export interface CandidatePackageOptions {
     readonly helpers?: Readonly<Record<string, string>>;
 }
 export declare function resolvedSymbol(checker: ts.TypeChecker, symbol: ts.Symbol | undefined): ts.Symbol | undefined;
-export declare function candidateProgram(text: string, installed?: CandidatePackageOptions): {
+export interface CandidateProgram {
     readonly program: ts.Program;
     readonly source: ts.SourceFile;
     readonly sources: readonly ts.SourceFile[];
     readonly modules: ReadonlyMap<string, ts.SourceFile>;
-};
+}
+export declare function candidateProgram(text: string, installed?: CandidatePackageOptions): CandidateProgram;
+export declare function candidateCompiler(installed?: CandidatePackageOptions): (text: string) => CandidateProgram;

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

@@ -10,9 +10,12 @@ export function resolvedSymbol(checker, symbol) {
     return checker.getAliasedSymbol(symbol);
 }
 export function candidateProgram(text, installed = {}) {
+    return candidateCompiler(installed)(text);
+}
+export function candidateCompiler(installed = {}) {
     const packageRoot = resolve(installed.packageRoot ?? candidatePackageRoot);
     const candidate = join(packageRoot, "candidate.ts");
-    const sources = new Map([[candidate, text]]);
+    const sources = new Map([[candidate, ""]]);
     for (const [name, content] of Object.entries(installed.helpers ?? {})) {
         if (workflowHelperPath("candidate.ts", `./${name}`) !== name)
             throw new Error("invalid-workflow-helper");
@@ -32,12 +35,18 @@ export function candidateProgram(text, installed = {}) {
         noEmit: true,
     };
     const host = trustedHost({ sources, options, entries, packageRoot });
-    const program = ts.createProgram([...sources.keys(), ...entries.values()], options, host);
-    const source = program.getSourceFile(candidate);
+    return (text) => {
+        sources.set(candidate, text);
+        const program = ts.createProgram([...sources.keys(), ...entries.values()], options, host);
+        return compiledCandidate(program, { candidate, sources, entries });
+    };
+}
+function compiledCandidate(program, input) {
+    const source = program.getSourceFile(input.candidate);
     if (!source)
         throw new Error("candidate-analysis-unavailable");
     const modules = new Map();
-    for (const [name, file] of entries) {
+    for (const [name, file] of input.entries) {
         const declaration = program.getSourceFile(file);
         if (!declaration)
             throw new Error("candidate-surface-unavailable");
@@ -47,7 +56,7 @@ export function candidateProgram(text, installed = {}) {
         program,
         source,
         modules,
-        sources: [...sources.keys()].map((name) => {
+        sources: [...input.sources.keys()].map((name) => {
             const entry = program.getSourceFile(name);
             if (!entry)
                 throw new Error("candidate-analysis-unavailable");
@@ -55,6 +64,21 @@ export function candidateProgram(text, installed = {}) {
         }),
     };
 }
+function sourceReader(readFile) {
+    const declarations = new Map();
+    return (file, languageVersion) => {
+        const content = readFile(file);
+        if (content === undefined)
+            return undefined;
+        const cached = declarations.get(file);
+        if (cached?.text === content)
+            return cached;
+        const source = ts.createSourceFile(file, content, languageVersion, true);
+        if (file.endsWith(".d.ts"))
+            declarations.set(file, source);
+        return source;
+    };
+}
 function trustedHost(input) {
     const { sources, options, entries, packageRoot } = input;
     const libraries = dirname(ts.getDefaultLibFilePath(options)) + sep;
@@ -72,12 +96,7 @@ function trustedHost(input) {
     const host = ts.createCompilerHost(options);
     host.readFile = readFile;
     host.fileExists = (file) => readFile(file) !== undefined;
-    host.getSourceFile = (file, languageVersion) => {
-        const content = readFile(file);
-        return content === undefined
-            ? undefined
-            : ts.createSourceFile(file, content, languageVersion, true);
-    };
+    host.getSourceFile = sourceReader(readFile);
     host.resolveModuleNameLiterals = (names, containingFile) => names.map(({ text: name }) => {
         const installed = entries.get(name);
         if (installed)

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

@@ -1,5 +1,6 @@
 import { type CandidatePackageOptions } from "./workflow-candidate-program.ts";
 import type { CandidateAnalysis, InstalledWorkflowExports } from "../src/workflow-candidate.ts";
+export declare function createWorkflowCandidateAnalyzer(installed?: CandidatePackageOptions): (text: string) => ReturnType<typeof analyzeWorkflowCandidate>;
 export declare function analyzeWorkflowCandidate(text: string, installed?: CandidatePackageOptions): {
     readonly analysis: CandidateAnalysis;
     readonly installedExports: InstalledWorkflowExports;

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

@@ -1,12 +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 { 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);
@@ -90,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,
@@ -125,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 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloving",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Local durable development workflow service",
   "license": "MIT",
   "repository": {
@@ -128,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"
   },

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
@@ -31,8 +31,9 @@ step bridge. The alternative configurations use `develop/option-tests.ts`, with
 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
@@ -44,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`
@@ -68,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

@@ -127,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,

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 (