cloving 1.3.0 → 1.4.0

package/dist/src/daemon/schedule-control.js

@@ -0,0 +1,110 @@
+import { scheduleStops } from "../schedule-progress.js";
+import { runIdentity } from "../service/submission-handler.js";
+import { failed, invalidRequest, result } from "../service/replies.js";
+function summary(workflowId, progress) {
+    return {
+        workflowId,
+        everySeconds: progress.everySeconds,
+        state: progress.state,
+        failuresInRow: progress.failuresInRow,
+        failedRunIds: progress.failedRunIds,
+        lastSlot: progress.lastSlot,
+        nextAt: progress.state === "active" ? progress.nextAt : null,
+        activeRunId: progress.activeCommandId === undefined
+            ? null
+            : runIdentity(progress.activeCommandId),
+        stoppedAt: progress.stoppedAt ?? null,
+        stoppedSlot: progress.stoppedSlot ?? null,
+        stops: scheduleStops(progress),
+    };
+}
+export function scheduleConnection() {
+    let port;
+    return {
+        request: (parameters) => port?.(parameters) ??
+            Promise.resolve(failed("schedules-unavailable", {})),
+        connect: (connected) => {
+            port = connected;
+        },
+    };
+}
+async function change(settings, command) {
+    const { workflowId, action, now } = command;
+    const { journal } = settings;
+    let prior = journal.entries.get(workflowId);
+    if (prior === undefined)
+        return failed("unknown-schedule", { workflowId });
+    const state = action === "pause" ? "paused" : "active";
+    if (prior.state === state)
+        return result("schedule", { schedule: summary(workflowId, prior) });
+    if (prior.pending !== undefined) {
+        prior = await settings.recoverPending({ workflowId, progress: prior });
+        journal.entries.set(workflowId, prior);
+        await journal.save();
+    }
+    const rest = { ...prior };
+    delete rest.stoppedAt;
+    delete rest.stoppedSlot;
+    const progress = action === "pause"
+        ? { ...prior, state, stops: scheduleStops(prior) }
+        : {
+            ...rest,
+            state,
+            failuresInRow: 0,
+            failedRunIds: [],
+            stops: scheduleStops(prior),
+            nextAt: now + prior.everySeconds * 1000,
+        };
+    journal.entries.set(workflowId, progress);
+    try {
+        await journal.save();
+    }
+    catch (error) {
+        journal.entries.set(workflowId, prior);
+        throw error;
+    }
+    return result("schedule", { schedule: summary(workflowId, progress) });
+}
+function request(settings, parameters) {
+    const { action, workflowId } = parameters;
+    const scheduled = settings.declarations.filter((entry) => entry.schedule !== undefined);
+    if (action === "list")
+        return Promise.resolve(result("schedules", {
+            stops: Array.from(settings.journal.entries, ([workflowId, progress]) => ({
+                workflowId,
+                stops: scheduleStops(progress),
+            })),
+            schedules: scheduled.flatMap((entry) => {
+                const progress = settings.journal.entries.get(entry.workflowId);
+                return progress === undefined
+                    ? []
+                    : [summary(entry.workflowId, progress)];
+            }),
+        }));
+    if ((action !== "pause" && action !== "resume") ||
+        typeof workflowId !== "string")
+        return Promise.resolve(invalidRequest("Use list, pause or resume with a workflow ID."));
+    if (!scheduled.some((entry) => entry.workflowId === workflowId))
+        return Promise.resolve(failed("unknown-schedule", { workflowId }));
+    return change(settings, {
+        workflowId,
+        action,
+        now: settings.clock(),
+    });
+}
+export function scheduleControl(settings) {
+    let running = Promise.resolve();
+    const serialized = (operation) => {
+        const next = running.then(async () => {
+            settings.signal.throwIfAborted();
+            return operation();
+        });
+        running = next.then(() => undefined, () => undefined);
+        return next;
+    };
+    return {
+        request: (parameters) => serialized(() => request(settings, parameters)).catch(() => failed("schedules-unavailable", {})),
+        tick: () => serialized(settings.tick),
+        drain: () => running,
+    };
+}

package/dist/src/daemon/schedule-journal.d.ts

@@ -1,18 +1,5 @@
-import { type Fields } from "../protocol.ts";
-export type PendingSlot = {
-    readonly kind: "run";
-    readonly input: Fields;
-} | {
-    readonly kind: "skip";
-    readonly runId: string;
-};
-export interface ScheduleProgress {
-    readonly everySeconds: number;
-    readonly nextAt: number;
-    readonly lastSlot: number;
-    readonly activeCommandId?: string;
-    readonly pending?: PendingSlot;
-}
+import type { ScheduleProgress } from "../schedule-progress.ts";
+export type { PendingSlot, ScheduleProgress } from "../schedule-progress.ts";
 export declare function scheduleJournal(directory: string): Promise<{
     readonly entries: Map<string, ScheduleProgress>;
     readonly save: () => Promise<void>;

package/dist/src/daemon/schedule-journal.js

@@ -23,10 +23,68 @@ function isProgress(value) {
     const fields = record(value);
     if (fields === undefined)
         return false;
-    const { activeCommandId, pending } = fields;
+    const { activeCommandId } = fields;
     return (timing(fields) &&
-        (activeCommandId === undefined || isCommandId(activeCommandId)) &&
-        (pending === undefined || pendingSlot(pending)));
+        control(fields) &&
+        history(fields) &&
+        pendingProgress(fields) &&
+        (activeCommandId === undefined || isCommandId(activeCommandId)));
+}
+function pendingProgress(fields) {
+    const { pending, state } = fields;
+    if (pending === undefined)
+        return true;
+    return (state === undefined || state === "active") && pendingSlot(pending);
+}
+function stopped(fields) {
+    const { state, stoppedAt, stoppedSlot } = fields;
+    if (stoppedAt === undefined && stoppedSlot === undefined)
+        return state !== "stopped";
+    return (whole(stoppedAt) &&
+        whole(stoppedSlot) &&
+        stoppedSlot <= Number(fields["lastSlot"]));
+}
+function failures(fields) {
+    const { failuresInRow, failedRunIds } = fields;
+    return (whole(failuresInRow) &&
+        failuresInRow <= 3 &&
+        Array.isArray(failedRunIds) &&
+        failedRunIds.length === failuresInRow &&
+        failedRunIds.every(isRecordKey) &&
+        new Set(failedRunIds).size === failuresInRow);
+}
+function history(fields) {
+    const stops = fields["stops"];
+    if (stops === undefined)
+        return true;
+    if (!Array.isArray(stops))
+        return false;
+    let previousSlot = -1;
+    for (const item of stops) {
+        const stop = record(item);
+        if (stop === undefined)
+            return false;
+        const slot = stop["stoppedSlot"];
+        if (!whole(slot) || !whole(stop["stoppedAt"]))
+            return false;
+        if (slot <= previousSlot || slot > Number(fields["lastSlot"]))
+            return false;
+        if (!failures({ ...stop, failuresInRow: 3 }))
+            return false;
+        previousSlot = slot;
+    }
+    return true;
+}
+function control(fields) {
+    const { state, failuresInRow, failedRunIds } = fields;
+    if (state === undefined &&
+        failuresInRow === undefined &&
+        failedRunIds === undefined)
+        return (fields["stoppedAt"] === undefined && fields["stoppedSlot"] === undefined);
+    return (["active", "paused", "stopped"].includes(String(state)) &&
+        failures(fields) &&
+        stopped(fields) &&
+        (state !== "stopped" || failuresInRow === 3));
 }
 export async function scheduleJournal(directory) {
     const file = join(directory, "schedules.json");
@@ -42,7 +100,12 @@ export async function scheduleJournal(directory) {
     for (const [workflowId, value] of Object.entries(parsed)) {
         if (!isProgress(value))
             throw new Error("invalid-schedule-state");
-        entries.set(workflowId, value);
+        entries.set(workflowId, {
+            ...value,
+            state: value.state ?? "active",
+            failuresInRow: value.failuresInRow ?? 0,
+            failedRunIds: value.failedRunIds ?? [],
+        });
     }
     return {
         entries,

package/dist/src/daemon/ticket-registration.d.ts

@@ -1,10 +1,7 @@
 import { type DeclaredWorkflow } from "../workflow-declaration.ts";
 import type { Resolver, WorkflowRegistration } from "../service/registry.ts";
+import { type SubmissionContract } from "../submission.ts";
 import type { LocalCommands } from "../command-settings.ts";
-export declare const ticketWorkflow: "develop-ticket";
-export declare const promptWorkflow: "develop-prompt";
-export declare const issueWorkflow: "develop-issue";
-export declare const ticketCapabilities: string[];
 export type TicketRegistrations = {
     readonly kind: "admitted";
     readonly registrations: readonly WorkflowRegistration[];
@@ -24,10 +21,8 @@ export interface TicketRegistration extends Omit<WorkflowRegistration, "manifest
     readonly effectLimit: number;
     readonly capabilities?: readonly string[];
 }
-export declare function ticketResolver(source: TicketSource): Resolver;
-export declare function issueResolver(source: TicketSource): Resolver;
-export declare function promptResolver(repository: string): Resolver;
 export declare function ticketRegistrationTable(source: TicketSource, declarations?: readonly DeclaredWorkflow[]): readonly TicketRegistration[];
+export declare function declaredResolver(source: TicketSource, contract: SubmissionContract): Resolver;
 export declare function ticketRegistrations(manifests: Readonly<Record<string, string | undefined>>, options: {
     readonly table: readonly TicketRegistration[];
     readonly bundleDigest?: string;

package/dist/src/daemon/ticket-registration.js

@@ -1,45 +1,34 @@
-import { createHash } from "node:crypto";
 import { admitCompiled } from "../cli/validate.js";
 import { isCommandWaits, workflowQueueRefusals, } from "../workflow-declaration.js";
 import { ticketCommandText, ticketText } from "./ticket-source.js";
 import { declaredInput } from "./declared-input.js";
-import { bundledWorkflowIds } from "../workflow-discovery.js";
 import { declaredManifest } from "../execution-pin.js";
 import { record } from "../protocol.js";
 import { hasTicketField } from "../submission.js";
 import { issueIdentity } from "../issue-identity.js";
 import { ticketDependencyWaits, TicketDependencyReadError, } from "./ticket-dependency-waits.js";
-export const ticketWorkflow = bundledWorkflowIds.ticket;
-export const promptWorkflow = bundledWorkflowIds.prompt;
-export const issueWorkflow = bundledWorkflowIds.issue;
-export const ticketCapabilities = ["claude", "github"];
+const defaultCapabilities = ["claude", "github"];
 const ticketIdentifier = /^[A-Za-z0-9._:-]{1,64}$/;
 function rejected(code, detail) {
     return { kind: "rejected", code, detail };
 }
-function digest(commandId) {
-    return createHash("sha256").update(commandId).digest("hex");
-}
 async function ticket(source, request) {
-    const { command, repository } = source;
+    const { command } = source;
     const ticketId = String(request.submission["ticket"]);
     if (ticketId === "next")
         return nextTicket(source, request);
     if (!ticketIdentifier.test(ticketId))
         return rejected("invalid-ticket-id", "A ticket ID has letters, digits and the characters . _ : - only.");
     if (command === undefined)
-        return rejected("ticket-source-not-configured", "The daemon has no ticket command. Set CLOVING_TICKET_COMMAND, or use the workflow develop-prompt.");
+        return rejected("ticket-source-not-configured", "The daemon has no ticket command. Set CLOVING_TICKET_COMMAND.");
     const read = await ticketText(command, { ticketId, signal: request.signal });
     if (read.kind === "failed")
         return rejected("ticket-not-available", read.detail);
-    const name = ticketId.toLowerCase().replace(/[^a-z0-9-]/g, "-");
     return {
         kind: "resolved",
         input: {
-            cycleId: `${name}-${digest(request.commandId).slice(0, 8)}`,
             ticketId,
             ticket: read.text,
-            repository,
         },
     };
 }
@@ -63,17 +52,10 @@ async function nextTicket(source, request) {
         return rejected("invalid-ticket-id", "The next-ticket command must print one valid ticket ID other than next.");
     return ticket(source, { ...request, submission: { ticket: selected.text } });
 }
-export function ticketResolver(source) {
-    return {
-        id: "ticket-command",
-        version: "1",
-        resolve: (request) => ticket(source, request),
-    };
-}
-export function issueResolver(source) {
+function ticketResolver(source) {
     const waits = ticketDependencyWaits(source);
     return {
-        id: "issue-command",
+        id: "ticket-command",
         version: "1",
         skippedTickets: waits.skipped,
         resolve: (request) => issueTicket({ source, waits }, request).catch((error) => {
@@ -107,66 +89,18 @@ async function issueTicket(context, request) {
         return rejected("ticket-dependency-open", `Ticket ${String(input["ticketId"])} needs open issues: ${dependencies.map((id) => `#${id}`).join(", ")}.`);
     return {
         kind: "resolved",
-        input: { ...input, delivery: "pull-request" },
-    };
-}
-export function promptResolver(repository) {
-    return {
-        id: "ticket-prompt",
-        version: "1",
-        resolve: (request) => Promise.resolve({
-            kind: "resolved",
-            input: {
-                cycleId: `task-${digest(request.commandId).slice(0, 12)}`,
-                ticket: String(request.submission["prompt"]),
-                repository,
-            },
-        }),
+        input,
     };
 }
 export function ticketRegistrationTable(source, declarations = []) {
-    return [
-        {
-            workflowId: ticketWorkflow,
-            functionName: "developTicket",
-            effectLimit: 8,
-            handoffs: [],
-            submission: { maximumBytes: 4_096, fields: { ticket: "string" } },
-            resolver: ticketResolver(source),
-        },
-        {
-            workflowId: issueWorkflow,
-            functionName: "developTicket",
-            effectLimit: 20,
-            handoffs: [],
-            submission: { maximumBytes: 4_096, fields: { ticket: "string" } },
-            resolver: issueResolver(source),
-        },
-        {
-            workflowId: bundledWorkflowIds.prd,
-            functionName: "developPrd",
-            effectLimit: 8,
-            handoffs: [issueWorkflow],
-            submission: { maximumBytes: 65_536, fields: { prompt: "string" } },
-            resolver: promptResolver(source.repository),
-        },
-        {
-            workflowId: promptWorkflow,
-            functionName: "developTicket",
-            effectLimit: 8,
-            handoffs: [],
-            submission: { maximumBytes: 65_536, fields: { prompt: "string" } },
-            resolver: promptResolver(source.repository),
-        },
-        ...declarations.map(({ input, ...declaration }) => ({
-            ...declaration,
-            submission: input,
-            resolver: declaredResolver(source, input),
-        })),
-    ];
+    return declarations.map(({ input, ...declaration }) => ({
+        ...declaration,
+        submission: input,
+        resolver: declaredResolver(source, input),
+    }));
 }
-function declaredResolver(source, contract) {
-    const tickets = hasTicketField(contract) ? issueResolver(source) : undefined;
+export function declaredResolver(source, contract) {
+    const tickets = hasTicketField(contract) ? ticketResolver(source) : undefined;
     return {
         id: "declared-input",
         version: "1",
@@ -202,7 +136,7 @@ export async function ticketRegistrations(manifests, options) {
         return { kind: "rejected", detail: refusal };
     const registrations = [];
     for (const row of options.table) {
-        const { functionName, capabilities = ticketCapabilities, ...registration } = row;
+        const { functionName, capabilities = defaultCapabilities, ...registration } = row;
         const manifest = manifests[functionName];
         if (manifest === undefined)
             return {
@@ -254,7 +188,7 @@ function registrationRefusal(table, commands) {
 function commandRegistrationRefusal(row, commands) {
     if (Object.hasOwn(row, "commandWaits") &&
         !isCommandWaits(row.commandWaits, {
-            capabilities: row.capabilities ?? ticketCapabilities,
+            capabilities: row.capabilities ?? defaultCapabilities,
             commands: row.commands ?? [],
         }))
         return `invalid-command-waits: ${row.workflowId}`;

package/dist/src/daemon/turn-attempt-journal.d.ts

@@ -0,0 +1,38 @@
+import { type TurnEnd, type TurnProgress } from "./claude-turn.ts";
+import { attemptCommand, type Attempts } from "./turn-attempts.ts";
+declare function attemptEntry(attempts: Attempts, selected: ReturnType<typeof attemptCommand>): {
+    startedAt: string;
+    resumedAfter?: "daemon-restart";
+    attempt: number;
+    fallbackReason?: string;
+    budgetUsd?: number;
+    turnStartCommit: string | null;
+    model: string | null;
+};
+export declare function prepareAttempt(attempts: Attempts): Promise<{
+    entry: {
+        startedAt: string;
+        resumedAfter?: "daemon-restart";
+        attempt: number;
+        fallbackReason?: string;
+        budgetUsd?: number;
+        turnStartCommit: string | null;
+        model: string | null;
+    };
+    selected: {
+        fallbackReason?: string;
+        model: string | null;
+        budgetUsd?: number;
+        command: readonly string[];
+    };
+    folder: string;
+} | undefined>;
+export declare function attemptJournal(attempts: Attempts, entry: ReturnType<typeof attemptEntry>): {
+    progress: (snapshot: TurnProgress) => Promise<void>;
+    running: (identifier: number | null) => Promise<void>;
+};
+export declare function recordedEnd(attempts: Attempts, completion: {
+    readonly processId: number | null;
+    readonly end: TurnEnd;
+}): Promise<void>;
+export {};

package/dist/src/daemon/turn-attempt-journal.js

@@ -0,0 +1,136 @@
+import { join } from "node:path";
+import { mkdir } from "node:fs/promises";
+import { readRecord, writeRecord } from "./operation-journal.js";
+import { capacityRefusal, } from "./claude-turn.js";
+import { attemptCommand, attemptUsage, attemptCost, } from "./turn-attempts.js";
+function written(folder, entry) {
+    return writeRecord(folder, { ...entry, permissions: "private" });
+}
+function attemptEntry(attempts, selected) {
+    const attempt = attempts.ends.length + 1;
+    const resume = attempts.options.resume;
+    return {
+        ...attempts.options.metadata,
+        turnStartCommit: attempts.turnStartCommit,
+        model: selected.model,
+        ...(selected.budgetUsd === undefined
+            ? {}
+            : { budgetUsd: selected.budgetUsd }),
+        ...(selected.fallbackReason === undefined
+            ? {}
+            : { fallbackReason: selected.fallbackReason }),
+        attempt,
+        ...(resume !== undefined && attempt === resume.ends.length + 1
+            ? { resumedAfter: "daemon-restart" }
+            : {}),
+        startedAt: attempt === 1 ? attempts.startedAt : new Date().toISOString(),
+    };
+}
+export async function prepareAttempt(attempts) {
+    const selected = attemptCommand(attempts, attempts.ends.length + 1);
+    if (selected.budgetUsd === 0) {
+        attempts.failure = "claude-turn-budget-exhausted";
+        return undefined;
+    }
+    const entry = attemptEntry(attempts, selected);
+    const folder = entry.attempt === 1
+        ? attempts.start.folder
+        : join(attempts.start.folder, `attempt-${String(entry.attempt)}`);
+    await written(attempts.start.folder, {
+        name: "started.json",
+        value: {
+            ...entry,
+            startedAt: attempts.startedAt,
+            phase: "starting",
+            processId: null,
+        },
+    });
+    await mkdir(folder, { recursive: true, mode: 0o700 });
+    return { entry, selected, folder };
+}
+function progressFields(attempts, progress) {
+    const result = progress?.result;
+    const end = { exitCode: null, result };
+    if (result === undefined)
+        return {
+            sessionId: progress?.sessionId ?? null,
+            sessionCostUsd: null,
+            costUsd: null,
+        };
+    return {
+        sessionId: progress?.sessionId ?? null,
+        sessionCostUsd: result.costUsd,
+        costUsd: attemptCost([...attempts.ends, end], attempts.ends.length),
+        usage: result.usage,
+        turns: result.turns,
+    };
+}
+export function attemptJournal(attempts, entry) {
+    let saved = Promise.resolve();
+    let progress;
+    let processId = null;
+    const save = () => {
+        const value = {
+            ...entry,
+            phase: "running",
+            processId,
+            ...progressFields(attempts, progress),
+        };
+        saved = saved.then(() => written(attempts.start.folder, {
+            name: `attempt-${String(entry.attempt)}.json`,
+            value,
+        }));
+        return saved;
+    };
+    return {
+        progress: (snapshot) => {
+            progress = snapshot;
+            return save();
+        },
+        running: async (identifier) => {
+            processId = identifier;
+            await written(attempts.start.folder, {
+                name: "started.json",
+                value: {
+                    ...entry,
+                    startedAt: attempts.startedAt,
+                    phase: "running",
+                    processId,
+                },
+            });
+            await save();
+        },
+    };
+}
+export async function recordedEnd(attempts, completion) {
+    const { start, ends, options } = attempts;
+    const { processId, end } = completion;
+    const attempt = ends.length;
+    const selected = attemptCommand(attempts, attempt);
+    const name = `attempt-${String(attempt)}.json`;
+    const record = await readRecord(start.folder, name);
+    const started = typeof record === "object" && record !== null ? record : {};
+    const startedAt = Reflect.get(started, "startedAt");
+    if (typeof startedAt !== "string")
+        throw new Error("attempt-start-time-missing");
+    await written(start.folder, {
+        name,
+        value: {
+            ...started,
+            ...options.metadata,
+            turnStartCommit: attempts.turnStartCommit,
+            ...attemptUsage(attempts, { end, attempt }),
+            ...(selected.fallbackReason === undefined
+                ? {}
+                : { fallbackReason: selected.fallbackReason }),
+            attempt,
+            processId,
+            startedAt,
+            endedAt: new Date().toISOString(),
+            exitCode: end.exitCode,
+            capacity: capacityRefusal(end.result),
+            sessionCostUsd: end.result?.costUsd ?? null,
+            turns: end.result?.turns ?? null,
+        },
+    });
+}

package/dist/src/daemon/turn-attempts.d.ts

@@ -0,0 +1,47 @@
+import { usageOf, type WorkerAttemptUsage } from "../worker-usage.ts";
+import { type TokenPrices } from "../token-prices.ts";
+import { type TurnEnd, type TurnStart } from "./claude-turn.ts";
+import type { TurnResume } from "./claude-recovery.ts";
+export interface RetrySettings {
+    readonly tokenPrices?: TokenPrices;
+    readonly fallbackModels?: readonly string[];
+    readonly retryDelay?: (milliseconds: number, signal: AbortSignal) => Promise<void>;
+}
+export interface RetryOptions extends RetrySettings {
+    readonly resume?: TurnResume;
+    readonly stopping?: AbortController;
+    readonly stopMilliseconds?: number;
+    readonly metadata: Readonly<Record<string, unknown>>;
+}
+export interface Attempts {
+    failure?: string;
+    readonly start: TurnStart;
+    readonly turnStartCommit: string | null;
+    readonly startedAt: string;
+    readonly options: RetryOptions;
+    readonly stopping: AbortController;
+    readonly grace: {
+        milliseconds: number;
+    };
+    readonly ends: TurnEnd[];
+}
+export declare function total(values: readonly (number | null)[]): number | null;
+export declare function combined(attempts: Attempts): TurnEnd;
+export declare function attemptCommand(attempts: Attempts, attempt: number): {
+    fallbackReason?: string;
+    model: string | null;
+    budgetUsd?: number;
+    command: readonly string[];
+};
+export declare function attemptUsage(attempts: Attempts, completion: {
+    readonly end: TurnEnd;
+    readonly attempt: number;
+}): WorkerAttemptUsage;
+export declare function sessionCost(ends: readonly TurnEnd[]): number | null;
+export declare function attemptCost(ends: readonly TurnEnd[], index: number): number | null;
+export declare function attemptEstimate(attempts: Attempts, result: {
+    readonly end: TurnEnd;
+    readonly model: string | null;
+    readonly usage: ReturnType<typeof usageOf>;
+}): number | null;
+export declare function kindOf(attempts: Attempts, end: TurnEnd): import("../worker-usage.ts").RetryKind | null;