cloving 1.2.0 → 1.3.0

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

@@ -1,9 +1,12 @@
 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;
@@ -155,54 +158,48 @@ export function ticketRegistrationTable(source, declarations = []) {
             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),
+        ...declarations.map(({ input, ...declaration }) => ({
+            ...declaration,
+            submission: input,
+            resolver: declaredResolver(source, input),
         })),
     ];
 }
-function declaredResolver(repository) {
+function declaredResolver(source, contract) {
+    const tickets = hasTicketField(contract) ? issueResolver(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;
@@ -223,9 +220,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 ?? ticketCapabilities,
+            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-command.d.ts

@@ -0,0 +1,10 @@
+export interface CommandStart {
+    readonly output?: string | undefined;
+    readonly worker?: string | undefined;
+    readonly command: readonly string[];
+    readonly prompt: string;
+}
+export declare function turnCommand(start: CommandStart): {
+    readonly parts: readonly string[];
+    readonly standardInput: string | undefined;
+};

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

@@ -0,0 +1,33 @@
+function argumentPrompt(prompt) {
+    return Buffer.byteLength(prompt, "utf8") < 64 * 1024;
+}
+export function turnCommand(start) {
+    if (start.output === "text")
+        return {
+            parts: start.command.map((part) => part === "{prompt}" ? start.prompt : part),
+            standardInput: start.command.includes("{prompt}")
+                ? undefined
+                : start.prompt,
+        };
+    if (start.worker === "gemini" && argumentPrompt(start.prompt))
+        return {
+            parts: [...start.command, "-p", start.prompt],
+            standardInput: undefined,
+        };
+    if (start.worker === "opencode")
+        return {
+            parts: [...start.command, start.prompt],
+            standardInput: undefined,
+        };
+    if (start.worker === "cursor-agent" && argumentPrompt(start.prompt))
+        return {
+            parts: [...start.command, start.prompt],
+            standardInput: undefined,
+        };
+    if (start.worker !== "grok")
+        return { parts: start.command, standardInput: start.prompt };
+    const command = [...start.command];
+    const index = command.findIndex((argument, position) => position > 0 && ["-p", "--single"].includes(argument));
+    command.splice(index < 0 ? command.length : index + 1, 0, start.prompt);
+    return { parts: command, standardInput: undefined };
+}

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

@@ -0,0 +1,18 @@
+import { type WorkTree } from "./work-tree.ts";
+import type { StreamResult } from "./claude-turn.ts";
+interface ReportLimits {
+    readonly summaryCharacters: number;
+    readonly resultBytes: number;
+}
+export declare function turnReport(start: {
+    readonly harness: {
+        readonly worker: string;
+        readonly output?: "text";
+    };
+    readonly tree: WorkTree;
+    readonly limits: ReportLimits;
+}, result: StreamResult): Promise<{
+    readonly text?: string;
+    readonly reason?: string;
+}>;
+export {};

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

@@ -0,0 +1,79 @@
+import { ticketStatus } from "../ticket-status.js";
+import { reviewReport } from "../review-subject.js";
+import { sumPrices } from "../worker-usage.js";
+import { changes } from "./work-tree.js";
+function tailReport(fields, limit) {
+    let text = JSON.stringify({ ...fields, summary: "" });
+    if (Buffer.byteLength(text) > limit)
+        return undefined;
+    let minimum = 1;
+    let maximum = fields.summary.length;
+    while (minimum <= maximum) {
+        const kept = Math.floor((minimum + maximum) / 2);
+        const candidate = JSON.stringify({
+            ...fields,
+            summary: fields.summary.slice(-kept),
+        });
+        if (Buffer.byteLength(candidate) > limit) {
+            maximum = kept - 1;
+            continue;
+        }
+        text = candidate;
+        minimum = kept + 1;
+    }
+    return text;
+}
+function boundedReport(fields, options) {
+    const text = JSON.stringify(fields);
+    const excess = Buffer.byteLength(text) - options.limit;
+    if (excess <= 0)
+        return { text };
+    if (options.output === "text") {
+        const shortened = tailReport(fields, options.limit);
+        return shortened === undefined
+            ? { reason: "claude-result-too-large" }
+            : { text: shortened };
+    }
+    const kept = Math.max(0, fields.summary.length - excess);
+    const shortened = JSON.stringify({
+        ...fields,
+        summary: fields.summary.slice(0, kept),
+    });
+    if (Buffer.byteLength(shortened) <= options.limit)
+        return { text: shortened };
+    const metadata = JSON.stringify({
+        ...fields,
+        ticketStatus: undefined,
+        summary: "",
+    });
+    return {
+        reason: "claude-result-too-large",
+        ...(Buffer.byteLength(metadata) <= options.limit ? { text: metadata } : {}),
+    };
+}
+export async function turnReport(start, result) {
+    if (result.ticketStatusTooLarge === true)
+        return { reason: "claude-result-too-large" };
+    const { harness, tree, limits } = start;
+    const review = reviewReport(result.text);
+    const feedback = result.reviewFeedback ?? review.feedback;
+    return boundedReport({
+        harness: harness.worker,
+        ticketStatus: ticketStatus(result.text, result.ticketStatus),
+        reviewVerdict: result.reviewVerdict === undefined
+            ? review.reviewVerdict
+            : result.reviewVerdict,
+        summary: harness.output === "text"
+            ? feedback.slice(-limits.summaryCharacters)
+            : feedback.slice(0, limits.summaryCharacters),
+        ...(await changes(tree)),
+        worktree: tree.path,
+        costUsd: result.costUsd,
+        usage: result.usage,
+        model: result.model,
+        ...(result.attempts === undefined ? {} : { attempts: result.attempts }),
+        estimatedCostUsd: sumPrices((result.attempts ?? []).map((attempt) => attempt.estimatedCostUsd)),
+        sessionId: result.sessionId,
+        turns: result.turns,
+    }, { ...harness, limit: limits.resultBytes });
+}

package/dist/src/daemon/work-tree.d.ts

@@ -12,9 +12,10 @@ export interface TreeRequest {
 }
 export interface Changes {
     readonly branch: string;
+    readonly commit: string | null;
     readonly commits: readonly string[];
     readonly files: readonly string[];
-    readonly uncommitted: readonly string[];
+    readonly uncommitted: readonly string[] | null;
 }
 export declare function treeName(target: string): string;
 export declare function treePlace(request: Pick<TreeRequest, "worktrees" | "target">): {

package/dist/src/daemon/work-tree.js

@@ -186,21 +186,24 @@ export function treeFailure(error) {
         : "work-tree-not-available";
 }
 export async function changes(tree) {
-    const lines = async (parts) => (await git({ directory: tree.path, parts }).catch(() => ""))
-        .split("\n")
-        .filter((line) => line.trim() !== "")
-        .slice(0, lineLimit)
-        .map((line) => line.slice(0, lineLength));
+    const lines = (parts) => changeLines({ directory: tree.path, parts });
     const range = `${tree.startCommit}..HEAD`;
-    const [branch = tree.branch] = await lines([
-        "rev-parse",
-        "--abbrev-ref",
-        "HEAD",
-    ]);
+    const branch = (await lines(["rev-parse", "--abbrev-ref", "HEAD"]))?.[0] ?? tree.branch;
     return {
         branch,
-        commits: await lines(["log", "--oneline", range]),
-        files: await lines(["diff", "--stat", range]),
+        commit: (await lines(["rev-parse", "HEAD"]))?.[0] ?? null,
+        commits: (await lines(["log", "--oneline", range])) ?? [],
+        files: (await lines(["diff", "--stat", range])) ?? [],
         uncommitted: await lines(["status", "--short"]),
     };
 }
+async function changeLines(call) {
+    const output = await git(call).catch(() => null);
+    if (output === null)
+        return null;
+    return output
+        .split("\n")
+        .filter((line) => line.trim() !== "")
+        .slice(0, lineLimit)
+        .map((line) => line.slice(0, lineLength));
+}

package/dist/src/daemon/workflow-generations.d.ts

@@ -0,0 +1,32 @@
+import type { HostPorts } from "../service/service.ts";
+import type { WorkflowFunction } from "../host/start-delivery.ts";
+import type { WorkflowHandler } from "../host/world-host.ts";
+import type { ExecutionManifest } from "../workflow-admission.ts";
+import { type WorkflowRegistration } from "../service/registry.ts";
+export interface WorkflowGeneration {
+    readonly workflows: Readonly<Record<string, unknown>>;
+    readonly handler: WorkflowHandler;
+}
+export type WorkflowBundleLoader = (directory: string) => Promise<WorkflowGeneration>;
+export declare function workflowGenerations(settings: {
+    readonly directory: string;
+    readonly repository: string;
+    readonly registrations: readonly WorkflowRegistration[];
+    readonly table: readonly {
+        readonly workflowId: string;
+        readonly functionName: string;
+    }[];
+    readonly workflows: Readonly<Record<string, WorkflowFunction | undefined>>;
+    readonly handler: WorkflowHandler;
+    readonly loadBundle?: WorkflowBundleLoader;
+}): {
+    resolve: (manifest: ExecutionManifest | undefined) => Promise<{
+        workflow: WorkflowFunction;
+        handler: WorkflowHandler;
+    } | undefined>;
+    available: (manifest: ExecutionManifest) => Promise<ExecutionManifest | undefined>;
+};
+export declare function prepareWorkflowGenerations(ports: {
+    readonly state: HostPorts["state"];
+    readonly workflow: Pick<HostPorts["workflow"], "manifest">;
+}, generations: Pick<ReturnType<typeof workflowGenerations>, "resolve">): Promise<void>;

package/dist/src/daemon/workflow-generations.js

@@ -0,0 +1,57 @@
+import { join } from "node:path";
+import { workflowRegistry, } from "../service/registry.js";
+import { workflowPin } from "../broker/workflow-pin.js";
+export function workflowGenerations(settings) {
+    const functions = Object.fromEntries(settings.table.map((row) => [
+        row.workflowId,
+        settings.workflows[row.functionName],
+    ]));
+    const registry = workflowRegistry(settings.registrations, {
+        workflowBundles: {
+            directory: join(settings.directory, "workflow-bundles"),
+            repository: settings.repository,
+        },
+    });
+    const resolve = async (manifest) => {
+        if (manifest === undefined)
+            return undefined;
+        const registered = registry.byPin(workflowPin(manifest));
+        if (registered !== undefined) {
+            const workflow = functions[registered.workflowId];
+            return workflow === undefined
+                ? undefined
+                : { workflow, handler: settings.handler };
+        }
+        if (manifest.bundleDigest === undefined ||
+            settings.loadBundle === undefined)
+            return undefined;
+        const directory = await registry.bundle(manifest);
+        if (directory === undefined)
+            return undefined;
+        try {
+            const generation = await settings.loadBundle(directory);
+            const workflow = Object.values(generation.workflows).find((candidate) => typeof candidate === "function" &&
+                Reflect.get(candidate, "workflowId") === manifest.workflowId);
+            return workflow === undefined
+                ? undefined
+                : { workflow, handler: generation.handler };
+        }
+        catch {
+            return undefined;
+        }
+    };
+    return {
+        resolve,
+        available: async (manifest) => (await resolve(manifest)) === undefined ? undefined : manifest,
+    };
+}
+export async function prepareWorkflowGenerations(ports, generations) {
+    const prepared = new Set();
+    for (const run of Object.values((await ports.state()).runs)) {
+        if (["completed", "failed", "cancelled"].includes(run.status) ||
+            prepared.has(run.workflow))
+            continue;
+        prepared.add(run.workflow);
+        await generations.resolve(await ports.workflow.manifest(run.runId));
+    }
+}

package/dist/src/daemon/workflow-replay.d.ts

@@ -0,0 +1,16 @@
+import type { WorkflowHandler } from "../host/world-host.ts";
+import type { AuthorityState } from "../authority/transitions.ts";
+interface ReplayRun {
+    readonly runId: string;
+    readonly workflowId?: string;
+}
+interface ReplayPorts {
+    readonly state: () => Promise<Pick<AuthorityState, "details">>;
+    readonly run: (receipt: string) => Promise<ReplayRun | undefined>;
+    readonly available: (runId: string, workflowId?: string) => Promise<boolean>;
+    readonly submit: (command: Readonly<Record<string, unknown>>) => Promise<{
+        readonly kind: "accepted" | "duplicate" | "failed" | "rejected";
+    }>;
+}
+export declare function pinnedWorkflowHandler(handler: (request: Request, runId: string) => Promise<Response>, ports: ReplayPorts): WorkflowHandler;
+export {};

package/dist/src/daemon/workflow-replay.js

@@ -0,0 +1,58 @@
+import { record } from "../protocol.js";
+import { setTimeout as delay } from "node:timers/promises";
+function seeded(value) {
+    const input = record(record(value)?.["runInput"]);
+    const runId = record(input?.["attributes"])?.["cloving.run"];
+    const workflowId = input?.["workflowName"];
+    return typeof runId === "string" && typeof workflowId === "string"
+        ? { runId, workflowId }
+        : undefined;
+}
+async function located(ports, receipt) {
+    for (let attempt = 0; attempt < 20; attempt += 1) {
+        const run = await ports.run(receipt);
+        if (run !== undefined)
+            return run;
+        await delay(5);
+    }
+    return undefined;
+}
+async function observedReplay(ports, replay) {
+    const { runId, receipt, available } = replay;
+    const observation = (await ports.state()).details[runId]?.observation;
+    const unavailable = observation?.reason === "pinned-workflow-unavailable";
+    if (available !== unavailable)
+        return true;
+    const expectedObservation = observation?.sequence ?? 0;
+    const outcome = await ports.submit({
+        kind: "report-observation",
+        runId,
+        commandId: `pinned-workflow-${available ? "restored" : "unavailable"}:${receipt}:${String(expectedObservation)}`,
+        condition: available ? "working" : "infrastructure-failure",
+        reason: available ? "in-progress" : "pinned-workflow-unavailable",
+        expectedObservation,
+    });
+    return outcome.kind === "accepted" || outcome.kind === "duplicate";
+}
+export function pinnedWorkflowHandler(handler, ports) {
+    return async (request) => {
+        const value = await request
+            .clone()
+            .json()
+            .catch(() => undefined);
+        const receipt = record(value)?.["runId"];
+        if (typeof receipt !== "string")
+            return new Response("invalid-workflow-message", { status: 400 });
+        const run = (await ports.run(receipt)) ??
+            seeded(value) ??
+            (await located(ports, receipt));
+        if (run === undefined)
+            return new Response("unknown-world-run", { status: 503 });
+        const available = await ports.available(run.runId, run.workflowId);
+        if (!(await observedReplay(ports, { runId: run.runId, receipt, available })))
+            return new Response("workflow-observation-unavailable", { status: 503 });
+        if (available)
+            return handler(request, run.runId);
+        return new Response("pinned-workflow-unavailable", { status: 503 });
+    };
+}

package/dist/src/daemon/workflow-schedules.d.ts

@@ -0,0 +1,27 @@
+import type { WorkerPort } from "../service/worker-port.ts";
+import type { DeclaredWorkflow } from "../workflow-declaration.ts";
+interface ScheduleSettings {
+    readonly directory: string;
+    readonly runtimeDirectory: string;
+    readonly declarations?: readonly DeclaredWorkflow[];
+    readonly scheduleClock?: () => number;
+    readonly submit: WorkerPort["submit"];
+}
+export declare function scheduledDeclarations(settings: {
+    readonly declarations?: readonly DeclaredWorkflow[];
+    readonly schedules?: unknown;
+}, limits?: {
+    readonly repository: string;
+    readonly documentBytes: number;
+}): {
+    readonly kind: "configured";
+    readonly declarations: readonly DeclaredWorkflow[];
+} | {
+    readonly kind: "refused";
+    readonly reason: string;
+    readonly detail: string;
+};
+export declare function workflowSchedules(settings: ScheduleSettings): Promise<{
+    readonly stop: () => Promise<void>;
+}>;
+export {};