cloving 1.3.0 → 1.5.0

package/dist/src/cli/report-text.js

@@ -0,0 +1,33 @@
+function isMetric(value) {
+    return typeof value["status"] === "string";
+}
+function sectionMetrics(section, prefix) {
+    return Object.fromEntries(Object.entries(section).flatMap(([name, value]) => isMetric(value)
+        ? [[`${prefix}.${name}`, value]]
+        : Object.entries(value).map(([key, metric]) => [`${prefix}.${name}.${key}`, metric])));
+}
+export function textReport(report) {
+    const lines = [`Loop report ${JSON.stringify(report.window)}`];
+    const { jobLogs, ...quality } = report.quality;
+    const metrics = {
+        ...report.metrics,
+        ...sectionMetrics(quality, "quality"),
+        ...sectionMetrics(report.ci, "ci"),
+        ...sectionMetrics(report.operator, "operator"),
+    };
+    for (const [name, metric] of Object.entries(metrics)) {
+        lines.push(`${name}: ${metric.status === "unavailable" ? "unavailable" : String(metric.value)}`);
+        const baseline = metric.baseline;
+        lines.push(`  history: ${baseline.history}; median: ${String(baseline.median)}; band: ${JSON.stringify(baseline.band)}${metric.mark === "outside" ? "; outside" : ""}`);
+        lines.push(`  comparison value: ${String(metric.comparisonValue)}`);
+        lines.push(`  evidence: ${JSON.stringify(metric.evidence)}`);
+        lines.push(`  baseline evidence: ${JSON.stringify(baseline.evidence)}`);
+    }
+    lines.push(`Quality job logs: ${JSON.stringify(jobLogs)}`);
+    lines.push(`Run costs (USD): ${JSON.stringify(report.runCosts)}`);
+    lines.push(`Completed ticket costs (USD): ${JSON.stringify(report.completedTicketCosts)}`);
+    lines.push(`Semantics: ${JSON.stringify(report.semantics)}`);
+    lines.push(`Sources: ${JSON.stringify(report.sources)}`);
+    lines.push(`Coverage: ${JSON.stringify(report.coverage)}`);
+    return lines.join("\n") + "\n";
+}

package/dist/src/cli/report.d.ts

@@ -2,6 +2,7 @@ import { type Fields } from "../protocol.ts";
 import { type ReportCompletion } from "../report.ts";
 import type { WatchPrSettings } from "./watch-pr-settings.ts";
 interface ReportEnvironment {
+    readonly now?: number;
     readonly runtimeDirectory: string;
     readonly workingDirectory: string;
     readonly watchPr?: WatchPrSettings;

package/dist/src/cli/report.js

@@ -1,6 +1,8 @@
+import { textReport } from "./report-text.js";
 import { record } from "../protocol.js";
 import { loopReport, } from "../report.js";
 import { send } from "./client.js";
+import { readReportFlow } from "./report-flow.js";
 import { readReportGithub } from "./report-github.js";
 function reportRecord(value, after) {
     const event = record(value) ?? {};
@@ -22,6 +24,10 @@ function appendEvents(snapshot, values) {
         snapshot.after = parsed.sequence;
         if (snapshot.observedSince === null || parsed.at < snapshot.observedSince)
             snapshot.observedSince = parsed.at;
+        if (["effect.requested", "effect.reported"].includes(String(parsed.event["type"])))
+            snapshot.effects.push({ ...parsed.event, at: parsed.at });
+        if (["run.started", "schedule.skipped"].includes(String(parsed.event["type"])))
+            snapshot.flowEvents.push(parsed.event);
         const completion = reportCompletion(parsed.event);
         if (completion === null)
             continue;
@@ -36,6 +42,8 @@ async function daemonReport(runtime) {
         latest: null,
         observedSince: null,
         completions: new Map(),
+        effects: [],
+        flowEvents: [],
     };
     for (;;) {
         const reply = await send(runtime, {
@@ -57,6 +65,8 @@ async function daemonReport(runtime) {
         if (snapshot.after >= snapshot.latest)
             return {
                 completions: [...snapshot.completions.values()],
+                effects: snapshot.effects,
+                flowEvents: snapshot.flowEvents,
                 observedSince: snapshot.observedSince,
             };
         if (events.length < 1000)
@@ -78,11 +88,12 @@ async function runCost(runtime, runId) {
     if (reply.kind === "error")
         return { runId, turns: null };
     const run = record(reply.result["run"]);
-    const turns = run?.["workerTurns"];
-    if (run?.["runId"] !== runId ||
-        !Array.isArray(turns) ||
-        !settledSpending(run))
+    if (run?.["runId"] !== runId)
         return { runId, turns: null };
+    const turns = run["workerTurns"];
+    const ticket = runTicket(run);
+    if (!Array.isArray(turns) || !settledSpending(run))
+        return { runId, ...ticket, turns: null };
     const parsed = turns.map((value) => {
         const turn = record(value);
         const operationId = turn?.["operationId"];
@@ -97,29 +108,14 @@ async function runCost(runtime, runId) {
     });
     return {
         runId,
+        ...ticket,
         turns: parsed.some((turn) => turn === null)
             ? null
             : parsed.filter((turn) => turn !== null),
     };
 }
-function textReport(report) {
-    const lines = [`Loop report ${JSON.stringify(report["window"])}`];
-    for (const [name, value] of Object.entries(record(report["metrics"]) ?? {})) {
-        const metric = record(value) ?? {};
-        lines.push(`${name}: ${metric["status"] === "unavailable" ? "unavailable" : String(metric["value"])}`);
-        const baseline = record(metric["baseline"]) ?? {};
-        lines.push(`  history: ${String(baseline["history"])}; median: ${String(baseline["median"])}; band: ${JSON.stringify(baseline["band"])}${metric["mark"] === "outside" ? "; outside" : ""}`);
-        lines.push(`  comparison value: ${String(metric["comparisonValue"])}`);
-        lines.push(`  evidence: ${JSON.stringify(metric["evidence"])}`);
-        lines.push(`  baseline evidence: ${JSON.stringify(baseline["evidence"])}`);
-    }
-    lines.push(`Run costs (USD): ${JSON.stringify(report["runCosts"])}`);
-    lines.push(`Sources: ${JSON.stringify(report["sources"])}`);
-    lines.push(`Coverage: ${JSON.stringify(report["coverage"])}`);
-    return lines.join("\n") + "\n";
-}
 export async function reportCommand(invocation, environment) {
-    const now = Date.now();
+    const now = environment.now ?? Date.now();
     const since = new Date(now - (invocation.since + 168) * 3_600_000).toISOString();
     const settings = environment.watchPr === undefined ? {} : { settings: environment.watchPr };
     const [daemonRead, githubRead] = await Promise.allSettled([
@@ -128,14 +124,25 @@ export async function reportCommand(invocation, environment) {
     ]);
     const daemon = daemonRead.status === "fulfilled"
         ? daemonRead.value
-        : { completions: null, observedSince: null };
+        : {
+            completions: null,
+            effects: null,
+            flowEvents: null,
+            observedSince: null,
+        };
     const github = githubRead.status === "fulfilled" ? { github: githubRead.value } : {};
-    const costs = [];
-    for (const event of daemon.completions ?? [])
-        if (event.at >= now - (invocation.since + 168) * 3_600_000 &&
-            event.at < now)
-            costs.push(await runCost(environment.runtimeDirectory, event.runId));
+    const costs = await reportCosts(environment.runtimeDirectory, {
+        completions: daemon.completions ?? [],
+        start: Date.parse(since),
+        end: now,
+        issues: githubRead.status === "fulfilled" ? githubRead.value.issues : null,
+    });
     const calculated = loopReport({
+        flow: await readReportFlow(environment.runtimeDirectory, {
+            events: daemon.flowEvents,
+            start: Date.parse(since),
+            completions: daemon.completions,
+        }),
         since: invocation.since,
         now,
         ...daemon,
@@ -190,3 +197,73 @@ export function reportCompletion(event) {
         throw new Error("invalid-report-event");
     return { runId, sequence, at: Date.parse(at), outcome };
 }
+function runTicket(run) {
+    const ticketId = run?.["ticketId"];
+    return ticketId === null || (typeof ticketId === "string" && ticketId !== "")
+        ? { ticketId }
+        : {};
+}
+async function ticketIndex(runtime) {
+    const index = new Map();
+    let after = "";
+    for (;;) {
+        const reply = await send(runtime, {
+            operation: "status",
+            parameters: { metadata: "tickets", after, limit: 500 },
+        });
+        if (reply.kind === "error")
+            throw new Error(reply.error.code);
+        const runs = reply.result["runs"];
+        if (!Array.isArray(runs))
+            throw new Error("invalid-report-ticket-index");
+        const latest = appendTicketIndex(index, { runs, after });
+        const next = reply.result["next"];
+        if (next === null)
+            return index;
+        if (typeof next !== "string" || next !== latest || next <= after)
+            throw new Error("invalid-report-ticket-cursor");
+        after = next;
+    }
+}
+async function reportCosts(runtime, input) {
+    const ended = input.completions.filter((event) => event.at < input.end);
+    const costs = [];
+    for (const event of ended.filter((event) => event.at >= input.start))
+        costs.push(await runCost(runtime, event.runId));
+    const older = ended.filter((event) => event.at < input.start);
+    const tickets = new Set((input.issues ?? [])
+        .filter((issue) => issue.at >= input.start && issue.at < input.end)
+        .map((issue) => String(issue.evidence["issue"])));
+    if (older.length === 0 || tickets.size === 0)
+        return costs;
+    try {
+        const index = await ticketIndex(runtime);
+        for (const event of older) {
+            const ticketId = index.get(event.runId);
+            if (ticketId === undefined)
+                continue;
+            costs.push(ticketId !== null && tickets.has(ticketId)
+                ? await runCost(runtime, event.runId)
+                : { runId: event.runId, ticketId, turns: null });
+        }
+    }
+    catch {
+        return costs;
+    }
+    return costs;
+}
+function appendTicketIndex(index, page) {
+    let latest = page.after;
+    for (const value of page.runs) {
+        const row = record(value);
+        const runId = row?.["runId"];
+        const ticketId = row?.["ticketId"];
+        if (typeof runId !== "string" ||
+            runId <= latest ||
+            !(ticketId === null || (typeof ticketId === "string" && ticketId !== "")))
+            throw new Error("invalid-report-ticket-index");
+        index.set(runId, ticketId);
+        latest = runId;
+    }
+    return latest;
+}

package/dist/src/cli/runtime-arguments.d.ts

@@ -1,3 +1,5 @@
+import { type ScheduleInvocation } from "./schedule-arguments.ts";
+import { type QueueInvocation } from "./queue-arguments.ts";
 export type RunSource = {
     readonly kind: "prompt";
     readonly text: string;
@@ -8,12 +10,15 @@ export type RunSource = {
     readonly kind: "input";
     readonly file: string;
 };
-type DecisionCommand = "answer" | "approve" | "deny";
-type RunCommand = "pause" | "resume" | "drop";
-export type RuntimeInvocation = {
+export type DecisionCommand = "answer" | "approve" | "deny";
+export type RunCommand = "pause" | "resume" | "drop";
+export type RuntimeInvocation = ScheduleInvocation | QueueInvocation | {
     readonly kind: "report";
     readonly since: number;
     readonly json: boolean;
+} | {
+    readonly kind: "reload";
+    readonly json: boolean;
 } | {
     readonly kind: "command-help";
     readonly command: string;
@@ -28,6 +33,7 @@ export type RuntimeInvocation = {
     readonly runId: string | null;
     readonly limit: number | null;
     readonly after: string | null;
+    readonly active: boolean;
     readonly json: boolean;
 } | {
     readonly kind: "questions";
@@ -72,6 +78,15 @@ export interface RuntimeRequest {
     readonly options: readonly GivenOption[];
 }
 type Outcome = RuntimeInvocation | string;
+export declare const argumentRules: {
+    identifier: RegExp;
+    decisionReference: RegExp;
+    sha256Digest: RegExp;
+    revisions: {
+        minimum: number;
+        maximum: number;
+    };
+};
 export declare function isRuntimeCommand(command: string): boolean;
 export declare function runtimeInvocation(request: RuntimeRequest): Outcome;
 export {};

package/dist/src/cli/runtime-arguments.js

@@ -1,4 +1,6 @@
 import { isRecordKey } from "../authority/commands.js";
+import { scheduleInvocation, } from "./schedule-arguments.js";
+import { queueInvocation } from "./queue-arguments.js";
 const identifier = /^[A-Za-z0-9._:/-]{1,128}$/;
 const decisionReference = /^[A-Za-z0-9._:/-]{1,256}$/;
 const sha256Digest = /^sha256:[0-9a-f]{64}$/;
@@ -8,6 +10,12 @@ const revisions = { minimum: 1, maximum: Number.MAX_SAFE_INTEGER };
 const sequences = { minimum: 0, maximum: Number.MAX_SAFE_INTEGER };
 const bindingOptions = ["expected-revision", "generation", "subject-digest"];
 const mutationOptions = ["command-id", "json"];
+export const argumentRules = {
+    identifier,
+    decisionReference,
+    sha256Digest,
+    revisions,
+};
 const shapes = new Map([
     [
         "run",
@@ -51,37 +59,37 @@ const shapes = new Map([
             build: events,
         },
     ],
+    ["report", noSubjectShape(["since", "json"], report)],
     [
-        "report",
-        {
-            subject: "none",
-            required: [],
-            allowed: () => ["since", "json"],
-            build: report,
-        },
-    ],
-    [
-        "watch",
-        {
-            subject: "none",
-            required: [],
-            allowed: () => ["port"],
-            build: watch,
-        },
+        "reload",
+        noSubjectShape(["json"], (request) => ({
+            kind: "reload",
+            json: given(request, "json"),
+        })),
     ],
+    ["watch", noSubjectShape(["port"], watch)],
 ]);
+function noSubjectShape(allowed, build) {
+    return { subject: "none", required: [], allowed: () => allowed, build };
+}
 export function isRuntimeCommand(command) {
-    return shapes.has(command);
+    return command === "schedule" || command === "queue" || shapes.has(command);
 }
 export function runtimeInvocation(request) {
     const shape = shapes.get(request.command);
-    if (shape === undefined)
+    if (!isRuntimeCommand(request.command))
         return "unknown-command";
     const names = request.options.map((option) => option.name);
     if (new Set(names).size !== names.length)
         return "repeated-option";
     if (names.includes("help"))
         return { kind: "command-help", command: request.command };
+    if (request.command === "schedule")
+        return scheduleInvocation(request);
+    if (request.command === "queue")
+        return queueInvocation(request);
+    if (shape === undefined)
+        return "unknown-command";
     return shapeFailure(shape, request) ?? shape.build(request);
 }
 function shapeFailure(shape, request) {
@@ -118,7 +126,7 @@ function runCommandShape(command) {
 }
 function statusOptions(request) {
     return request.positionals.length === 0
-        ? ["limit", "after", "json"]
+        ? ["active", "limit", "after", "json"]
         : ["json"];
 }
 function eventOptions(request) {
@@ -192,8 +200,9 @@ function status(request) {
     const after = matching(valueOf(request, "after"), identifier);
     if (runId === invalid || limit === invalid || after === invalid)
         return "invalid-option-value";
+    const active = given(request, "active");
     const json = given(request, "json");
-    return { kind: "status", runId, limit, after, json };
+    return { kind: "status", runId, limit, after, active, json };
 }
 function watch(request) {
     const port = whole(valueOf(request, "port"), { minimum: 0, maximum: 65535 });

package/dist/src/cli/schedule-arguments.d.ts

@@ -0,0 +1,14 @@
+import type { ServiceRequest } from "../protocol.ts";
+export interface ScheduleInvocation {
+    readonly kind: "schedule";
+    readonly action: "list" | "pause" | "resume";
+    readonly workflowId: string | null;
+    readonly json: boolean;
+}
+export declare function scheduleInvocation(request: {
+    readonly positionals: readonly string[];
+    readonly options: readonly {
+        readonly name: string;
+    }[];
+}): ScheduleInvocation | string;
+export declare function scheduleServiceRequest(invocation: ScheduleInvocation): ServiceRequest;

package/dist/src/cli/schedule-arguments.js

@@ -0,0 +1,26 @@
+import { isRecordKey } from "../authority/commands.js";
+export function scheduleInvocation(request) {
+    if (request.options.some((option) => option.name !== "json"))
+        return "unexpected-option";
+    const [action, workflowId] = request.positionals;
+    const json = request.options.some((option) => option.name === "json");
+    if (action === undefined)
+        return { kind: "schedule", action: "list", workflowId: null, json };
+    if (action !== "pause" && action !== "resume")
+        return "invalid-schedule-action";
+    if (workflowId === undefined)
+        return "missing-argument";
+    if (request.positionals.length > 2)
+        return "unexpected-argument";
+    if (!isRecordKey(workflowId))
+        return "invalid-option-value";
+    return { kind: "schedule", action, workflowId, json };
+}
+export function scheduleServiceRequest(invocation) {
+    return {
+        operation: "schedule",
+        parameters: invocation.workflowId === null
+            ? { action: invocation.action }
+            : { action: invocation.action, workflowId: invocation.workflowId },
+    };
+}

package/dist/src/cli/schedule-render.d.ts

@@ -0,0 +1,22 @@
+import { type Fields } from "../protocol.ts";
+export declare function scheduleLines(result: Fields): readonly string[];
+export interface ShownSchedule {
+    readonly workflowId: string;
+    readonly everySeconds: number;
+    readonly state: "active" | "paused" | "stopped";
+    readonly failuresInRow: number;
+    readonly nextAt: number | null;
+    readonly stoppedAt: number | null;
+}
+export declare function scheduleStatusLine(schedule: ShownSchedule, style?: "status" | "watch"): string;
+export type ShownSchedules = readonly ShownSchedule[] | {
+    readonly status: "unavailable";
+};
+export declare function shownSchedules(value: unknown): ShownSchedules;
+export declare function statusScheduleLines(value: unknown): readonly string[];
+export declare function shownScheduled(value: unknown): {
+    readonly scheduled?: {
+        readonly slot: number;
+    };
+};
+export declare function scheduledText(value: unknown): string;

package/dist/src/cli/schedule-render.js

@@ -0,0 +1,73 @@
+import { record } from "../protocol.js";
+function line(value) {
+    const schedule = record(value) ?? {};
+    const nextAt = schedule["nextAt"];
+    const runId = schedule["activeRunId"];
+    const activeRun = typeof runId === "string" ? runId : "none";
+    const next = typeof nextAt === "number" ? new Date(nextAt).toISOString() : "none";
+    return `  ${String(schedule["workflowId"])}  every ${String(schedule["everySeconds"])} seconds  ${String(schedule["state"])}  next ${next}  ${String(schedule["failuresInRow"])} failures in a row  slot ${String(schedule["lastSlot"])}  active run ${activeRun}`;
+}
+export function scheduleLines(result) {
+    if (result["kind"] === "schedule")
+        return [line(result["schedule"])];
+    const schedules = result["schedules"];
+    const lines = Array.isArray(schedules) ? schedules.map(line) : [];
+    return ["Schedules:", ...(lines.length === 0 ? ["  none"] : lines)];
+}
+export function scheduleStatusLine(schedule, style = "status") {
+    const time = (at) => style === "watch"
+        ? new Date(at).toLocaleString()
+        : new Date(at).toISOString();
+    const next = schedule.state === "active" && schedule.nextAt !== null
+        ? `, next run at ${time(schedule.nextAt)}`
+        : "";
+    const stopped = schedule.state === "stopped" && schedule.stoppedAt !== null
+        ? `, stopped at ${time(schedule.stoppedAt)}`
+        : "";
+    return `Schedule ${schedule.workflowId}: every ${String(schedule.everySeconds)} s, ${schedule.state}${next}${stopped}, ${String(schedule.failuresInRow)} failures in a row`;
+}
+export function shownSchedules(value) {
+    if (record(value)?.["status"] === "unavailable")
+        return { status: "unavailable" };
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        const schedule = record(entry);
+        if (typeof schedule?.["workflowId"] !== "string" ||
+            typeof schedule["everySeconds"] !== "number" ||
+            typeof schedule["failuresInRow"] !== "number")
+            return [];
+        const state = schedule["state"];
+        if (state !== "active" && state !== "paused" && state !== "stopped")
+            return [];
+        const stamp = (value) => typeof value === "number" && Number.isFinite(new Date(value).getTime())
+            ? value
+            : null;
+        return [
+            {
+                workflowId: schedule["workflowId"],
+                everySeconds: schedule["everySeconds"],
+                state,
+                failuresInRow: schedule["failuresInRow"],
+                nextAt: stamp(schedule["nextAt"]),
+                stoppedAt: stamp(schedule["stoppedAt"]),
+            },
+        ];
+    });
+}
+export function statusScheduleLines(value) {
+    const schedules = shownSchedules(value);
+    return "status" in schedules
+        ? ["Schedules: unavailable"]
+        : schedules.map((schedule) => scheduleStatusLine(schedule));
+}
+export function shownScheduled(value) {
+    const slot = record(value)?.["slot"];
+    return typeof slot === "number" && Number.isSafeInteger(slot) && slot >= 0
+        ? { scheduled: { slot } }
+        : {};
+}
+export function scheduledText(value) {
+    const { scheduled } = shownScheduled(value);
+    return scheduled === undefined ? "" : `scheduled ${String(scheduled.slot)}`;
+}

package/dist/src/cli/terminal-text.d.ts

@@ -0,0 +1,3 @@
+export declare function show(value: unknown): string;
+export declare function oneLine(value: unknown): string;
+export declare function visible(value: unknown): string;

package/dist/src/cli/terminal-text.js

@@ -0,0 +1,28 @@
+export function show(value) {
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+function escaped(character) {
+    return `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`;
+}
+const hiddenRanges = [
+    [0x00, 0x1f],
+    [0x7f, 0x9f],
+    [0x061c, 0x061c],
+    [0x200b, 0x200f],
+    [0x2028, 0x202e],
+    [0x2060, 0x2069],
+    [0xfeff, 0xfeff],
+];
+function hidden(character) {
+    const code = character.charCodeAt(0);
+    return hiddenRanges.some(([first, last]) => code >= first && code <= last);
+}
+export function oneLine(value) {
+    return Array.from(show(value), (character) => hidden(character) ? escaped(character) : character).join("");
+}
+export function visible(value) {
+    return show(value)
+        .split("\n")
+        .map((line) => Array.from(line, (character) => hidden(character) ? escaped(character) : character).join(""))
+        .join("\n    ");
+}

package/dist/src/cli/toolchain.d.ts

@@ -1,5 +1,6 @@
 import type { ToolchainIdentity } from "../workflow-admission.ts";
 export declare const supportedNodes: string;
+export declare const clovingVersion: string;
 export declare function supportedNode(version: string): boolean;
 export declare function observedToolchain(start: string): Promise<ToolchainIdentity>;
 export declare function qualifiedToolchain(observed: ToolchainIdentity, start: string): Promise<ToolchainIdentity>;

package/dist/src/cli/toolchain.js

@@ -4,6 +4,7 @@ import { access, readFile, realpath } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import packageMetadata from "#package" with { type: "json" };
 export const supportedNodes = packageMetadata.engines.node;
+export const clovingVersion = packageMetadata.version;
 export function supportedNode(version) {
     const release = /^v(\d+)\.(\d+)\.(\d+)$/.exec(version);
     if (release === null)

package/dist/src/cli/usage-render.d.ts

@@ -6,3 +6,4 @@ export declare function statusJson(result: Fields): Fields;
 import { type Fields } from "../protocol.ts";
 export declare function attemptText(attempt: WorkerAttemptUsage): string;
 export declare function attemptTexts(value: unknown): readonly string[];
+export declare function queueSpendLines(value: unknown): readonly string[];

package/dist/src/cli/usage-render.js

@@ -60,8 +60,35 @@ export function attemptText(attempt) {
     const kind = attempt.retryKind === undefined
         ? ""
         : ` · retryKind: ${String(attempt.retryKind)}`;
-    return `Attempt ${String(attempt.attempt)} · ${attempt.model ?? "Model not known"}${kind} · ${priceText(attempt.costUsd, attempt.estimatedCostUsd)}`;
+    const resumed = attempt.resumedAfter === undefined
+        ? ""
+        : ` · resumedAfter: ${attempt.resumedAfter}`;
+    return `Attempt ${String(attempt.attempt)} · ${attempt.model ?? "Model not known"}${kind}${resumed} · ${priceText(attempt.costUsd, attempt.estimatedCostUsd)}`;
 }
 export function attemptTexts(value) {
     return (attemptsOf(value) ?? []).map(attemptText);
 }
+export function queueSpendLines(value) {
+    const spend = record(value);
+    if (spend === undefined)
+        return [];
+    const spent = priceOf(spend["spentUsd"]);
+    const limit = priceOf(spend["limitUsd"]);
+    const unknown = Number(spend["unknownTurns"]);
+    const working = Number(spend["turnsInWork"]);
+    return [
+        `Spend: ${priceText(spent).replace(/ USD$/, "")} of ${priceText(limit)} in the last 24 hours`,
+        ...(unknown > 0
+            ? [`${String(unknown)} turn${unknown === 1 ? "" : "s"} with unknown cost`]
+            : []),
+        ...(working > 0
+            ? [`${String(working)} turn${working === 1 ? "" : "s"} in work`]
+            : []),
+        ...(spend["holding"] === true
+            ? ["Queue holds new runs for spend limit"]
+            : []),
+        ...(spent !== null && limit !== null && spent > limit
+            ? ["Spend is over the limit"]
+            : []),
+    ];
+}

package/dist/src/cli/usage.d.ts

@@ -1,5 +1,5 @@
-export declare const configUsage = "Usage: cloving config list [--json]\n       cloving config get <field> [--json]\n       cloving config set <field> <value> [--private] [--json]\n       cloving config unset <field> [--private] [--json]\n\nReads and changes settings for the current repository; --repository selects another repository.\nValues use JSON when valid, otherwise text. Every change is checked before writing.\nFields use their default project or private file; --private selects the private file.\nlist and get show the effective source and hidden file values. Unconfigured values use defaults; null means no value.\nChanges keep the previous file as .bak and replace the file atomically under a lock.\nA live lock waits at most ten seconds, then exits with settings-locked.\nPrivate files, backups and temporary files have mode 0600. Changes require a service restart.\n";
+export declare const configUsage = "Usage: cloving config list [--json]\n       cloving config get <field> [--json]\n       cloving config set <field> <value> [--private] [--json]\n       cloving config unset <field> [--private] [--json]\n\nReads and changes settings for the current repository; --repository selects another repository.\nValues use JSON when valid, otherwise text. Every change is checked before writing.\nFields use their default project or private file; --private selects the private file.\nlist and get show the effective source and hidden file values. Unconfigured values use defaults; null means no value.\nChanges keep the previous file as .bak and replace the file atomically under a lock.\nA live lock waits at most ten seconds, then exits with settings-locked.\nPrivate files, backups and temporary files have mode 0600.\ncloving reload applies changes of profiles, fallbackModels, tokenPrices and workflows.folder. Other changes require a service restart.\n";
 export declare const commandUsage: Readonly<Record<string, string>>;
-export declare const usage = "Usage: cloving [--help] [--version]\n       cloving workflows list [--json] [--repository <directory>]\n       cloving workflows test [<id>] [--repository <directory>]\n       cloving workflows validate <manifest-path> [--input <json-file>] [--json]\n       cloving templates list [--json]\n       cloving templates show <name> [--json]\n       cloving templates copy <name> [--id <workflow-id>] [--json] [--repository <directory>]\n       cloving <command> [--help]\n\nCommands:\n  workflows list      List bundled, project and user workflows and refusal codes.\n  workflows test      Run project and user workflow tests without a service.\n  workflows validate  Check a compiled workflow manifest, its artifacts and optional runtime input.\n  templates list      List the workflow templates of the package.\n  templates show      Show the decision points and the files of one template.\n  templates copy      Copy one template into .cloving/workflows of the repository.\n  doctor     Check repository requirements before starting or submitting work.\n  run        Submit one run of an admitted workflow.\n  status     List the runs or show one run.\n  report     Report loop facts and seven-day baselines.\n  questions  List the pending decisions.\n  answer     Answer one design question.\n  approve    Approve one pending approval.\n  deny       Deny one pending approval.\n  pause      Stop new dispatch for a run.\n  resume     Resume a paused run.\n  drop       Cancel a run and keep its files.\n  events     Print the committed events.\n  watch      Serve a page that shows the runs live.\n  phone      Show, list, remove and reset the connected phones.\n  config     Read and change repository settings.\n  start      Start the service for a repository.\n\nThe runtime commands need a Cloving service. They use the current git repository; --repository <directory> selects another repository. CLOVING_RUNTIME_DIR overrides its runtime directory.\nUse npm exec -- cloving ... for a project-local installation.\n";
+export declare const usage = "Usage: cloving [--help] [--version]\n       cloving workflows list [--json] [--repository <directory>]\n       cloving workflows test [<id>] [--repository <directory>]\n       cloving workflows validate <manifest-path> [--input <json-file>] [--json]\n       cloving init [--harness <name or path>] [--repository <directory>]\n       cloving init-prompt [--repository <directory>]\n       cloving templates list [--json]\n       cloving templates show <name> [--json]\n       cloving templates copy <name> [--id <workflow-id>] [--json] [--repository <directory>]\n       cloving red-green\n       cloving <command> [--help]\n\nCommands:\n  workflows list      List project and user workflows and refusal codes.\n  workflows test      Run project and user workflow tests without a service.\n  workflows validate  Check a compiled workflow manifest, its artifacts and optional runtime input.\n  templates list      List the workflow templates of the package.\n  templates show      Show the decision points and the files of one template.\n  templates copy      Copy one template into .cloving/workflows of the repository.\n  red-green  Check assertion failure on the base and success on the head.\n  init             Start the setup agent\n  init-prompt Print setup instructions for an agent.\n  doctor     Check repository requirements before starting or submitting work.\n  run        Submit one run of an admitted workflow.\n  status     List the runs or show one run.\n  mcp        Serve the Cloving tools over stdio.\n  schedule   List, pause and resume workflow schedules.\n  queue      Show, resume and drain the queue.\n  report     Report loop facts and seven-day baselines.\n  questions  List the pending decisions.\n  answer     Answer one design question.\n  approve    Approve one pending approval.\n  deny       Deny one pending approval.\n  pause      Stop new dispatch for a run.\n  resume     Resume a paused run.\n  drop       Cancel a run and keep its files.\n  events     Print the committed events.\n  watch      Serve a page that shows the runs live.\n  reload     Check and compile the workflow files again.\n  phone      Show, list, remove and reset the connected phones.\n  config     Read and change repository settings.\n  start      Start the service for a repository.\n\nThe runtime commands need a Cloving service. They use the current git repository; --repository <directory> selects another repository. CLOVING_RUNTIME_DIR overrides its runtime directory.\nUse npm exec -- cloving ... for a project-local installation.\n";
 export declare const validateUsage = "Usage: cloving workflows validate <manifest-path> [--input <json-file>] [--json]\n\nChecks a Cloving workflow manifest, its compiled SDK artifacts, declared resources and toolchain, and an optional runtime input file. Relative paths resolve against the current directory.\n\nOptions:\n  --input <json-file>  Validate this runtime input file.\n  --json               Print one versioned JSON result on stdout.\n\nValidation does not admit a run, dispatch effects, import workflow code or call a model.\n\nExample:\n  cloving workflows validate cloving.workflow.json --input input.json\n";
 export declare const phoneUsage = "Usage: cloving phone status [--json]\n       cloving phone list [--json]\n       cloving phone remove <device-id> [--json]\n       cloving phone reset [--json]\n\nShows and changes the phones that answer the questions of this computer.\nstatus shows the registration with cloving.ai and the number of phones.\nlist shows each phone with its device ID, name, platform, state and pairing time.\nremove marks one phone removed on this computer, then asks cloving.ai to remove it. A failure at cloving.ai keeps the phone removed and shows a warning.\nreset removes the registration with cloving.ai, marks all phones removed and deletes phone/link.json and phone/daemon-keys.json.\nConnect a phone with the Connect a phone button of the watch page.\ncloving start runs the phone relay as a child process. With CLOVING_PHONE_RELAY=off, the relay does not start, and status says that the relay is off or not started.\n";