cloving 1.2.0 → 1.4.0

package/dist/src/daemon/text-output.js

@@ -0,0 +1,44 @@
+import { usageOf } from "../worker-usage.js";
+import { reviewReportStream } from "../review-subject.js";
+import { ticketStatusStream } from "../ticket-status-stream.js";
+export function textOutput(child, options) {
+    const { output, limit } = options;
+    const status = ticketStatusStream(limit);
+    const verdict = reviewReportStream(limit);
+    let text = "";
+    let error = "";
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+        error = (error + chunk).slice(-limit);
+    });
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+        text = (text + chunk).slice(-limit);
+        status.write(chunk);
+        verdict.write(chunk);
+        if (!output.write(chunk)) {
+            child.stdout.pause();
+            output.once("drain", () => {
+                child.stdout.resume();
+            });
+        }
+    });
+    return async (exitCode) => {
+        await new Promise((resolve) => output.end(resolve));
+        const review = verdict.result();
+        return {
+            ...status.result(),
+            reviewVerdict: review.reviewVerdict,
+            ...(review.reviewVerdict === null
+                ? {}
+                : { reviewFeedback: review.feedback }),
+            text: exitCode === 0 ? text : error,
+            failed: exitCode !== 0,
+            model: null,
+            costUsd: null,
+            usage: usageOf(null),
+            sessionId: null,
+            turns: null,
+        };
+    };
+}

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

@@ -1,9 +1,7 @@
-import type { DeclaredWorkflow, WorkflowStage } from "../workflow-declaration.ts";
+import { type DeclaredWorkflow } from "../workflow-declaration.ts";
 import type { Resolver, WorkflowRegistration } from "../service/registry.ts";
-export declare const ticketWorkflow: "develop-ticket";
-export declare const promptWorkflow: "develop-prompt";
-export declare const issueWorkflow: "develop-issue";
-export declare const ticketCapabilities: string[];
+import { type SubmissionContract } from "../submission.ts";
+import type { LocalCommands } from "../command-settings.ts";
 export type TicketRegistrations = {
     readonly kind: "admitted";
     readonly registrations: readonly WorkflowRegistration[];
@@ -18,20 +16,15 @@ export interface TicketSource {
     readonly githubCommand?: readonly string[] | undefined;
     readonly skipTickets?: readonly string[];
 }
-export interface TicketRegistration {
-    readonly workflowId: string;
+export interface TicketRegistration extends Omit<WorkflowRegistration, "manifest" | "availability" | "admission"> {
     readonly functionName: string;
-    readonly resolver: Resolver;
-    readonly submission: WorkflowRegistration["submission"];
     readonly effectLimit: number;
     readonly capabilities?: readonly string[];
-    readonly stages?: readonly WorkflowStage[];
-    readonly handoffs?: 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;
+    readonly commands?: LocalCommands;
 }): Promise<TicketRegistrations>;

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

@@ -1,42 +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 { bundledWorkflowIds } from "../workflow-discovery.js";
+import { declaredInput } from "./declared-input.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,
         },
     };
 }
@@ -60,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) => {
@@ -104,108 +89,54 @@ 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((declaration) => ({
-            workflowId: declaration.workflowId,
-            functionName: declaration.functionName,
-            effectLimit: declaration.effectLimit,
-            capabilities: declaration.capabilities,
-            submission: declaration.input,
-            ...(declaration.stages === undefined
-                ? {}
-                : { stages: declaration.stages }),
-            ...(declaration.handoffs === undefined
-                ? {}
-                : { handoffs: declaration.handoffs }),
-            resolver: declaredResolver(source.repository),
-        })),
-    ];
+    return declarations.map(({ input, ...declaration }) => ({
+        ...declaration,
+        submission: input,
+        resolver: declaredResolver(source, input),
+    }));
 }
-function declaredResolver(repository) {
+export function declaredResolver(source, contract) {
+    const tickets = hasTicketField(contract) ? ticketResolver(source) : undefined;
     return {
         id: "declared-input",
         version: "1",
-        resolve: (request) => Promise.resolve({
-            kind: "resolved",
-            input: {
-                cycleId: `task-${digest(request.commandId).slice(0, 12)}`,
-                repository,
-                input: request.submission,
-            },
-        }),
+        ...(tickets?.skippedTickets === undefined
+            ? {}
+            : { skippedTickets: tickets.skippedTickets }),
+        resolve: async (request) => {
+            const resolution = tickets !== undefined && Object.hasOwn(request.submission, "ticket")
+                ? await tickets.resolve(request)
+                : undefined;
+            if (resolution?.kind === "rejected")
+                return resolution;
+            const ticket = resolution === undefined ? undefined : (record(resolution.input) ?? {});
+            const input = ticket === undefined
+                ? request.submission
+                : {
+                    ...request.submission,
+                    ticket: { id: ticket["ticketId"], text: ticket["ticket"] },
+                };
+            return {
+                kind: "resolved",
+                input: declaredInput(source.repository, {
+                    commandId: request.commandId,
+                    submission: input,
+                }),
+            };
+        },
     };
 }
 export async function ticketRegistrations(manifests, options) {
-    const ids = new Set();
-    for (const row of options.table) {
-        if (ids.has(row.workflowId))
-            return {
-                kind: "rejected",
-                detail: `duplicate-workflow-id: ${row.workflowId}`,
-            };
-        ids.add(row.workflowId);
-    }
-    for (const row of options.table) {
-        const unknown = row.handoffs?.find((target) => !ids.has(target));
-        if (unknown !== undefined)
-            return {
-                kind: "rejected",
-                detail: `unknown-handoff-target: ${row.workflowId} -> ${unknown}`,
-            };
-    }
+    const refusal = registrationRefusal(options.table, options.commands ?? {});
+    if (refusal !== undefined)
+        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 {
@@ -223,9 +154,57 @@ export async function ticketRegistrations(manifests, options) {
             };
         registrations.push({
             ...registration,
-            manifest: declaredManifest(admission.manifest, row),
+            manifest: declaredManifest(admission.manifest, {
+                ...row,
+                bundleDigest: options.bundleDigest,
+            }),
             availability: "available",
         });
     }
     return { kind: "admitted", registrations };
 }
+function registrationRefusal(table, commands) {
+    const queueRefusal = queueRegistrationRefusal(table);
+    if (queueRefusal !== undefined)
+        return queueRefusal;
+    const ids = new Set();
+    for (const row of table) {
+        if (ids.has(row.workflowId))
+            return `duplicate-workflow-id: ${row.workflowId}`;
+        ids.add(row.workflowId);
+    }
+    for (const row of table) {
+        const unknown = row.handoffs?.find((target) => !ids.has(target));
+        if (unknown !== undefined)
+            return `unknown-handoff-target: ${row.workflowId} -> ${unknown}`;
+    }
+    for (const row of table) {
+        const refusal = commandRegistrationRefusal(row, commands);
+        if (refusal !== undefined)
+            return refusal;
+    }
+    return undefined;
+}
+function commandRegistrationRefusal(row, commands) {
+    if (Object.hasOwn(row, "commandWaits") &&
+        !isCommandWaits(row.commandWaits, {
+            capabilities: row.capabilities ?? defaultCapabilities,
+            commands: row.commands ?? [],
+        }))
+        return `invalid-command-waits: ${row.workflowId}`;
+    const unknown = row.commands?.find((name) => !Object.hasOwn(commands, name));
+    return unknown === undefined
+        ? undefined
+        : `command-unknown: ${row.workflowId} -> ${unknown}`;
+}
+function queueRegistrationRefusal(table) {
+    const queued = table.filter((row) => row.queue === true);
+    if (queued.length > 1)
+        return `queue-workflow-conflict: ${queued.map((row) => row.workflowId).join(", ")}`;
+    for (const row of queued) {
+        const codes = workflowQueueRefusals({ queue: true, input: row.submission });
+        if (codes.length > 0)
+            return `${codes.join(", ")}: ${row.workflowId}`;
+    }
+    return undefined;
+}

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;