cloving 1.1.0 → 1.2.0

package/dist/src/daemon/claude-turn.js

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { createWriteStream, mkdtempSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { codexStream } from "./codex-stream.js";
-import { priceOf, usageOf } from "../worker-usage.js";
+import { priceOf, usageOf, } from "../worker-usage.js";
 import { commandModel } from "../token-prices.js";
 import { analysisCommand, analysisEnvironment } from "./analysis-launch.js";
 function parsed(line) {

package/dist/src/daemon/claude-worker.d.ts

@@ -1,11 +1,9 @@
-import { type TokenPrices } from "../token-prices.ts";
 import { type TurnProfiles } from "../turn-profile.ts";
 import type { Delivery } from "../broker/actor/delivery-intents.ts";
 import { type Worker } from "./claude-turn.ts";
 import { type RetrySettings } from "./retrying-turn.ts";
 import { type WorkerReport } from "./operation-journal.ts";
 export interface ClaudeWorkerSettings extends RetrySettings {
-    readonly tokenPrices?: TokenPrices;
     readonly worker?: Worker;
     readonly profiles?: TurnProfiles;
     readonly workflowId?: (runId: string) => Promise<string | undefined>;

package/dist/src/daemon/claude-worker.js

@@ -1,8 +1,8 @@
 import { join } from "node:path";
 import { ticketStatus } from "../ticket-status.js";
+import { sumPrices } from "../worker-usage.js";
 import { analysisWorker } from "./analysis-worker.js";
 import { analysisMethod } from "./analysis-launch.js";
-import { estimatedCostUsd, priceForModel, } from "../token-prices.js";
 import { profileCommand, } from "../turn-profile.js";
 import {} from "./claude-turn.js";
 import { startRetriedTurn } from "./retrying-turn.js";
@@ -41,8 +41,7 @@ async function reconciled(parts, intent) {
     await written(folder, { name: "result.json", value: ending });
     return replied({ receipt: key, worker }, ending);
 }
-async function resultText(tree, turn) {
-    const { result, settings } = turn;
+async function resultText(tree, result) {
     const fields = {
         ticketStatus: ticketStatus(result.text),
         summary: result.text.slice(0, claudeLimits.summaryCharacters),
@@ -51,10 +50,8 @@ async function resultText(tree, turn) {
         costUsd: result.costUsd,
         usage: result.usage,
         model: result.model,
-        estimatedCostUsd: estimatedCostUsd(result.usage, {
-            worker: settings.worker ?? "claude",
-            price: priceForModel(settings.tokenPrices ?? {}, result.model),
-        }),
+        ...(result.attempts === undefined ? {} : { attempts: result.attempts }),
+        estimatedCostUsd: sumPrices((result.attempts ?? []).map((attempt) => attempt.estimatedCostUsd)),
         sessionId: result.sessionId,
         turns: result.turns,
     };
@@ -84,9 +81,7 @@ async function resultText(tree, turn) {
 async function outcome(running, end) {
     const endedAt = new Date().toISOString();
     const { result } = end;
-    const report = result === undefined
-        ? {}
-        : await resultText(running.tree, { result, settings: running.settings });
+    const report = result === undefined ? {} : await resultText(running.tree, result);
     const { text, reason } = report;
     if (reason === undefined &&
         text !== undefined &&
@@ -104,7 +99,7 @@ async function outcome(running, end) {
 }
 async function concluded(parts, running) {
     const { intent, key } = running;
-    const recorded = await outcome({ ...running, settings: parts.settings }, await running.turn.ended);
+    const recorded = await outcome(running, await running.turn.ended);
     await written(running.folder, { name: "result.json", value: recorded });
     await parts.settings.report(reportOf({ intent, commandId: `claude-turn:${key}`, worker }, recorded));
 }

package/dist/src/daemon/daemon.d.ts

@@ -3,8 +3,10 @@ import { type WorkflowHandler } from "../host/world-host.ts";
 import type { TurnProfiles } from "../turn-profile.ts";
 import type { TokenPrices } from "../token-prices.ts";
 import type { DeclaredWorkflow } from "../workflow-declaration.ts";
+import type { WorkflowRefusal } from "../workflow-refusals.ts";
 import type { Worker } from "./claude-turn.ts";
 export interface DaemonSettings {
+    readonly fallbackModels?: readonly string[];
     readonly tokenPrices?: TokenPrices;
     readonly worker?: Worker;
     readonly profiles?: TurnProfiles;
@@ -13,6 +15,7 @@ export interface DaemonSettings {
     readonly repository: string;
     readonly manifests: Readonly<Record<string, string | undefined>>;
     readonly declarations?: readonly DeclaredWorkflow[];
+    readonly workflowRefusals?: readonly WorkflowRefusal[];
     readonly workflows: Readonly<Record<string, WorkflowFunction | undefined>>;
     readonly handler: WorkflowHandler;
     readonly command: readonly string[];
@@ -21,6 +24,7 @@ export interface DaemonSettings {
     readonly notifyCommand?: readonly string[];
     readonly notifyMilliseconds?: number;
     readonly queueMilliseconds?: number;
+    readonly queueLanes?: number;
     readonly resetQueue?: boolean;
     readonly githubCommand?: readonly string[];
     readonly checkCommand?: readonly string[];
@@ -46,4 +50,4 @@ export declare const bridgeTiming: {
     pollMilliseconds: number;
     retryMilliseconds: number;
 };
-export declare function startDaemon(settings: DaemonSettings): Promise<DaemonOpening>;
+export declare function startDaemon(givenSettings: DaemonSettings): Promise<DaemonOpening>;

package/dist/src/daemon/daemon.js

@@ -1,4 +1,4 @@
-import { mkdir } from "node:fs/promises";
+import { mkdir, realpath } from "node:fs/promises";
 import { join } from "node:path";
 import { startDelivery, } from "../host/start-delivery.js";
 import { registerStepBridge, sdkStepCall, stepBridge, } from "../host/step-bridge-host.js";
@@ -6,8 +6,10 @@ import { startHost } from "../host/world-host.js";
 import { worldLoop } from "../host/world-reconciliation.js";
 import { cancelled, workflowOutcome, taggedRun, taggedRuns, } from "../host/world-runs.js";
 import { startService, } from "../service/service.js";
+import { workflowPin } from "../broker/workflow-pin.js";
 import { claudeWorker } from "./claude-worker.js";
 import { deliveryRouter } from "./delivery-router.js";
+import { handoffWorker } from "./handoff-worker.js";
 import { githubWorker } from "./github-worker.js";
 import { chatsWorker } from "./chats-worker.js";
 import { worldDirectory } from "./host-environment.js";
@@ -72,11 +74,16 @@ function githubOf(settings, given) {
 }
 function adapters(settings, options) {
     const { directory, repository, command } = settings;
-    const { given, table } = options;
-    const workflows = Object.fromEntries(table.map((row) => [row.workflowId, settings.workflows[row.functionName]]));
+    const { given, table, registrations } = options;
+    const functions = Object.fromEntries(table.map((row) => [row.workflowId, settings.workflows[row.functionName]]));
+    const workflows = Object.fromEntries(registrations.map((registration) => [
+        workflowPin(registration.manifest),
+        functions[registration.workflowId],
+    ]));
     const document = async (digest) => (await given).document(digest);
     const report = async (effect) => (await given).reportEffect(effect);
     const worker = claudeWorker({
+        fallbackModels: settings.fallbackModels ?? [],
         tokenPrices: settings.tokenPrices ?? {},
         worker: settings.worker ?? "claude",
         profiles: settings.profiles ?? {},
@@ -99,18 +106,36 @@ function adapters(settings, options) {
         runs: taggedRuns,
         cancel: cancelled,
         input: async (runId) => (await given).input(runId),
-        workflow: async (runId) => workflows[String(await (await given).workflowId(runId))],
+        workflow: ({ workflow }) => Promise.resolve(workflows[workflow]),
     });
-    return { worker, github, runs, chats };
+    const handoff = handoffOf(settings, given);
+    return { worker, github, runs, chats, handoff };
 }
-export async function startDaemon(settings) {
-    const { directory } = settings;
+function handoffOf(settings, given) {
+    return handoffWorker({
+        runtimeDirectory: settings.runtimeDirectory,
+        journal: join(settings.directory, "handoffs"),
+        document: async (digest) => (await given).document(digest),
+        runStatus: async (runId) => (await (await given).state()).runs[runId]?.status,
+    });
+}
+async function daemonRegistrations(settings) {
     const table = ticketRegistrationTable({
         repository: settings.repository,
         command: settings.ticketCommand,
         nextCommand: settings.nextCommand,
+        githubCommand: settings.githubCommand,
     }, settings.declarations);
     const admitted = await ticketRegistrations(settings.manifests, { table });
+    return { table, admitted };
+}
+export async function startDaemon(givenSettings) {
+    const settings = {
+        ...givenSettings,
+        repository: await realpath(givenSettings.repository),
+    };
+    const { directory } = settings;
+    const { table, admitted } = await daemonRegistrations(settings);
     if (admitted.kind === "rejected")
         return {
             kind: "refused",
@@ -118,25 +143,27 @@ export async function startDaemon(settings) {
             detail: admitted.detail,
         };
     const given = Promise.withResolvers();
-    const { worker, github, runs, chats } = adapters(settings, {
+    const { worker, github, runs, chats, handoff } = adapters(settings, {
         given: given.promise,
         table,
+        registrations: admitted.registrations,
     });
     await mkdir(join(directory, "state"), { recursive: true });
     await mkdir(settings.runtimeDirectory, { recursive: true, mode: 0o700 });
     const opening = await startService({
         stateDirectory: join(directory, "state"),
         runtimeDirectory: settings.runtimeDirectory,
+        workflowRefusals: settings.workflowRefusals ?? [],
         workflows: admitted.registrations.map((registration) => ({
             ...registration,
             ...(settings.queueMilliseconds !== undefined &&
                 registration.workflowId === "develop-issue"
-                ? { admission: "when-idle" }
+                ? { admission: settings.queueLanes ?? 1 }
                 : {}),
         })),
         delivery: deliveryRouter({
             runs,
-            effects: { claude: worker, github, chats },
+            effects: { claude: worker, github, chats, handoff },
         }),
         effects: { leaseMilliseconds: turnLeaseMilliseconds },
         host: (ports) => {
@@ -181,6 +208,7 @@ async function runningDaemon(settings, resources) {
             directory: settings.directory,
             runtimeDirectory: settings.runtimeDirectory,
             intervalMilliseconds: settings.queueMilliseconds,
+            lanes: settings.queueLanes ?? 1,
             resetQueue: settings.resetQueue ?? false,
         });
     return {

package/dist/src/daemon/delivery-router.js

@@ -25,6 +25,12 @@ export function deliveryRouter(routes) {
                 return runs.reconcile(intent);
             return workerOf(routes, intent)?.reconcile(intent, signal) ?? refusal();
         },
+        retry: (intent, signal) => {
+            if (!protectedEffect(intent))
+                return refusal();
+            return (workerOf(routes, intent)?.retry?.(intent, signal) ??
+                Promise.resolve({ kind: "unknown" }));
+        },
         stop: (intent, signal) => {
             if (!protectedEffect(intent))
                 return runs.stop(intent);

package/dist/src/daemon/github-calls.d.ts

@@ -24,6 +24,10 @@ export interface Finding {
     readonly line: number | null;
     readonly body: string;
 }
+export declare function githubText(text: string, settings: {
+    readonly environment?: NodeJS.ProcessEnv;
+    readonly privateTexts?: readonly string[];
+}): string;
 export declare function calls(settings: CallSettings, signal: AbortSignal): Calls;
 export declare function scoreOf(comments: unknown, commit: string): Scored | undefined;
 export declare function findingsOf(comments: unknown, commit: string): readonly Finding[];

package/dist/src/daemon/github-calls.js

@@ -22,17 +22,26 @@ function privateEnvironment(environment) {
 function failureDetail(error, place) {
     const stderr = field(error, "stderr");
     const text = typeof stderr === "string" ? stderr : "";
-    const secrets = Object.entries(place.environment)
+    return {
+        detail: githubText(text, place).slice(-2_000),
+        status: Number(/\(HTTP (\d{3})\)/.exec(text)?.[1]),
+    };
+}
+export function githubText(text, settings) {
+    const environment = { ...process.env, ...settings.environment };
+    const secrets = Object.entries(environment)
         .filter(([name]) => /TOKEN|SECRET|PASSWORD|KEY/i.test(name))
         .map(([, value]) => value);
-    const hidden = [...secrets, ...place.privateTexts]
+    const privateTexts = [
+        ...(settings.privateTexts ?? []),
+        ...privateEnvironment(environment),
+    ];
+    const hidden = [...secrets, ...privateTexts]
         .filter((value) => typeof value === "string" && value !== "")
         .sort((left, right) => right.length - left.length);
-    const detail = hidden.reduce((redacted, value) => redacted.replaceAll(value, "[hidden]"), text);
-    return {
-        detail: detail.slice(-2_000),
-        status: Number(/\(HTTP (\d{3})\)/.exec(text)?.[1]),
-    };
+    return hidden.reduce((redacted, value) => redacted.replaceAll(privateTexts.includes(value)
+        ? new RegExp(value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi")
+        : value, "[hidden]"), text);
 }
 async function output(command, place) {
     try {

package/dist/src/daemon/github-ci.d.ts

@@ -0,0 +1,6 @@
+import { type Operation } from "./github-operation.ts";
+export interface CiResult {
+    readonly reason: "ci-failed" | "ci-pending";
+    readonly output: string;
+}
+export declare function waitForCi(operation: Operation, commit: string): Promise<CiResult | undefined>;

package/dist/src/daemon/github-ci.js

@@ -0,0 +1,170 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { githubText } from "./github-calls.js";
+import { githubRead } from "./github-retry.js";
+import { field, githubTiming, repositoryPath, } from "./github-operation.js";
+function isCheckRun(value) {
+    const conclusion = field(value, "conclusion");
+    const details = field(value, "details_url");
+    const app = field(value, "app");
+    return (typeof field(value, "id") === "number" &&
+        typeof field(value, "name") === "string" &&
+        typeof field(value, "status") === "string" &&
+        (conclusion === null || typeof conclusion === "string") &&
+        (details === null || typeof details === "string") &&
+        (app === null || typeof field(app, "slug") === "string"));
+}
+const passing = new Set(["success", "neutral", "skipped"]);
+function latestRuns(checks, required) {
+    const latest = new Map();
+    for (const check of checks) {
+        const name = check.name;
+        if (required === undefined
+            ? check.app?.slug !== "github-actions"
+            : !required.has(name))
+            continue;
+        const previous = latest.get(name);
+        if (previous === undefined || check.id > previous.id)
+            latest.set(name, check);
+    }
+    return [...latest.values()];
+}
+function list(value) {
+    return Array.isArray(value) ? value.map((item) => item) : [];
+}
+async function checkRuns(operation, commit) {
+    const pages = JSON.parse(await githubRead(operation, [
+        "api",
+        "--paginate",
+        "--slurp",
+        `${repositoryPath}/commits/${commit}/check-runs?filter=all&per_page=100`,
+    ]));
+    if (!Array.isArray(pages) || pages.length === 0)
+        throw new Error("github-call-failed");
+    return list(pages).flatMap((page) => {
+        const checks = field(page, "check_runs");
+        if (!Array.isArray(checks) || !checks.every(isCheckRun))
+            throw new Error("github-call-failed");
+        return checks;
+    });
+}
+function unavailable(operation, error) {
+    operation.signal.throwIfAborted();
+    const detail = field(error, "detail");
+    return `CI diagnostics unavailable: ${githubText(typeof detail === "string" ? detail : "GitHub logs could not be read", operation.settings)}`;
+}
+async function failedSteps(operation, place) {
+    try {
+        const view = JSON.parse(await operation.calls.gh(["run", "view", place.run, "--json", "jobs"]));
+        return list(field(view, "jobs"))
+            .filter((job) => String(field(job, "databaseId")) === place.job)
+            .flatMap((job) => list(field(job, "steps")))
+            .filter((step) => typeof field(step, "conclusion") === "string" &&
+            !passing.has(String(field(step, "conclusion"))))
+            .map((step) => `Failed step: ${String(field(step, "name"))}`)
+            .join("\n");
+    }
+    catch (error) {
+        return unavailable(operation, error);
+    }
+}
+async function failedCheck(operation, check) {
+    const summary = [
+        `Failed check: ${check.name} (${check.conclusion ?? "null"})`,
+    ];
+    const details = check.details_url ?? "";
+    const run = /\/actions\/runs\/(\d+)/.exec(details)?.[1];
+    let log = "Failed log unavailable.";
+    if (run !== undefined) {
+        const job = /\/job\/(\d+)/.exec(details)?.[1];
+        summary.push(await failedSteps(operation, { run, job }));
+        log = await failedLog(operation, { run, job });
+    }
+    return {
+        summary: githubText(summary.join("\n"), operation.settings),
+        log: githubText(log, operation.settings),
+    };
+}
+async function failedLog(operation, place) {
+    try {
+        return await operation.calls.gh([
+            "run",
+            "view",
+            place.run,
+            "--log-failed",
+            ...(place.job === undefined ? [] : ["--job", place.job]),
+        ]);
+    }
+    catch (error) {
+        operation.signal.throwIfAborted();
+        if (place.job === undefined)
+            return unavailable(operation, error);
+        return operation.calls
+            .gh(["api", `${repositoryPath}/actions/jobs/${place.job}/logs`])
+            .catch((failure) => unavailable(operation, failure));
+    }
+}
+async function failedOutput(operation, checks) {
+    const reports = [];
+    for (const check of checks)
+        reports.push(await failedCheck(operation, check));
+    const summary = reports.map((report) => report.summary).join("\n");
+    const available = Math.max(0, 6_000 - summary.length - reports.length);
+    const allowance = Math.floor(available / reports.length);
+    return [
+        summary,
+        ...reports.map((report) => allowance === 0 ? "" : report.log.slice(-allowance)),
+    ]
+        .join("\n")
+        .slice(0, 6_000);
+}
+function requiredChecks(operation) {
+    const setting = operation.settings.environment?.["CLOVING_REQUIRED_CHECKS"] ??
+        process.env["CLOVING_REQUIRED_CHECKS"];
+    if (setting === undefined)
+        return undefined;
+    const names = JSON.parse(setting);
+    if (!Array.isArray(names) ||
+        !names.every((name) => typeof name === "string" && name.trim() !== ""))
+        throw new Error("invalid-payload");
+    return new Set(names);
+}
+function pendingChecks(checks, names) {
+    return [...names].filter((name) => !checks.some((check) => check.name === name && check.status === "completed"));
+}
+export async function waitForCi(operation, commit) {
+    const { pollMilliseconds: poll, ciGraceMilliseconds: grace, ciLimitMilliseconds: limit, } = {
+        ...githubTiming,
+        ciGraceMilliseconds: 60_000,
+        ciLimitMilliseconds: 5_400_000,
+        ...operation.settings.timing,
+    };
+    const started = Date.now();
+    const required = requiredChecks(operation);
+    const names = new Set(required);
+    for (;;) {
+        const checks = latestRuns(await checkRuns(operation, commit), required);
+        for (const check of checks)
+            names.add(check.name);
+        const failed = checks.filter((check) => check.status === "completed" && !passing.has(check.conclusion ?? ""));
+        if (failed.length > 0)
+            return {
+                reason: "ci-failed",
+                output: await failedOutput(operation, failed),
+            };
+        const pending = pendingChecks(checks, names);
+        if (pending.length === 0 &&
+            (required !== undefined ||
+                names.size > 0 ||
+                Date.now() - started >= grace))
+            return undefined;
+        const remaining = limit - (Date.now() - started);
+        if (remaining <= 0)
+            return {
+                reason: "ci-pending",
+                output: `CI wait limit reached for ${commit}. Pending checks: ${pending.join(", ") || "waiting for GitHub Actions checks"}`,
+            };
+        await delay(Math.min(poll, remaining), undefined, {
+            signal: operation.signal,
+        });
+    }
+}

package/dist/src/daemon/github-merge-call.d.ts

@@ -0,0 +1,14 @@
+import { type Operation } from "./github-operation.ts";
+export interface ReviewedPull {
+    readonly number: number;
+    readonly commit: string;
+}
+export declare function knownMerge(operation: Operation, expected: ReviewedPull & {
+    readonly updated: string;
+}): Promise<{
+    readonly head: string;
+    readonly merged: string | undefined;
+}>;
+export declare function mergePull(operation: Operation, pull: ReviewedPull & {
+    readonly updated: string;
+}): Promise<string>;

package/dist/src/daemon/github-merge-call.js

@@ -0,0 +1,73 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { field, githubTiming, repositoryPath, } from "./github-operation.js";
+import { githubRead, retryGithub } from "./github-retry.js";
+function commitOf(value, name) {
+    if (typeof value !== "object" || value === null)
+        throw new Error("github-call-failed");
+    const commit = Reflect.get(value, name);
+    if (typeof commit !== "string")
+        throw new Error("github-call-failed");
+    return commit;
+}
+export async function knownMerge(operation, expected) {
+    const pull = JSON.parse(await githubRead(operation, [
+        "api",
+        `${repositoryPath}/pulls/${String(expected.number)}`,
+    ]));
+    const head = commitOf(field(pull, "head"), "sha");
+    if (field(pull, "merged") !== true)
+        return { head, merged: undefined };
+    if (head !== expected.commit && head !== expected.updated)
+        throw new Error("merged-other-commit");
+    return { head, merged: commitOf(pull, "merge_commit_sha") };
+}
+async function mergedNow(operation, pull) {
+    const reply = JSON.parse(await operation.calls.gh([
+        "api",
+        "-X",
+        "PUT",
+        `${repositoryPath}/pulls/${String(pull.number)}/merge`,
+        "-f",
+        "merge_method=merge",
+        "-f",
+        `sha=${pull.commit}`,
+    ]));
+    return commitOf(reply, "sha");
+}
+async function waitForHead(operation, pull) {
+    const timing = operation.settings.timing ?? githubTiming;
+    for (let attempt = 0; attempt < 30; attempt += 1) {
+        if (attempt > 0)
+            await delay(timing.pollMilliseconds, undefined, {
+                signal: operation.signal,
+            });
+        const current = JSON.parse(await githubRead(operation, [
+            "api",
+            `${repositoryPath}/pulls/${String(pull.number)}`,
+        ]));
+        if (commitOf(field(current, "head"), "sha") === pull.commit)
+            return;
+    }
+    throw new Error("head-not-updated");
+}
+export function mergePull(operation, pull) {
+    return retryGithub(operation, {
+        action: async (attempt) => {
+            const known = attempt > 0 ? await knownMerge(operation, pull) : undefined;
+            if (known?.merged !== undefined)
+                return known.merged;
+            const updated = { number: pull.number, commit: pull.updated };
+            if (pull.updated !== pull.commit)
+                await waitForHead(operation, updated);
+            return mergedNow(operation, updated);
+        },
+        statuses: pull.updated === pull.commit ? [] : [405, 409],
+    }).catch(async (error) => {
+        if (!(error instanceof Error) || error.message !== "github-network-failed")
+            throw error;
+        const known = await knownMerge(operation, pull);
+        if (known.merged !== undefined)
+            return known.merged;
+        throw error;
+    });
+}

package/dist/src/daemon/github-merge.d.ts

@@ -1,8 +1,6 @@
 import { type Operation } from "./github-operation.ts";
-interface ReviewedPull {
-    readonly number: number;
-    readonly commit: string;
-}
+import { type CiResult } from "./github-ci.ts";
+import { type ReviewedPull } from "./github-merge-call.ts";
 interface SuccessfulMerge {
     readonly number: number;
     readonly commit: string;
@@ -13,6 +11,6 @@ interface MergeRepair {
     readonly reason: "check-failed" | "merge-conflict";
     readonly output: string;
 }
-export type MergeResult = SuccessfulMerge | MergeRepair;
+export type MergeResult = SuccessfulMerge | MergeRepair | CiResult;
 export declare function merge(operation: Operation, pull: ReviewedPull): Promise<MergeResult>;
 export {};