cloving 1.1.0 → 1.3.0

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

@@ -0,0 +1,213 @@
+import ts from "typescript";
+const ambientNames = new Set([
+    "globalThis",
+    "global",
+    "window",
+    "self",
+    "process",
+    "Date",
+    "performance",
+    "fetch",
+    "WebSocket",
+    "Worker",
+    "crypto",
+    "setTimeout",
+    "setInterval",
+    "setImmediate",
+    "queueMicrotask",
+    "eval",
+    "Function",
+    "require",
+    "console",
+    "navigator",
+    "Atomics",
+    "SharedArrayBuffer",
+    "WeakRef",
+    "FinalizationRegistry",
+    "Intl",
+]);
+const candidateNames = new Set([
+    "Buffer",
+    "document",
+    "screen",
+    "history",
+    "location",
+    "localStorage",
+    "sessionStorage",
+    "indexedDB",
+    "caches",
+    "Deno",
+    "Bun",
+    "__dirname",
+    "__filename",
+    "File",
+    "FileReader",
+    "readFile",
+    "writeFile",
+    "XMLHttpRequest",
+    "EventSource",
+    "WebTransport",
+    "BroadcastChannel",
+    "MessageChannel",
+    "MessagePort",
+    "postMessage",
+    "clearTimeout",
+    "clearInterval",
+    "clearImmediate",
+    "requestAnimationFrame",
+    "requestIdleCallback",
+    "cancelAnimationFrame",
+    "cancelIdleCallback",
+    "AbortSignal",
+    "Reflect",
+    "Proxy",
+    "constructor",
+    "WebAssembly",
+]);
+const reflectiveProperties = new Set(["constructor", "__proto__", "prototype"]);
+const candidateProperties = new Set([
+    "getPrototypeOf",
+    "setPrototypeOf",
+    "getOwnPropertyDescriptor",
+    "getOwnPropertyDescriptors",
+]);
+const pureMathMembers = new Set([
+    "E",
+    "LN10",
+    "LN2",
+    "LOG10E",
+    "LOG2E",
+    "PI",
+    "SQRT1_2",
+    "SQRT2",
+    "abs",
+    "acos",
+    "acosh",
+    "asin",
+    "asinh",
+    "atan",
+    "atan2",
+    "atanh",
+    "cbrt",
+    "ceil",
+    "clz32",
+    "cos",
+    "cosh",
+    "exp",
+    "expm1",
+    "floor",
+    "fround",
+    "hypot",
+    "imul",
+    "log",
+    "log10",
+    "log1p",
+    "log2",
+    "max",
+    "min",
+    "pow",
+    "round",
+    "sign",
+    "sin",
+    "sinh",
+    "sqrt",
+    "tan",
+    "tanh",
+    "trunc",
+]);
+function localBinding(symbol) {
+    return (symbol.declarations ?? []).some((declaration) => !declaration.getSourceFile().isDeclarationFile &&
+        (ts.getCombinedModifierFlags(declaration) & ts.ModifierFlags.Ambient) ===
+            0);
+}
+export function referenceSymbol(node, context) {
+    const { parent, checker } = context;
+    if (parent &&
+        (ts.isPropertyAccessExpression(parent) ||
+            ts.isPropertyAssignment(parent)) &&
+        parent.name === node)
+        return undefined;
+    if (parent && ts.isShorthandPropertyAssignment(parent))
+        return checker.getShorthandAssignmentValueSymbol(parent);
+    return checker.getSymbolAtLocation(node);
+}
+function referenceIdentifier(node, parent) {
+    if (!ts.isIdentifier(node))
+        return false;
+    if (!parent)
+        return true;
+    if ((ts.isPropertyAccessExpression(parent) ||
+        ts.isPropertyAssignment(parent)) &&
+        parent.name === node)
+        return false;
+    return !ts.isImportSpecifier(parent);
+}
+function restrictedAmbientName(name, context) {
+    return (ambientNames.has(name) ||
+        name === "Math" ||
+        (context.profile === "candidate" && candidateNames.has(name)));
+}
+function pureMathAccess(node, parent) {
+    return (!!parent &&
+        ts.isPropertyAccessExpression(parent) &&
+        parent.expression === node &&
+        pureMathMembers.has(parent.name.text));
+}
+function ambientReference(node, context) {
+    const { parent } = context;
+    if (!referenceIdentifier(node, parent))
+        return false;
+    if (!restrictedAmbientName(node.text, context))
+        return false;
+    const candidate = context.profile === "candidate";
+    const symbol = referenceSymbol(node, context);
+    if ((!symbol && !candidate) || (symbol && localBinding(symbol)))
+        return false;
+    return node.text !== "Math" || !pureMathAccess(node, parent);
+}
+function reflectiveAccess(node, context) {
+    const candidate = context.profile === "candidate";
+    const restricted = (name) => reflectiveProperties.has(name) ||
+        (candidate && candidateProperties.has(name));
+    if (ts.isPropertyAccessExpression(node))
+        return restricted(node.name.text);
+    if (ts.isElementAccessExpression(node) &&
+        ts.isStringLiteralLike(node.argumentExpression))
+        return restricted(node.argumentExpression.text);
+    if (!candidate || !ts.isBindingElement(node))
+        return false;
+    const name = node.propertyName ?? node.name;
+    return ((ts.isIdentifier(name) || ts.isStringLiteralLike(name)) &&
+        restricted(name.text));
+}
+function dynamicCapability(node, checker) {
+    if (!ts.isElementAccessExpression(node))
+        return false;
+    const target = checker.getTypeAtLocation(node.expression);
+    return (target.getCallSignatures().length > 0 ||
+        target.getConstructSignatures().length > 0);
+}
+export function typeOnlyEffectNode(node) {
+    return ((ts.isTypeNode(node) && !ts.isExpressionWithTypeArguments(node)) ||
+        ts.isInterfaceDeclaration(node) ||
+        ts.isTypeAliasDeclaration(node));
+}
+export function restrictedEffect(node, context) {
+    return (ambientReference(node, context) ||
+        reflectiveAccess(node, context) ||
+        dynamicCapability(node, context.checker));
+}
+export function sourceEffectNodes(source, context) {
+    const findings = [];
+    function visit(node, parent) {
+        if (typeOnlyEffectNode(node))
+            return;
+        if (restrictedEffect(node, { ...context, parent }))
+            findings.push(node);
+        ts.forEachChild(node, (child) => {
+            visit(child, node);
+        });
+    }
+    visit(source);
+    return findings;
+}

package/dist/tools/workflow-test-hook.d.ts

@@ -0,0 +1,7 @@
+export declare function workflowTestHook(input: {
+    readonly root: string;
+    readonly extension: string;
+    readonly exports: Readonly<Record<string, {
+        readonly import: string;
+    }>>;
+}): string;

package/dist/tools/workflow-test-hook.js

@@ -0,0 +1,16 @@
+export function workflowTestHook(input) {
+    const modules = Object.fromEntries(Object.entries(input.exports).map(([subpath, target]) => {
+        const path = target.import
+            .replace("./dist/", "./")
+            .replace(/\.js$/, input.extension);
+        return ["cloving" + subpath.slice(1), new URL(path, input.root).href];
+    }));
+    const hook = `import { registerHooks } from "node:module";
+const modules = ${JSON.stringify(modules)};
+registerHooks({
+  resolve(specifier, context, nextResolve) {
+    return nextResolve(modules[specifier] ?? specifier, context);
+  },
+});`;
+    return "data:text/javascript," + encodeURIComponent(hook);
+}

package/dist/tools/workflow-test-loader.d.ts

@@ -0,0 +1 @@
+export declare function workflowTestLoader(): string;

package/dist/tools/workflow-test-loader.js

@@ -0,0 +1,10 @@
+import { extname } from "node:path";
+import packageMetadata from "#package" with { type: "json" };
+import { workflowTestHook } from "./workflow-test-hook.js";
+export function workflowTestLoader() {
+    return workflowTestHook({
+        root: new URL("../", import.meta.url).href,
+        extension: extname(import.meta.filename),
+        exports: packageMetadata.exports,
+    });
+}

package/dist/workflows/develop-prd.js

@@ -1,4 +1,5 @@
 import { protectedEffect } from "cloving/workflows/steps/protected-effect";
+import { handoff } from "cloving/workflows/steps/handoff";
 const draft = "cloving-prd-draft.md";
 const noCommit = "Do not commit and do not push. Work only in this work tree.";
 function issueNumber(result) {
@@ -67,9 +68,76 @@ function requests(input) {
         units: 1,
     }));
 }
+function readyIssue(input, issueResult) {
+    const { number, result } = issueResult;
+    const created = JSON.parse(result ?? "null");
+    const url = typeof created === "object" && created !== null && "url" in created
+        ? created.url
+        : undefined;
+    const issue = typeof url === "string"
+        ? /^https?:\/\/[^/\s]+\/([\w.-]+)\/([\w.-]+)\/issues\/([1-9]\d*)$/.exec(url)
+        : null;
+    if (issue === null || Number(issue[3]) !== number)
+        throw new Error("invalid-issue-result");
+    return {
+        scope: { phase: "prd", operation: "github-ready", round: 1 },
+        capability: "github",
+        method: "label",
+        target: input.cycleId,
+        units: 1,
+        payload: JSON.stringify({
+            owner: issue[1],
+            repository: issue[2],
+            number,
+            add: ["cloving: ready"],
+            remove: [],
+        }),
+    };
+}
+async function handoffIssue(input, created) {
+    const { number } = created;
+    const outcome = {
+        kind: "handoff_requested",
+        cycleId: input.cycleId,
+        promotionId: `issue-${String(number)}`,
+    };
+    try {
+        await handoff({
+            workflowId: "develop-issue",
+            input: { ticket: String(number) },
+        });
+        return outcome;
+    }
+    catch (error) {
+        const reason = handoffReason(error);
+        const queued = await protectedEffect(readyIssue(input, created));
+        return {
+            ...outcome,
+            reason,
+            ...(queued.kind === "completed" ? {} : { issueUpdate: "failed" }),
+        };
+    }
+}
+function handoffReason(error) {
+    const cause = typeof error === "object" && error !== null && "cause" in error
+        ? error.cause
+        : error;
+    if (typeof cause !== "object" ||
+        cause === null ||
+        !("message" in cause) ||
+        typeof cause.message !== "string")
+        return "handoff-failed";
+    return /^[a-z][a-z0-9-]{0,127}$/.test(cause.message)
+        ? cause.message
+        : "handoff-failed";
+}
 export async function developPrd(input) {
     "use workflow";
-    let promotionId = "";
+    let outcome = {
+        kind: "handoff_requested",
+        cycleId: input.cycleId,
+        promotionId: "",
+    };
     for (const request of requests(input)) {
         const result = await protectedEffect(request);
         if (result.kind !== "completed")
@@ -91,7 +159,7 @@ export async function developPrd(input) {
                 reason: "invalid-issue-result",
                 evidenceId: request.scope.operation,
             };
-        promotionId = `issue-${String(number)}`;
+        outcome = await handoffIssue(input, { number, result: result.result });
     }
-    return { kind: "handoff_requested", cycleId: input.cycleId, promotionId };
+    return outcome;
 }

package/dist/workflows/develop-ticket.js

@@ -76,6 +76,11 @@ async function merged(input, done) {
             cycleId: input.cycleId,
             promotionId: `pull-request-${String(number)}`,
         };
+    if (merge.result["reason"] === "ci-pending")
+        return blocked(input.cycleId, {
+            reason: `The merge has the result ci-pending: ${part(merge.result, "output")}. The pull request stays open: ${done.pull.url}`,
+            evidenceId: "github-merge",
+        });
     if (done.round > lastFix)
         return blocked(input.cycleId, {
             reason: `The merge has the result ${merge.result["reason"]} in round ${String(done.round)}, and a run has at most ${String(lastFix)} fix rounds. The pull request stays open: ${done.pull.url}`,
@@ -185,7 +190,7 @@ export async function developTicket(input, decision) {
     });
     if (turn.kind !== "completed")
         return blocked(cycleId, {
-            reason: `The Claude turn has the result ${turn.kind}.`,
+            reason: `The worker turn has the result ${turn.kind}.`,
             evidenceId: "claude-turn",
         });
     const gate = await decisionGate({

package/dist/workflows/ticket-prompts.js

@@ -8,9 +8,10 @@ function instructions(repository) {
         `If this work tree has no node_modules folder and the main repository has one, make a copy-on-write clone: cp -c -R ${repository}/node_modules node_modules`,
         "Follow the instructions of the repository (AGENTS.md and CLAUDE.md).",
         "Use test-driven development: write a test that fails, see it fail, then write the code.",
-        "Run the checks of the repository before you finish.",
+        "Run the checks of the repository before you finish. Commit your work before the report. If the repository provides npm run check:clean, run it after committing.",
+        "Treat a check time warning as work to do in the same ticket when your change made the check slower.",
         "Commit your work on the current branch. Do not push. Do not change a different branch.",
-        "End with a short report: what you changed, the checks that you ran with their results, and what is not done. End the report with exactly one of the lines Ticket status: complete or Ticket status: partial. Before a partial status line, include Remaining: followed by a list with one item on each line, using a dash and a space before each item.",
+        "End with a short report: what you changed, the checks that you ran with their results, and what is not done. End the report with exactly one of the lines Ticket status: complete or Ticket status: partial. Before a partial status line, include Remaining: followed by a list with one item on each line, using a dash and a space before each item. Blank lines are allowed around and between list items.",
     ].join("\n");
 }
 function named(input) {
@@ -37,8 +38,12 @@ function denial(round) {
 }
 export function review(input, turnResult) {
     const turn = fields(turnResult.result);
+    const harness = turn["harness"];
+    const worker = typeof harness === "string" && harness !== ""
+        ? `the ${harness} worker`
+        : "the worker";
     return [
-        `Review the work of the Claude worker for ${named(input)}.`,
+        `Review the work of ${worker} for ${named(input)}.`,
         `Round: ${String(turnResult.round)} of ${String(lastRound)}`,
         `Branch: ${part(turn, "branch")}`,
         `Work tree: ${part(turn, "worktree")}`,
@@ -95,6 +100,15 @@ export function turnPrompt(input, fix) {
             "Reassess each remaining item before reporting Ticket status: complete. Keep every unfinished item in the next Remaining: list.",
         ].join("\n");
     const ticket = pullPrompt(input) + continuation;
+    if (review["reason"] === "ci-failed")
+        return [
+            ticket,
+            "",
+            `This is round ${String(round)}. The CI checks of the pull request ${pull.url} failed.`,
+            "Fix the failed CI checks, including failures that the pull request did not cause, and commit the fix.",
+            "",
+            part(review, "output"),
+        ].join("\n");
     if (typeof review["reason"] === "string")
         return [
             ticket,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloving",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Local durable development workflow service",
   "license": "MIT",
   "repository": {
@@ -34,15 +34,73 @@
     "./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"
+    },
+    "./workflows/steps/review-by-person": {
+      "types": "./dist/src/steps/review-by-person.d.ts",
+      "import": "./dist/src/steps/review-by-person.js"
+    },
+    "./workflows/steps/review-by-agent": {
+      "types": "./dist/src/steps/review-by-agent.d.ts",
+      "import": "./dist/src/steps/review-by-agent.js"
+    },
+    "./workflows/steps/merge-by-person": {
+      "types": "./dist/src/steps/merge-by-person.d.ts",
+      "import": "./dist/src/steps/merge-by-person.js"
+    },
+    "./workflows/steps/merge-when-green": {
+      "types": "./dist/src/steps/merge-when-green.d.ts",
+      "import": "./dist/src/steps/merge-when-green.js"
+    },
+    "./workflows/steps/wait-for-decision": {
+      "types": "./dist/src/steps/wait-for-decision.d.ts",
+      "import": "./dist/src/steps/wait-for-decision.js"
+    },
+    "./workflows/steps/handoff": {
+      "types": "./dist/src/steps/handoff.d.ts",
+      "import": "./dist/src/steps/handoff.js"
+    },
+    "./workflows/steps/wait-for-run": {
+      "types": "./dist/src/steps/wait-for-run.d.ts",
+      "import": "./dist/src/steps/wait-for-run.js"
+    },
+    "./workflows/steps/run-command": {
+      "types": "./dist/src/steps/run-command.d.ts",
+      "import": "./dist/src/steps/run-command.js"
+    },
+    "./workflows/testing": {
+      "types": "./dist/src/testing.d.ts",
+      "import": "./dist/src/testing.js"
+    },
+    "./workflows/steps/sleep": {
+      "types": "./dist/src/steps/sleep.d.ts",
+      "import": "./dist/src/steps/sleep.js"
     }
   },
   "files": [
     "dist/src",
     "dist/tools",
-    "dist/workflows"
+    "dist/workflows",
+    "templates",
+    "assets/watch-fonts/fira-code-latin-400-normal.woff2",
+    "assets/watch-fonts/fira-code-latin-500-normal.woff2",
+    "assets/watch-fonts/fira-code-OFL.md",
+    "assets/watch-fonts/heebo-latin-500-normal.woff2",
+    "assets/watch-fonts/heebo-latin-700-normal.woff2",
+    "assets/watch-fonts/heebo-latin-800-normal.woff2",
+    "assets/watch-fonts/heebo-OFL.md",
+    "assets/watch-fonts/space-grotesk-latin-400-normal.woff2",
+    "assets/watch-fonts/space-grotesk-latin-500-normal.woff2",
+    "assets/watch-fonts/space-grotesk-latin-600-normal.woff2",
+    "assets/watch-fonts/space-grotesk-latin-700-normal.woff2",
+    "assets/watch-fonts/space-grotesk-OFL.md",
+    "assets/watch-fonts/manifest.json"
   ],
   "engines": {
-    "node": ">=26.9.0 <27",
+    "node": ">=24.22.1 <25 || >=26.9.0 <27",
     "npm": ">=11.19.1 <12"
   },
   "os": [
@@ -56,11 +114,13 @@
   "scripts": {
     "build": "tsc --project tsconfig.build.json && node tools/copy-workflow-declarations.ts workflows dist/workflows",
     "build:workflows": "node tools/compile-workflows.ts",
-    "check:setup": "tsc --project tsconfig.json --noEmit",
+    "check:setup": "node tools/check-shells.ts && tsc --project tsconfig.json --noEmit",
     "check:quality": "node tools/check-quality.ts",
+    "check:clean": "node tools/check-clean.ts",
     "check:lint": "eslint src tools quality test eslint.config.mjs --max-warnings 0",
     "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",
     "check": "node tools/quality-pending.ts",
     "test:concurrency": "node tools/quality-pending.ts"
@@ -76,7 +136,6 @@
     "istanbul-lib-coverage": "3.2.2",
     "jscpd": "5.4.0",
     "prettier": "3.9.9",
-    "typescript": "6.0.3",
     "typescript-eslint": "8.71.1"
   },
   "overrides": {
@@ -89,7 +148,8 @@
     "@workflow/builders": "5.0.2",
     "entities": "8.1.0",
     "preact": "11.0.0",
-    "solid-objects": "0.17.8",
+    "solid-objects": "1.0.2",
+    "typescript": "6.0.3",
     "workflow": "5.1.0"
   }
 }

package/templates/develop/README.md

@@ -0,0 +1,78 @@
+# Develop template decisions
+
+`template.json` describes the five 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
+pass folder admission, including compilation with the Workflow SDK in a packed
+installation. Copy this directory's contents into a workflow folder.
+
+The host supplies `{ cycleId, repository, input: { ticket: { id, text } } }`.
+`develop/report.ts` extracts the resolved text and preserves the worker's ticket
+status. `develop/round.ts` composes development, review and merge. A failed
+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.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
+loader and the installed package, covering every option.
+
+`develop/turn.ts` implements the development turn for either a resolved
+`ticket` or a task `prompt`. It calls the public protected effect helper and
+returns the broker result unchanged. Its `feedback` takes the previous
+result's `reason`, full `output`, and `remaining` items. Rounds 1 through 4
+allow the initial turn and three fix turns; the workflow must stop after that.
+`develop.test.ts` exercises this helper with `cloving/workflows/testing`.
+The package tests also load small compositions of this helper through folder
+admission for both input forms and test both forms in complete workflows.
+
+`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`
+opens a question with an identity scoped to the run and round. It returns
+nonempty feedback from an explicit answer, or stops. It opens no question
+after the initial turn and three fix turns. The separate `develop/queue-partial.ts`
+helper, `queuePartial`, forwards the issue,
+merged pull request and remaining items to the protected `partial-issue`
+operation, preserving its result. The GitHub worker owns partial-run history
+and requeues the first two runs, then blocks the ticket from the third.
+Folder-admission tests cover both helpers in the checkout and packed install.
+The default workflow calls `queuePartial` after merging partial work, closes
+complete issues, and reports a failed issue update in its outcome.
+The person-only composition needs no GitHub capability. `develop/local.ts`
+implements its round: develop, ask about partial work, review the immutable
+commit, and leave the branch for the person to merge. It refuses missing or
+malformed commit IDs and reports of uncommitted work. `develop/accept.ts`
+contains the editable pull-request acceptance call. `promptInput` in
+`develop/report.ts` adapts task text without looking up a ticket.
+Only resolved ticket input supplies an issue identity for lifecycle updates.
+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.
+Selecting `person` at selection, acceptance and partial work, with `local` at
+merge, describes the existing reviewed local-branch process.
+
+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.
+
+`requires` maps another point ID to its allowed option IDs. All named points
+must satisfy their requirement; any listed option for one point satisfies that
+point. For example, `"merge": ["person", "green"]` requires either pull-request
+merge option. An empty object imposes no additional requirement. Select exactly
+one known option at each point and validate the complete selection after edits.
+
+`needs` lists `cloving doctor` codes required by that option. The configured
+workflow also needs the common runtime and harness checks reported by doctor.
+
+Changing metadata does not change runtime behavior. The setup agent must apply
+the source and declaration edits, run the workflow's scenario tests, and load
+the edited configuration through folder admission before using it.

package/templates/develop/develop/accept.ts

@@ -0,0 +1,11 @@
+import type { ReviewSubject, ReviewResult } from "cloving/workflows";
+import { reviewByAgent } from "cloving/workflows/steps/review-by-agent";
+
+export async function acceptWork(
+  subject: ReviewSubject,
+): Promise<ReviewResult> {
+  return await reviewByAgent({
+    subject: subject,
+    reviewer: { kind: "greptile" },
+  });
+}