cloving 1.3.0 → 1.5.0

package/dist/src/host/start-delivery.d.ts

@@ -1,11 +1,9 @@
 import { type TaggedRun } from "./world-runs.ts";
-export type WorkflowFunction = (input: unknown, continuation?: Continuation) => Promise<unknown>;
-export interface Continuation {
-    readonly gateId: string;
-    readonly decision: string;
-    readonly answer: string | null;
-}
-export interface RunIntent extends Partial<Continuation> {
+export type WorkflowFunction = (input: unknown) => Promise<unknown>;
+export interface RunIntent {
+    readonly gateId?: string;
+    readonly decision?: string;
+    readonly answer?: string | null;
     readonly kind: string;
     readonly runId: string;
     readonly operationId: string;

package/dist/src/host/start-delivery.js

@@ -17,27 +17,15 @@ async function reconciled(parts, intent) {
         evidence: found.map((run) => `world-run:${run.receipt}`).join(" "),
     };
 }
-async function continuation(parts, intent) {
-    const { kind, gateId, decision, answer } = intent;
-    if (kind === "start-run")
-        return undefined;
-    if (kind !== "continue-run" || gateId === undefined || decision === undefined)
-        throw new Error(`unsupported-intent: ${kind}`);
-    if (answer === undefined || answer === null)
-        return { gateId, decision, answer: null };
-    const text = await parts.document(answer);
-    if (text === undefined)
-        throw new Error(`answer-not-available: ${gateId}`);
-    return { gateId, decision, answer: text };
-}
 async function delivered(parts, intent) {
-    const continued = await continuation(parts, intent);
+    if (intent.kind !== "start-run")
+        throw new Error(`unsupported-intent: ${intent.kind}`);
     const workflow = await parts.workflow(intent);
     const input = await parts.input(intent.runId);
     if (workflow === undefined || input === undefined)
         throw new Error(`start-not-available: ${intent.runId}`);
     const argument = JSON.parse(input);
-    const started = await start(workflow, [argument, continued], {
+    const started = await start(workflow, [argument], {
         attributes: {
             [runTag]: intent.runId,
             [operationTag]: intent.operationId,

package/dist/src/host/step-bridge-host.d.ts

@@ -1,3 +1,4 @@
+import { type CommandWaitPorts } from "./command-wait.ts";
 import { type GateOpening, type GateReceipt, type WaitRegistration } from "./gate-bridge.ts";
 export type { GateOpening, GateReceipt, WaitRegistration, } from "./gate-bridge.ts";
 import { type RunWaitPorts } from "./run-wait.ts";
@@ -41,6 +42,7 @@ export interface BridgeTiming {
 }
 export declare const bridgeTiming: BridgeTiming;
 export interface BridgePorts {
+    readonly commandWait?: CommandWaitPorts;
     readonly decisionReceived?: (runId: string, gateId: string) => Promise<boolean>;
     readonly runWait?: RunWaitPorts;
     readonly call: () => StepCall;

package/dist/src/host/step-bridge-host.js

@@ -1,3 +1,4 @@
+import { commandWaitBridge } from "./command-wait.js";
 import { createHash } from "node:crypto";
 import { setTimeout as delay } from "node:timers/promises";
 import { getStepMetadata, getWorkflowMetadata } from "workflow";
@@ -155,9 +156,29 @@ async function gate(hold, request) {
         return { kind: "unavailable", reason: "unknown-world-run" };
     return await openBridgeGate(hold.ports, subject);
 }
+function hostCommandWait(hold) {
+    return commandWaitBridge({
+        ...(hold.ports.commandWait === undefined
+            ? {}
+            : { commandWait: hold.ports.commandWait }),
+        stopped: hold.ports.stopped,
+        pollMilliseconds: hold.timing.pollMilliseconds,
+        retryMilliseconds: hold.timing.retryMilliseconds,
+        runStatus: async (runId) => (await hold.ports.state()).runs[runId]?.status,
+        subject: async () => {
+            const call = hold.ports.call();
+            const world = await located(hold, call.worldRunId);
+            if (world === undefined)
+                return undefined;
+            await inWork(hold, world.runId);
+            return { runId: world.runId, commandId: transportOf(call) };
+        },
+    });
+}
 export function stepBridge(ports) {
     const hold = { ports, timing: ports.timing ?? bridgeTiming };
     return {
+        ...hostCommandWait(hold),
         effect: (request) => effect(hold, request),
         gate: (request) => gate(hold, request),
         waitForDecision: async (request) => {

package/dist/src/operation-identity.d.ts

@@ -5,3 +5,4 @@ export interface OperationScope {
     readonly operation: string;
 }
 export declare function operationScope(operationId: string): OperationScope | null;
+export declare function operationPhase(operationId: string): string | null;

package/dist/src/operation-identity.js

@@ -48,6 +48,10 @@ export function operationScope(operationId) {
         return null;
     return { run, operation };
 }
+export function operationPhase(operationId) {
+    const [marker, , , phase] = parsedList(operationId);
+    return marker === "cloving-operation" && isComponent(phase) ? phase : null;
+}
 function parsedList(text) {
     try {
         const value = JSON.parse(text);

package/dist/src/private-config.schema.json

@@ -19,6 +19,42 @@
                         "type": "string",
                         "pattern": "\\S"
                     }
+                },
+                "redGreen": {
+                    "type": "object",
+                    "properties": {
+                        "test": {
+                            "type": "array",
+                            "minItems": 1,
+                            "items": {
+                                "type": "string",
+                                "pattern": "^[^\\u0000]+$"
+                            }
+                        },
+                        "testFiles": {
+                            "type": "array",
+                            "items": {
+                                "type": "string",
+                                "pattern": "^[^\\u0000]+$"
+                            }
+                        },
+                        "prepare": {
+                            "type": "array",
+                            "minItems": 1,
+                            "items": {
+                                "type": "string",
+                                "pattern": "^[^\\u0000]+$"
+                            }
+                        },
+                        "assertionPattern": {
+                            "type": "string"
+                        },
+                        "skipPattern": {
+                            "type": "string"
+                        }
+                    },
+                    "required": ["test", "testFiles"],
+                    "additionalProperties": false
                 }
             },
             "additionalProperties": false
@@ -49,6 +85,10 @@
                     "minimum": 10,
                     "maximum": 3600
                 },
+                "dailySpendLimitUsd": {
+                    "type": "number",
+                    "exclusiveMinimum": 0
+                },
                 "lanes": {
                     "type": "integer",
                     "minimum": 1,
@@ -254,6 +294,37 @@
                 }
             },
             "additionalProperties": false
+        },
+        "retention": {
+            "type": "object",
+            "properties": {
+                "days": {
+                    "anyOf": [
+                        {
+                            "type": "integer",
+                            "minimum": 1
+                        },
+                        {
+                            "const": null
+                        }
+                    ]
+                },
+                "action": {
+                    "enum": ["archive", "delete"]
+                },
+                "archiveFolder": {
+                    "anyOf": [
+                        {
+                            "type": "string",
+                            "pattern": "^/"
+                        },
+                        {
+                            "const": null
+                        }
+                    ]
+                }
+            },
+            "additionalProperties": false
         }
     },
     "additionalProperties": false,

package/dist/src/project-config.schema.json

@@ -19,6 +19,42 @@
                         "type": "string",
                         "pattern": "\\S"
                     }
+                },
+                "redGreen": {
+                    "type": "object",
+                    "properties": {
+                        "test": {
+                            "type": "array",
+                            "minItems": 1,
+                            "items": {
+                                "type": "string",
+                                "pattern": "^[^\\u0000]+$"
+                            }
+                        },
+                        "testFiles": {
+                            "type": "array",
+                            "items": {
+                                "type": "string",
+                                "pattern": "^[^\\u0000]+$"
+                            }
+                        },
+                        "prepare": {
+                            "type": "array",
+                            "minItems": 1,
+                            "items": {
+                                "type": "string",
+                                "pattern": "^[^\\u0000]+$"
+                            }
+                        },
+                        "assertionPattern": {
+                            "type": "string"
+                        },
+                        "skipPattern": {
+                            "type": "string"
+                        }
+                    },
+                    "required": ["test", "testFiles"],
+                    "additionalProperties": false
                 }
             },
             "additionalProperties": false
@@ -49,6 +85,10 @@
                     "minimum": 10,
                     "maximum": 3600
                 },
+                "dailySpendLimitUsd": {
+                    "type": "number",
+                    "exclusiveMinimum": 0
+                },
                 "lanes": {
                     "type": "integer",
                     "minimum": 1,

package/dist/src/project-settings.d.ts

@@ -1,8 +1,14 @@
-import { type Configuration } from "./configuration-schema.ts";
+import { type Configuration, type RedGreenSettings } from "./configuration-schema.ts";
 import type { TurnProfiles } from "./turn-profile.ts";
 import type { TokenPrices } from "./token-prices.ts";
 export type SettingSource = "environment" | "private" | "project";
-export type SettingValue = string | number | readonly string[] | TurnProfiles | TokenPrices;
+export declare const reloadedSettingFields: readonly string[];
+export interface TurnSettings {
+    readonly profiles: TurnProfiles;
+    readonly fallbackModels: readonly string[];
+    readonly tokenPrices: TokenPrices;
+}
+export type SettingValue = null | string | number | readonly string[] | TurnProfiles | TokenPrices | RedGreenSettings;
 export declare const settingVariables: Readonly<Record<string, string>>;
 export declare function absoluteWorkflowFolder(folder: string | undefined): string | undefined;
 export declare function configurationRoot(environment: Readonly<NodeJS.ProcessEnv>, home: string): string;
@@ -16,4 +22,12 @@ export declare function resolveSettings(environment: Readonly<NodeJS.ProcessEnv>
     readonly profiles: TurnProfiles;
     readonly harness?: Configuration["harness"];
     readonly sources: Readonly<Record<string, SettingSource>>;
+    readonly values: Readonly<Record<string, SettingValue>>;
 };
+interface ResolvedFields {
+    readonly environment: Readonly<NodeJS.ProcessEnv>;
+    readonly values: Readonly<Record<string, SettingValue>>;
+    readonly profiles: TurnProfiles;
+}
+export declare function settingDigests(resolved: ResolvedFields, digest: (text: string) => string): Readonly<Record<string, string>>;
+export {};

package/dist/src/project-settings.js

@@ -1,11 +1,19 @@
-import { configuration } from "./configuration-schema.js";
+import { configuration, settingFields, } from "./configuration-schema.js";
+export const reloadedSettingFields = [
+    "fallbackModels",
+    "profiles",
+    "tokenPrices",
+    "workflows.folder",
+];
 export const settingVariables = {
     "checks.beforeMerge": "CLOVING_CHECK_COMMAND",
     "checks.required": "CLOVING_REQUIRED_CHECKS",
+    "checks.redGreen": "CLOVING_RED_GREEN",
     "tickets.command": "CLOVING_TICKET_COMMAND",
     "tickets.nextCommand": "CLOVING_NEXT_COMMAND",
     "queue.everySeconds": "CLOVING_QUEUE_SECONDS",
     "queue.lanes": "CLOVING_QUEUE_LANES",
+    "queue.dailySpendLimitUsd": "CLOVING_QUEUE_DAILY_SPEND_USD",
     "harness.name": "CLOVING_WORKER",
     fallbackModels: "CLOVING_FALLBACK_MODELS",
     tokenPrices: "CLOVING_TOKEN_PRICES",
@@ -16,6 +24,9 @@ export const settingVariables = {
     "selfUpdate.everySeconds": "CLOVING_SELF_UPDATE_SECONDS",
     "github.command": "CLOVING_GH_COMMAND",
     "workflows.folder": "CLOVING_WORKFLOW_FOLDER",
+    "retention.days": "CLOVING_RETENTION_DAYS",
+    "retention.action": "CLOVING_RETENTION_ACTION",
+    "retention.archiveFolder": "CLOVING_RETENTION_ARCHIVE_FOLDER",
 };
 const environmentOnly = [
     "CLOVING_RUNTIME_DIR",
@@ -63,6 +74,7 @@ export function configurationValues(values) {
         selfUpdate: values.selfUpdate,
         github: values.github,
         workflows: values.workflows,
+        retention: values.retention,
     };
     for (const [name, group] of Object.entries(groups)) {
         if (group === undefined)
@@ -124,8 +136,30 @@ export function resolveSettings(environment, files) {
         environment: resolved,
         profiles,
         sources,
+        values,
         ...(privateConfiguration.harness === undefined
             ? {}
             : { harness: privateConfiguration.harness }),
     };
 }
+function resolvedValue(resolved, field) {
+    if (field === "profiles")
+        return resolved.profiles;
+    const variable = resolved.variables[field];
+    return variable === undefined
+        ? resolved.values[field]
+        : resolved.environment[variable];
+}
+export function settingDigests(resolved, digest) {
+    const fields = {
+        ...resolved,
+        variables: {
+            ...settingVariables,
+            ...harnessCommandMapping(resolved.values["harness.name"]),
+        },
+    };
+    return Object.fromEntries(settingFields().map((field) => [
+        field,
+        digest(JSON.stringify(resolvedValue(fields, field) ?? null)),
+    ]));
+}

package/dist/src/queue-spend.d.ts

@@ -0,0 +1,4 @@
+export declare function queueSpending(costs: readonly number[], limitUsd: number): {
+    readonly spentUsd: number;
+    readonly holding: boolean;
+};

package/dist/src/queue-spend.js

@@ -0,0 +1,21 @@
+function decimal(value) {
+    const [mantissa = "0", exponent = "0"] = String(value).split("e");
+    const fraction = mantissa.split(".")[1]?.length ?? 0;
+    return {
+        units: BigInt(mantissa.replace(".", "")),
+        exponent: Number(exponent) - fraction,
+    };
+}
+function scaled(value, exponent) {
+    return value.units * 10n ** BigInt(value.exponent - exponent);
+}
+export function queueSpending(costs, limitUsd) {
+    const prices = costs.map(decimal);
+    const limit = decimal(limitUsd);
+    const exponent = prices.reduce((smallest, price) => Math.min(smallest, price.exponent), limit.exponent);
+    const total = prices.reduce((sum, price) => sum + scaled(price, exponent), 0n);
+    return {
+        spentUsd: Number(`${String(total)}e${String(exponent)}`),
+        holding: total * 100n >= scaled(limit, exponent) * 85n,
+    };
+}

package/dist/src/queue-state.d.ts

@@ -0,0 +1,26 @@
+import type { Fields } from "./protocol.ts";
+export declare const queueFailureLimit = 3;
+export interface QueueDrain {
+    readonly startedAt: number;
+    readonly drainedAt: number | null;
+}
+export interface QueueControl {
+    readonly failedRunIds: readonly string[];
+    readonly drain: QueueDrain | undefined;
+    readonly error: string | undefined;
+}
+export type QueueCommand = "resume" | "drain";
+export type QueueChange = {
+    readonly kind: "changed" | "replayed" | "conflicting-command";
+} | {
+    readonly kind: "unavailable";
+    readonly detail: string;
+};
+export interface QueuePort {
+    readonly control: () => QueueControl | undefined;
+    readonly change: (request: {
+        readonly command: QueueCommand;
+        readonly commandId: string;
+    }) => Promise<QueueChange>;
+}
+export declare function queueStateFields(control: QueueControl, busy: number): Fields;

package/dist/src/queue-state.js

@@ -0,0 +1,34 @@
+export const queueFailureLimit = 3;
+function stopReason(control) {
+    if (control.error !== undefined)
+        return control.error;
+    if (control.failedRunIds.length >= queueFailureLimit)
+        return "failure-limit";
+    return undefined;
+}
+function drainState(drain, busy) {
+    return drain.drainedAt === null || busy > 0 ? "draining" : "drained";
+}
+function stateName(control, busy) {
+    if (control.error !== undefined)
+        return "stopped";
+    if (control.drain !== undefined)
+        return drainState(control.drain, busy);
+    if (stopReason(control) !== undefined)
+        return "stopped";
+    return "running";
+}
+export function queueStateFields(control, busy) {
+    const reason = stopReason(control);
+    return {
+        state: stateName(control, busy),
+        stop: reason === undefined ? null : { reason },
+        failedRunIds: [...control.failedRunIds],
+        drain: control.drain === undefined
+            ? null
+            : {
+                startedAt: control.drain.startedAt,
+                drainedAt: control.drain.drainedAt,
+            },
+    };
+}

package/dist/src/record-retention.d.ts

@@ -0,0 +1,46 @@
+export interface StoredRun {
+    readonly status: string;
+    readonly endedAt: number | null;
+}
+export interface RecordFolder {
+    readonly started: unknown;
+    readonly changedAt: number;
+}
+export interface RetentionContext {
+    readonly runs: Readonly<Record<string, StoredRun>>;
+    readonly now: number;
+    readonly days: number;
+}
+export type RetentionVerdict = "due" | "kept" | "skipped" | "unreadable";
+export interface RetentionSettings {
+    readonly days: number | null;
+    readonly action: "archive" | "delete";
+    readonly archiveFolder: string | null;
+}
+export interface RunTurns {
+    readonly runId: string;
+    readonly operationIds: readonly string[];
+}
+export type TurnDetails = {
+    readonly state: "archived";
+    readonly folder: string;
+} | {
+    readonly state: "deleted";
+};
+export interface TurnFolders {
+    readonly turns: number;
+    readonly kept: number;
+    readonly archived: string | undefined;
+}
+export declare const sharedRecordFolders: readonly string[];
+export declare const defaultRetention: RetentionSettings;
+type Variables = Readonly<Record<string, string | undefined>>;
+export declare function folderRunId(started: unknown): string | undefined;
+export declare function retentionVerdict(folder: RecordFolder, context: RetentionContext): RetentionVerdict;
+export declare function turnDetails(found: TurnFolders, context: {
+    readonly run: StoredRun | undefined;
+    readonly retention: RetentionSettings;
+    readonly now: number;
+}): TurnDetails | undefined;
+export declare function retentionSettings(variables: Variables): RetentionSettings;
+export {};

package/dist/src/record-retention.js

@@ -0,0 +1,81 @@
+import { operationScope } from "./operation-identity.js";
+export const sharedRecordFolders = [
+    "journal/runs",
+    "journal/targets",
+];
+export const defaultRetention = {
+    days: 30,
+    action: "archive",
+    archiveFolder: null,
+};
+const dayMilliseconds = 86_400_000;
+const finished = ["completed", "failed", "cancelled"];
+export function folderRunId(started) {
+    if (typeof started !== "object" || started === null)
+        return undefined;
+    if ("runId" in started && typeof started.runId === "string")
+        return started.runId;
+    if (!("operationId" in started) || typeof started.operationId !== "string")
+        return undefined;
+    return operationScope(started.operationId)?.run;
+}
+export function retentionVerdict(folder, context) {
+    const runId = folderRunId(folder.started);
+    const run = runId !== undefined && Object.hasOwn(context.runs, runId)
+        ? context.runs[runId]
+        : undefined;
+    if (run === undefined)
+        return "unreadable";
+    if (!finished.includes(run.status))
+        return "skipped";
+    const limit = context.now - context.days * dayMilliseconds;
+    return endedBefore(run, limit) && folder.changedAt < limit ? "due" : "kept";
+}
+function endedBefore(run, limit) {
+    return finished.includes(run.status) && (run.endedAt ?? Number.NaN) < limit;
+}
+export function turnDetails(found, context) {
+    if (found.archived !== undefined)
+        return { state: "archived", folder: found.archived };
+    const { run, retention } = context;
+    if (found.turns === 0 || found.kept > 0 || run === undefined)
+        return undefined;
+    if (retention.action !== "delete" || retention.days === null)
+        return undefined;
+    const limit = context.now - retention.days * dayMilliseconds;
+    return endedBefore(run, limit) ? { state: "deleted" } : undefined;
+}
+function refused(variable, expected) {
+    throw new Error(`invalid-setting: ${variable} must be ${expected}`);
+}
+function retentionDays(value) {
+    if (value === undefined)
+        return defaultRetention.days;
+    if (value === "null")
+        return null;
+    const days = Number(value);
+    if (/^[1-9][0-9]*$/.test(value) && Number.isSafeInteger(days))
+        return days;
+    return refused("CLOVING_RETENTION_DAYS", "a whole number of at least 1 or null");
+}
+function retentionAction(value) {
+    if (value === undefined)
+        return defaultRetention.action;
+    if (value === "archive" || value === "delete")
+        return value;
+    return refused("CLOVING_RETENTION_ACTION", "archive or delete");
+}
+function archiveFolder(value) {
+    if (value === undefined || value === "null")
+        return null;
+    if (value.startsWith("/"))
+        return value;
+    return refused("CLOVING_RETENTION_ARCHIVE_FOLDER", "an absolute path or null");
+}
+export function retentionSettings(variables) {
+    return {
+        days: retentionDays(variables["CLOVING_RETENTION_DAYS"]),
+        action: retentionAction(variables["CLOVING_RETENTION_ACTION"]),
+        archiveFolder: archiveFolder(variables["CLOVING_RETENTION_ARCHIVE_FOLDER"]),
+    };
+}

package/dist/src/relay/relay-service.d.ts

@@ -1,5 +1,7 @@
+import type { Reply } from "../protocol.ts";
 import { type InboxTiming } from "./answer-inbox.ts";
 import { type WatchTiming } from "./decision-watch.ts";
+import { type OperationState } from "./phone-operations.ts";
 import { type HeartbeatTiming } from "./relay-heartbeat.ts";
 export interface RelayPaths {
     readonly runtimeDirectory: string;
@@ -16,6 +18,7 @@ export interface RelayOptions extends RelayPaths {
 export interface Relay {
     readonly close: () => Promise<void>;
 }
+export declare function phoneState(relay: OperationState): Promise<Reply>;
 export declare function computerName(name: string): string;
 export declare function startRelay(options: RelayOptions): Promise<Relay>;
 export interface RelayProgram {

package/dist/src/relay/relay-service.js

@@ -41,15 +41,17 @@ function pairingView(open) {
             },
     };
 }
-async function phoneState(relay) {
-    const link = await readLink(relay.context.phoneDirectory);
+export async function phoneState(relay) {
+    const stored = await readLink(relay.context.phoneDirectory);
+    const lost = relay.registration.lost;
+    const link = lost ? undefined : stored;
     return result({
         registered: link !== undefined,
         daemonId: link?.daemonId ?? null,
         origin: link?.origin ?? null,
         pairing: pairingView(relay.sessions.current()),
         refusal: relay.sessions.refusal(),
-        reason: relay.registration.lost ? "registration-lost" : null,
+        reason: lost ? "registration-lost" : null,
         devices: (await relay.store.devices()).map((device) => ({
             deviceId: device.deviceId,
             name: device.name,