cloving 1.1.0 → 1.3.0

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

@@ -0,0 +1,14 @@
+import { workflowSchedules } from "./workflow-schedules.ts";
+interface LoopSettings extends ParametersOfSchedules {
+    readonly notifyCommand?: readonly string[];
+    readonly notifyMilliseconds?: number;
+    readonly queueMilliseconds?: number;
+    readonly queueLanes?: number;
+    readonly resetQueue?: boolean;
+    readonly queueWorkflowId: string;
+}
+type ParametersOfSchedules = Parameters<typeof workflowSchedules>[0];
+export declare function daemonLoops(settings: LoopSettings): Promise<{
+    readonly stop: () => Promise<void>;
+}>;
+export {};

package/dist/src/daemon/daemon-loops.js

@@ -0,0 +1,39 @@
+import { workflowSchedules } from "./workflow-schedules.js";
+import { issueQueue } from "./issue-queue.js";
+import { notifyRuns } from "./notify.js";
+export async function daemonLoops(settings) {
+    const schedules = await workflowSchedules(settings);
+    try {
+        const notifier = settings.notifyCommand === undefined
+            ? undefined
+            : await notifyRuns({
+                directory: settings.directory,
+                runtimeDirectory: settings.runtimeDirectory,
+                command: settings.notifyCommand,
+                ...(settings.notifyMilliseconds === undefined
+                    ? {}
+                    : { intervalMilliseconds: settings.notifyMilliseconds }),
+            });
+        const queue = settings.queueMilliseconds === undefined
+            ? undefined
+            : issueQueue({
+                directory: settings.directory,
+                runtimeDirectory: settings.runtimeDirectory,
+                intervalMilliseconds: settings.queueMilliseconds,
+                lanes: settings.queueLanes ?? 1,
+                resetQueue: settings.resetQueue ?? false,
+                workflowId: settings.queueWorkflowId,
+            });
+        return {
+            stop: async () => {
+                await schedules.stop();
+                await notifier?.stop();
+                await queue?.stop();
+            },
+        };
+    }
+    catch (error) {
+        await schedules.stop();
+        throw error;
+    }
+}

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

@@ -1,32 +1,5 @@
-import { type WorkflowFunction } from "../host/start-delivery.ts";
-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 { Worker } from "./claude-turn.ts";
-export interface DaemonSettings {
-    readonly tokenPrices?: TokenPrices;
-    readonly worker?: Worker;
-    readonly profiles?: TurnProfiles;
-    readonly directory: string;
-    readonly runtimeDirectory: string;
-    readonly repository: string;
-    readonly manifests: Readonly<Record<string, string | undefined>>;
-    readonly declarations?: readonly DeclaredWorkflow[];
-    readonly workflows: Readonly<Record<string, WorkflowFunction | undefined>>;
-    readonly handler: WorkflowHandler;
-    readonly command: readonly string[];
-    readonly ticketCommand?: readonly string[];
-    readonly nextCommand?: readonly string[];
-    readonly notifyCommand?: readonly string[];
-    readonly notifyMilliseconds?: number;
-    readonly queueMilliseconds?: number;
-    readonly resetQueue?: boolean;
-    readonly githubCommand?: readonly string[];
-    readonly checkCommand?: readonly string[];
-    readonly privateTexts?: readonly string[];
-    readonly concurrency: number;
-}
+import { type DaemonSettings } from "./daemon-adapters.ts";
+export type { DaemonSettings } from "./daemon-adapters.ts";
 export interface Daemon {
     readonly socket: string;
     readonly close: () => Promise<void>;
@@ -46,4 +19,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,19 +1,19 @@
-import { mkdir } from "node:fs/promises";
+import { adapters, recoverCommands, } from "./daemon-adapters.js";
+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";
 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 { claudeWorker } from "./claude-worker.js";
+import { workflowOutcome, taggedRun, taggedRuns } from "../host/world-runs.js";
+import { startService, serviceLimits, } from "../service/service.js";
+import { workflowGenerations, prepareWorkflowGenerations, } from "./workflow-generations.js";
 import { deliveryRouter } from "./delivery-router.js";
-import { githubWorker } from "./github-worker.js";
-import { chatsWorker } from "./chats-worker.js";
+import { commandEffects } from "./command-journal.js";
 import { worldDirectory } from "./host-environment.js";
-import { issueQueue } from "./issue-queue.js";
-import { notifyRuns } from "./notify.js";
-import { ticketRegistrations, ticketRegistrationTable, } from "./ticket-registration.js";
+import { pinnedWorkflowHandler } from "./workflow-replay.js";
+import { scheduledDeclarations } from "./workflow-schedules.js";
+import { daemonLoops } from "./daemon-loops.js";
+import { ticketRegistrations, ticketRegistrationTable, issueWorkflow, } from "./ticket-registration.js";
 export const turnLeaseMilliseconds = 4 * 3_600_000;
 export const loopMilliseconds = 250;
 export const bridgeTiming = {
@@ -21,11 +21,23 @@ export const bridgeTiming = {
     pollMilliseconds: 250,
     retryMilliseconds: 1_000,
 };
-async function hosted(settings, ports) {
+async function hosted(settings, hosting) {
+    const { ports, generations } = hosting;
+    await prepareWorkflowGenerations(ports, generations);
     const opening = await startHost({
         dataDirectory: worldDirectory(settings.directory),
         concurrency: settings.concurrency,
-        handler: settings.handler,
+        handler: pinnedWorkflowHandler(async (request, runId) => {
+            const generation = await generations.resolve(await ports.workflow.manifest(runId));
+            return generation === undefined
+                ? new Response("pinned-workflow-unavailable", { status: 503 })
+                : generation.handler(request);
+        }, {
+            state: ports.state,
+            run: taggedRun,
+            available: ports.workflow.available,
+            submit: ports.submit,
+        }),
     });
     if (opening.kind === "refused")
         throw new Error(`${opening.reason}: ${opening.detail}`);
@@ -53,143 +65,153 @@ async function hosted(settings, ports) {
         },
     };
 }
-function githubOf(settings, given) {
-    const { directory, repository, checkCommand } = settings;
-    return githubWorker({
-        document: async (digest) => (await given).document(digest),
-        report: async (effect) => (await given).reportEffect(effect),
-        operationStatus: async (operationId) => (await (await given).operation(operationId))?.status,
-        runStatus: async (runId) => (await (await given).state()).runs[runId]?.status,
-        repository,
-        gh: settings.githubCommand ?? ["gh"],
-        worktrees: join(directory, "worktrees"),
-        journal: join(directory, "github"),
-        ...(settings.privateTexts === undefined
+async function daemonRegistrations(settings) {
+    const conflict = settings.workflowRefusals?.find((refusal) => refusal.codes.includes("queue-workflow-conflict"));
+    if (conflict !== undefined)
+        return {
+            table: [],
+            admitted: {
+                kind: "rejected",
+                detail: `queue-workflow-conflict: ${conflict.scope} ${conflict.label}`,
+            },
+        };
+    const table = ticketRegistrationTable({
+        repository: settings.repository,
+        command: settings.ticketCommand,
+        nextCommand: settings.nextCommand,
+        githubCommand: settings.githubCommand,
+    }, settings.declarations);
+    const admitted = await ticketRegistrations(settings.manifests, {
+        table,
+        commands: settings.commands ?? {},
+        ...(settings.bundleDigest === undefined
             ? {}
-            : { privateTexts: settings.privateTexts }),
-        ...(checkCommand === undefined ? {} : { check: checkCommand }),
+            : { bundleDigest: settings.bundleDigest }),
     });
+    return {
+        table,
+        admitted: admitted.kind === "rejected"
+            ? admitted
+            : {
+                ...admitted,
+                registrations: admitted.registrations.map((registration) => ({
+                    ...registration,
+                    ...(settings.queueMilliseconds !== undefined &&
+                        registration.workflowId === queueWorkflowId(settings)
+                        ? { admission: settings.queueLanes ?? 1, queue: true }
+                        : {}),
+                })),
+            },
+    };
 }
-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 document = async (digest) => (await given).document(digest);
-    const report = async (effect) => (await given).reportEffect(effect);
-    const worker = claudeWorker({
-        tokenPrices: settings.tokenPrices ?? {},
-        worker: settings.worker ?? "claude",
-        profiles: settings.profiles ?? {},
-        workflowId: async (runId) => (await given).workflowId(runId),
+export async function startDaemon(givenSettings) {
+    const repository = await realpath(givenSettings.repository);
+    const scheduled = scheduledDeclarations(givenSettings, {
         repository,
-        command,
-        document,
-        report,
-        worktrees: join(directory, "worktrees"),
-        journal: join(directory, "journal"),
-    });
-    const github = githubOf(settings, given);
-    const chats = chatsWorker({
-        runtimeDirectory: settings.runtimeDirectory,
-        document,
-        workflowId: async (runId) => (await given).workflowId(runId),
+        documentBytes: serviceLimits.documentBytes,
     });
-    const runs = startDelivery({
-        document,
-        runs: taggedRuns,
-        cancel: cancelled,
-        input: async (runId) => (await given).input(runId),
-        workflow: async (runId) => workflows[String(await (await given).workflowId(runId))],
+    if (scheduled.kind === "refused")
+        return scheduled;
+    return openDaemon({
+        ...givenSettings,
+        declarations: scheduled.declarations,
+        repository,
     });
-    return { worker, github, runs, chats };
 }
-export async function startDaemon(settings) {
-    const { directory } = settings;
-    const table = ticketRegistrationTable({
-        repository: settings.repository,
-        command: settings.ticketCommand,
-        nextCommand: settings.nextCommand,
-    }, settings.declarations);
-    const admitted = await ticketRegistrations(settings.manifests, { table });
+async function openDaemon(settings) {
+    const { table, admitted } = await daemonRegistrations(settings);
     if (admitted.kind === "rejected")
         return {
             kind: "refused",
-            reason: "workflow-rejected",
+            reason: admitted.detail.startsWith("queue-workflow-conflict")
+                ? "queue-workflow-conflict"
+                : "workflow-rejected",
             detail: admitted.detail,
         };
     const given = Promise.withResolvers();
-    const { worker, github, runs, chats } = adapters(settings, {
-        given: given.promise,
+    const generations = workflowGenerations({
+        ...settings,
+        registrations: admitted.registrations,
         table,
     });
-    await mkdir(join(directory, "state"), { recursive: true });
+    const resources = adapters(settings, { given: given.promise, generations });
+    const { worker, github, runs, handoff, commands } = resources;
+    await mkdir(join(settings.directory, "state"), { recursive: true });
     await mkdir(settings.runtimeDirectory, { recursive: true, mode: 0o700 });
     const opening = await startService({
-        stateDirectory: join(directory, "state"),
+        workerHarness: worker.harness,
+        commandEffects: commandEffects(join(settings.directory, "commands")),
+        stateDirectory: join(settings.directory, "state"),
         runtimeDirectory: settings.runtimeDirectory,
-        workflows: admitted.registrations.map((registration) => ({
-            ...registration,
-            ...(settings.queueMilliseconds !== undefined &&
-                registration.workflowId === "develop-issue"
-                ? { admission: "when-idle" }
-                : {}),
-        })),
+        workflowBundles: {
+            directory: join(settings.directory, "workflow-bundles"),
+            repository: settings.repository,
+        },
+        workflowRefusals: settings.workflowRefusals ?? [],
+        workflows: admitted.registrations,
+        retainedWorkflow: generations.available,
         delivery: deliveryRouter({
             runs,
-            effects: { claude: worker, github, chats },
+            effects: { claude: worker, github, handoff, command: commands },
         }),
         effects: { leaseMilliseconds: turnLeaseMilliseconds },
         host: (ports) => {
             given.resolve(ports);
-            return hosted(settings, ports);
+            return hosted(settings, { ports, generations });
         },
     });
     if (opening.kind === "refused") {
-        await Promise.all([worker.close(), github.close(), chats.close()]);
+        await closeWorkers(resources);
         return opening;
     }
+    const running = { ...resources, service: opening.service };
+    await recoverWorkers(running, given.promise);
     return {
         kind: "started",
-        daemon: await runningDaemon(settings, {
-            service: opening.service,
-            worker,
-            github,
-            chats,
-        }),
+        daemon: await runningDaemon(settings, running),
     };
 }
+async function recoverWorkers(resources, ports) {
+    try {
+        await recoverCommands(resources.commands, await ports);
+    }
+    catch (error) {
+        await Promise.allSettled([
+            closeWorkers(resources),
+            resources.service.close(),
+        ]);
+        throw error;
+    }
+}
+async function closeWorkers(resources) {
+    await Promise.all([
+        resources.worker.close(),
+        resources.github.close(),
+        resources.commands.close(),
+    ]);
+}
 async function runningDaemon(settings, resources) {
-    const { service, worker, github, chats } = resources;
+    const { service, github } = resources;
     await github.scan();
-    const notifier = settings.notifyCommand === undefined
-        ? undefined
-        : await notifyRuns({
-            directory: settings.directory,
-            runtimeDirectory: settings.runtimeDirectory,
-            command: settings.notifyCommand,
-            ...(settings.notifyMilliseconds === undefined
-                ? {}
-                : { intervalMilliseconds: settings.notifyMilliseconds }),
-        }).catch(async (error) => {
-            await Promise.all([worker.close(), github.close(), chats.close()]);
-            await service.close();
-            throw error;
-        });
-    const queue = settings.queueMilliseconds === undefined
-        ? undefined
-        : issueQueue({
-            directory: settings.directory,
-            runtimeDirectory: settings.runtimeDirectory,
-            intervalMilliseconds: settings.queueMilliseconds,
-            resetQueue: settings.resetQueue ?? false,
-        });
+    const loops = await daemonLoops({
+        ...settings,
+        submit: service.worker.submit,
+        queueWorkflowId: queueWorkflowId(settings),
+    }).catch(async (error) => {
+        await closeWorkers(resources);
+        await service.close();
+        throw error;
+    });
     return {
         socket: service.socket,
         close: async () => {
-            await notifier?.stop();
-            await queue?.stop();
-            await Promise.all([worker.close(), github.close(), chats.close()]);
+            await loops.stop();
+            await closeWorkers(resources);
             await service.close();
         },
     };
 }
+function queueWorkflowId(settings) {
+    return (settings.declarations?.find((declaration) => declaration.queue === true)
+        ?.workflowId ?? issueWorkflow);
+}

package/dist/src/daemon/declared-input.d.ts

@@ -0,0 +1,3 @@
+import type { Fields } from "../protocol.ts";
+import type { ResolutionRequest } from "../service/registry.ts";
+export declare function declaredInput(repository: string, request: Pick<ResolutionRequest, "commandId" | "submission">): Fields;

package/dist/src/daemon/declared-input.js

@@ -0,0 +1,9 @@
+import { createHash } from "node:crypto";
+export function declaredInput(repository, request) {
+    const digest = createHash("sha256").update(request.commandId).digest("hex");
+    return {
+        cycleId: `task-${digest.slice(0, 12)}`,
+        repository,
+        input: request.submission,
+    };
+}

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

@@ -17,7 +17,7 @@ export function deliveryRouter(routes) {
     return {
         deliver: (intent, signal) => {
             if (!protectedEffect(intent))
-                return runs.deliver(intent);
+                return runs.deliver(intent, signal);
             return workerOf(routes, intent)?.deliver(intent, signal) ?? refusal();
         },
         reconcile: (intent, signal) => {
@@ -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/gemini-stream.d.ts

@@ -0,0 +1,4 @@
+export declare function geminiStream(): {
+    readonly line: (line: string) => readonly string[];
+    readonly result: (exitCode: number | null) => string;
+};

package/dist/src/daemon/gemini-stream.js

@@ -0,0 +1,129 @@
+import { record } from "../protocol.js";
+import { sumUsage, usageOf, } from "../worker-usage.js";
+function parsed(line) {
+    try {
+        return record(JSON.parse(line)) ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+function text(value) {
+    return typeof value === "string" ? value : "";
+}
+function usage(value) {
+    const fields = record(value) ?? {};
+    return usageOf({
+        input_tokens: fields["input_tokens"],
+        output_tokens: fields["output_tokens"],
+        cache_read_input_tokens: fields["cached"],
+    });
+}
+function statistics(event, state) {
+    const stats = record(event["stats"]);
+    const models = record(stats?.["models"]);
+    state.models =
+        models === undefined
+            ? undefined
+            : Object.entries(models).map(([model, counts]) => ({
+                model,
+                usage: usage(counts),
+            }));
+    state.usage =
+        state.models === undefined
+            ? usage(stats)
+            : sumUsage(state.models.map((entry) => entry.usage));
+}
+function completed(event, state) {
+    statistics(event, state);
+    state.success = event["status"] === "success";
+    if (!state.success)
+        state.failure =
+            text(record(event["error"])?.["message"]) ||
+                "Gemini result was not successful";
+}
+function message(event, state) {
+    if (event["role"] === "user")
+        state.continuing = false;
+    if (event["role"] !== "assistant")
+        return [];
+    const content = text(event["content"]);
+    state.message =
+        state.continuing && event["delta"] === true
+            ? state.message + content
+            : content;
+    state.continuing = true;
+    return [
+        JSON.stringify({
+            type: "assistant",
+            message: { content: [{ type: "text", text: content }] },
+        }),
+    ];
+}
+function toolUse(event) {
+    return [
+        JSON.stringify({
+            type: "assistant",
+            message: {
+                content: [
+                    {
+                        type: "tool_use",
+                        name: text(event["tool_name"]),
+                        input: record(event["parameters"]) ?? {},
+                    },
+                ],
+            },
+        }),
+    ];
+}
+function received(event, state) {
+    if (event["severity"] === "error")
+        state.failure = text(event["message"]) || "Gemini error";
+    switch (event["type"]) {
+        case "init":
+            state.model = text(event["model"]) || null;
+            state.sessionId = text(event["session_id"]) || null;
+            break;
+        case "result":
+            completed(event, state);
+            break;
+        case "message":
+            return message(event, state);
+        case "tool_use":
+            state.continuing = false;
+            return toolUse(event);
+        case "tool_result":
+            state.continuing = false;
+    }
+    return [];
+}
+export function geminiStream() {
+    const state = {
+        model: null,
+        sessionId: null,
+        message: "",
+        continuing: false,
+        success: false,
+        failure: null,
+        models: undefined,
+        usage: usageOf(null),
+    };
+    return {
+        line: (line) => received(parsed(line), state),
+        result: (exitCode) => {
+            const success = exitCode === 0 && state.success && state.failure === null;
+            return JSON.stringify({
+                type: "result",
+                is_error: !success,
+                result: success
+                    ? state.message
+                    : (state.failure ??
+                        `gemini ended with code ${String(exitCode)} without a successful result`),
+                model: state.model,
+                session_id: state.sessionId,
+                usage: state.usage,
+                models: state.models,
+            });
+        },
+    };
+}

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-rerun.d.ts

@@ -0,0 +1,26 @@
+import { type Operation } from "./github-operation.ts";
+export interface CiRerun {
+    readonly run: string;
+    readonly requestedAt: number;
+    readonly output: string;
+}
+export interface CiWait {
+    readonly commit: string;
+    readonly startedAt: number;
+    readonly reruns: CiRerun[];
+}
+export declare function ciWait(operation: Operation, commit: string): Promise<CiWait>;
+export declare function workflowAttempt(operation: Operation, run: string): Promise<{
+    readonly attempt: number;
+    readonly status: string;
+}>;
+export declare function attemptChecks(operation: Operation, workflow: {
+    readonly run: string;
+    readonly attempt: number;
+}): Promise<ReadonlySet<number>>;
+export declare function rerunCi(operation: Operation, request: {
+    readonly wait: CiWait;
+    readonly rerun: CiRerun;
+    readonly deadline: number;
+}): Promise<void>;
+export declare function attemptOutput(attempts: readonly string[]): string;