cloving 1.1.0 → 1.3.0

package/dist/src/testing.js

@@ -0,0 +1,264 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { workflowTestLoader } from "../tools/workflow-test-loader.js";
+import { authorizeEffect } from "./effect-authorization.js";
+import { record } from "./protocol.js";
+import { stepBridgeKey, } from "./step-bridge.js";
+export function fakeStepBridge(scenario) {
+    const { bridge, requests, budget } = scenarioBridge(scenario);
+    const key = Symbol.for(stepBridgeKey);
+    const sleepKey = Symbol.for("WORKFLOW_SLEEP");
+    const previous = Object.getOwnPropertyDescriptor(globalThis, key);
+    const previousSleep = Object.getOwnPropertyDescriptor(globalThis, sleepKey);
+    if (Reflect.get(globalThis, key) !== undefined ||
+        Reflect.get(globalThis, sleepKey) !== undefined)
+        throw new Error("workflow-testing-host-active");
+    if (previous?.configurable === false || previousSleep?.configurable === false)
+        throw new Error("workflow-testing-host-locked");
+    Object.defineProperty(globalThis, key, { configurable: true, value: bridge });
+    Object.defineProperty(globalThis, sleepKey, {
+        configurable: true,
+        value: (milliseconds) => {
+            requests.push(["sleep", { seconds: milliseconds / 1000 }]);
+            return Promise.resolve();
+        },
+    });
+    return {
+        requests,
+        get spent() {
+            return budget.spent;
+        },
+        [Symbol.dispose]() {
+            if (previous === undefined)
+                Reflect.deleteProperty(globalThis, key);
+            else
+                Object.defineProperty(globalThis, key, previous);
+            if (previousSleep === undefined)
+                Reflect.deleteProperty(globalThis, sleepKey);
+            else
+                Object.defineProperty(globalThis, sleepKey, previousSleep);
+        },
+    };
+}
+function scenarioBridge(scenario) {
+    const requests = [];
+    const waits = [...(scenario.waits ?? [])];
+    const decisions = [...(scenario.decisions ?? [])];
+    const budget = { spent: 0 };
+    const bridge = {
+        ...scenarioEffects(scenario, { requests, budget }),
+        gate: (request) => {
+            requests.push(["gate", request]);
+            return Promise.resolve(scenario.gate ?? {
+                kind: "unavailable",
+                reason: "no-scenario-result",
+            });
+        },
+        waitForDecision: (request) => {
+            requests.push(["waitForDecision", request]);
+            const decision = decisions.shift();
+            if (decision === undefined)
+                return Promise.reject(new Error("no-scenario-result"));
+            return Promise.resolve(decision);
+        },
+        waitForRun: (request) => {
+            requests.push(["waitForRun", request]);
+            return Promise.resolve(waits.shift() ?? {
+                kind: "unavailable",
+                reason: "no-scenario-result",
+                promotionId: null,
+            });
+        },
+    };
+    return { bridge, requests, budget };
+}
+function scenarioEffects(scenario, state) {
+    const { requests, budget } = state;
+    const effects = new Map(Object.entries(scenario.effects ?? {}).map(([key, values]) => [
+        key,
+        [...values],
+    ]));
+    return {
+        effect: (request) => {
+            requests.push(["effect", request]);
+            const refusal = spend(scenario, { budget, request });
+            if (refusal !== undefined)
+                return Promise.resolve(refusal);
+            const result = scenario.effects === undefined
+                ? scenario.turn
+                : effects.get(request.capability + " " + request.method)?.shift();
+            return Promise.resolve(result ?? { kind: "unavailable", reason: "no-scenario-result" });
+        },
+        handoff: (request) => {
+            requests.push(["handoff", request]);
+            const refusal = spend(scenario, {
+                budget,
+                request: { capability: "handoff", units: 1 },
+            });
+            if (refusal !== undefined)
+                return Promise.resolve(refusal);
+            return Promise.resolve(effects.get("handoff")?.shift() ?? {
+                kind: "completed",
+                operationId: "handoff",
+                receipt: null,
+                result: "target-run",
+            });
+        },
+    };
+}
+function spend(scenario, effect) {
+    const { budget, request } = effect;
+    if (scenario.effectLimit === undefined)
+        return undefined;
+    const allowed = authorizeEffect({ capabilities: ["claude", "github", "command", "handoff"] }, {
+        budget: { limit: scenario.effectLimit, spent: budget.spent },
+        request,
+    });
+    if (allowed.kind === "rejected")
+        return { kind: "refused", reason: allowed.reason };
+    budget.spent = allowed.spent;
+    return undefined;
+}
+function scenarioScript(scenario) {
+    const workflow = scenario.workflow.startsWith("file:")
+        ? scenario.workflow
+        : pathToFileURL(resolve(scenario.workflow)).href;
+    return `import { writeFile } from "node:fs/promises";
+import { fakeStepBridge } from ${JSON.stringify(import.meta.url)};
+import * as workflows from ${JSON.stringify(workflow)};
+const given = ${JSON.stringify(scenario)};
+const workflow = workflows[given.exportName];
+if (typeof workflow !== "function") throw new Error("workflow-test-export-missing");
+using bridge = fakeStepBridge(given);
+const outcome = await workflow(given.input, given.decision);
+await writeFile(process.argv[2], JSON.stringify({ outcome, requests: bridge.requests,
+  ...(given.effectLimit === undefined ? {} : { spent: bridge.spent }) }));`;
+}
+function scenarioResult(value) {
+    const result = record(value);
+    return (result !== undefined &&
+        Object.hasOwn(result, "outcome") &&
+        Array.isArray(result["requests"]) &&
+        result["requests"].every(scenarioRequest) &&
+        (result["spent"] === undefined || typeof result["spent"] === "number"));
+}
+function scenarioRequest(value) {
+    if (!Array.isArray(value) || value.length !== 2)
+        return false;
+    const request = record(value[1]);
+    if (request === undefined)
+        return false;
+    switch (value[0]) {
+        case "effect":
+            return protectedRequest(request);
+        case "gate":
+        case "waitForDecision":
+            return gateRequest(request);
+        case "handoff":
+            return handoffRequest(request);
+        case "waitForRun":
+            return runWaitRequest(request);
+        case "sleep":
+            return sleepRequest(request);
+        default:
+            return false;
+    }
+}
+function runWaitRequest(request) {
+    return (typeof request["runId"] === "string" &&
+        typeof request["maximumWaitSeconds"] === "number");
+}
+function sleepRequest(request) {
+    const seconds = request["seconds"];
+    return (typeof seconds === "number" &&
+        Number.isInteger(seconds) &&
+        seconds >= 1 &&
+        seconds <= 86400);
+}
+function gateRequest(request) {
+    return (typeof request["gateId"] === "string" &&
+        (request["kind"] === "question" || request["kind"] === "approval") &&
+        typeof request["prompt"] === "string" &&
+        optionalText(request["expiresAt"]));
+}
+function handoffRequest(request) {
+    const input = record(request["input"]);
+    return (typeof request["workflowId"] === "string" &&
+        input !== undefined &&
+        Object.values(input).every(handoffValue));
+}
+function protectedRequest(request) {
+    return (protectedScope(request["scope"]) &&
+        ["capability", "method", "target", "payload"].every((key) => typeof request[key] === "string") &&
+        typeof request["units"] === "number" &&
+        optionalText(request["resource"]));
+}
+function protectedScope(value) {
+    const scope = record(value);
+    if (scope === undefined)
+        return false;
+    const stage = record(scope["stage"]);
+    return (typeof scope["phase"] === "string" &&
+        typeof scope["operation"] === "string" &&
+        typeof scope["round"] === "number" &&
+        optionalText(scope["key"]) &&
+        (scope["stage"] === undefined ||
+            (stage !== undefined &&
+                ["id", "visit", "branch"].every((key) => typeof stage[key] === "string"))));
+}
+function optionalText(value) {
+    return value === undefined || typeof value === "string";
+}
+function handoffValue(value) {
+    if (value === null || ["string", "boolean", "number"].includes(typeof value))
+        return true;
+    if (Array.isArray(value))
+        return value.every(handoffValue);
+    const fields = record(value);
+    return fields !== undefined && Object.values(fields).every(handoffValue);
+}
+export async function runScenario(scenario) {
+    const temporary = await mkdtemp(join(tmpdir(), "cloving-scenario-"));
+    try {
+        const script = join(temporary, "scenario.mjs");
+        const resultFile = join(temporary, "result.json");
+        await writeFile(script, scenarioScript(scenario));
+        await executeScenario(script, resultFile);
+        const value = JSON.parse(await readFile(resultFile, "utf8"));
+        if (!scenarioResult(value))
+            throw new Error("invalid-workflow-scenario-result");
+        return value;
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+}
+function executeScenario(script, resultFile) {
+    return new Promise((settle, reject) => {
+        const child = spawn(process.execPath, [
+            "--experimental-strip-types",
+            "--import",
+            workflowTestLoader(),
+            script,
+            resultFile,
+        ], {
+            env: { ...process.env, NODE_TEST_CONTEXT: undefined },
+            stdio: ["ignore", "ignore", "pipe"],
+        });
+        let diagnostics = "";
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (text) => {
+            diagnostics = (diagnostics + text).slice(-65536);
+        });
+        child.once("error", reject);
+        child.once("close", (code, signal) => {
+            if (code === 0)
+                settle();
+            else
+                reject(new Error(`workflow-scenario-failed: ${String(code ?? signal)}\n${diagnostics}`));
+        });
+    });
+}

package/dist/src/ticket-dependencies.d.ts

@@ -0,0 +1 @@
+export declare function hardDependencies(ticket: string): readonly string[];

package/dist/src/ticket-dependencies.js

@@ -0,0 +1,15 @@
+export function hardDependencies(ticket) {
+    const lines = ticket.split(/\r?\n/);
+    const start = lines.findIndex((line) => /^## Dependencies\s*$/.test(line));
+    if (start === -1)
+        return [];
+    const following = lines.slice(start + 1);
+    const end = following.findIndex((line) => /^#{1,2} /.test(line));
+    const section = (end === -1 ? following : following.slice(0, end)).join("\n");
+    const sentences = section
+        .replace(/\b(?:e\.g|i\.e)\./g, "example")
+        .matchAll(/(?:^|[.!?]\s+|\n)\s*(?:[-*+]\s+|\d+\.\s+)?Needs\b([\s\S]*?)(?=[.!?](?:\s|$)|$)/g);
+    return [
+        ...new Set([...sentences].flatMap((sentence) => [...String(sentence[1]).matchAll(/#([1-9]\d*)\b/g)].map((match) => String(match[1])))),
+    ];
+}

package/dist/src/ticket-status-stream.d.ts

@@ -0,0 +1,9 @@
+import { type TicketStatus } from "./ticket-status.ts";
+export interface StreamedTicketStatus {
+    readonly ticketStatus: TicketStatus;
+    readonly ticketStatusTooLarge?: true;
+}
+export declare function ticketStatusStream(limit: number): {
+    write: (chunk: string) => void;
+    result: () => StreamedTicketStatus;
+};

package/dist/src/ticket-status-stream.js

@@ -0,0 +1,94 @@
+import { ticketStatus } from "./ticket-status.js";
+function emptyLine() {
+    return {
+        text: "",
+        length: 0,
+        contentLength: 0,
+        breaks: 0,
+        trailingCarriage: false,
+    };
+}
+function remainingLine(stream, line) {
+    if (line.length <= stream.limit && line.text === "Remaining:") {
+        stream.remaining = [];
+        stream.characters = 0;
+        stream.valid = true;
+        return;
+    }
+    if (!stream.valid)
+        return;
+    if (line.breaks > 0 || !/^- \S.*$/.test(line.text)) {
+        stream.valid = false;
+        return;
+    }
+    stream.characters = Math.min(stream.limit + 1, stream.characters + line.length + 1);
+    if (stream.characters <= stream.limit)
+        stream.remaining.push(line.text.slice(2));
+}
+function receivedLine(stream) {
+    const line = stream.line;
+    stream.line = emptyLine();
+    if (line.contentLength === 0)
+        return;
+    if (line.trailingCarriage)
+        line.breaks--;
+    if (line.length <= stream.limit + 1 && line.trailingCarriage) {
+        line.text = line.text.slice(0, -1);
+        line.length--;
+    }
+    if (stream.last !== undefined)
+        remainingLine(stream, stream.last);
+    if (/^Ticket status:/i.test(line.text))
+        stream.statuses = Math.min(2, stream.statuses + 1);
+    stream.last = line;
+}
+function writeStatus(stream, chunk) {
+    const parts = chunk.split("\n");
+    for (const [index, part] of parts.entries()) {
+        const { line, limit } = stream;
+        const content = part.trimEnd();
+        line.breaks = Math.min(2, line.breaks + (part.match(/[\r\u2028\u2029]/g)?.length ?? 0));
+        if (part !== "")
+            line.trailingCarriage = part.endsWith("\r");
+        if (content !== "")
+            line.contentLength = Math.min(limit + 1, line.length + content.length);
+        line.text = (line.text + part).slice(0, limit + 1);
+        line.length = Math.min(limit + 2, line.length + part.length);
+        if (index < parts.length - 1)
+            receivedLine(stream);
+    }
+}
+function statusResult(stream) {
+    receivedLine(stream);
+    const last = stream.last;
+    if (stream.statuses !== 1 || last === undefined)
+        return { ticketStatus: ticketStatus("") };
+    const status = last.contentLength > stream.limit ? "" : last.text.trimEnd();
+    if (status !== "Ticket status: partial" || !stream.valid)
+        return { ticketStatus: ticketStatus(status) };
+    if (stream.characters > stream.limit)
+        return {
+            ticketStatus: ticketStatus(status),
+            ticketStatusTooLarge: true,
+        };
+    return {
+        ticketStatus: ticketStatus(`Remaining:\n${stream.remaining.map((item) => `- ${item}`).join("\n")}\n${status}`),
+    };
+}
+export function ticketStatusStream(limit) {
+    const stream = {
+        limit,
+        line: emptyLine(),
+        last: undefined,
+        statuses: 0,
+        remaining: [],
+        characters: 0,
+        valid: false,
+    };
+    return {
+        write: (chunk) => {
+            writeStatus(stream, chunk);
+        },
+        result: () => statusResult(stream),
+    };
+}

package/dist/src/ticket-status.js

@@ -8,11 +8,14 @@ function parsedStatus(summary) {
     if (status !== "Ticket status: partial")
         return undefined;
     const heading = lines.lastIndexOf("Remaining:");
-    if (heading === -1)
-        return undefined;
-    const items = lines.slice(heading + 1);
+    const items = heading === -1
+        ? []
+        : lines.slice(heading + 1).filter((line) => line.trim() !== "");
     if (items.length === 0 || items.some((line) => !/^- \S.*$/.test(line)))
-        return undefined;
+        return {
+            kind: "partial",
+            remaining: ["The worker report has an unreadable Remaining: list."],
+        };
     return { kind: "partial", remaining: items.map((line) => line.slice(2)) };
 }
 function preservedStatus(value) {

package/dist/src/token-prices.d.ts

@@ -1,4 +1,5 @@
-import { type WorkerUsage } from "./worker-usage.ts";
+import { type WorkerUsage, type WorkerModelUsage } from "./worker-usage.ts";
+import type { NativeHarness } from "./harness-defaults.ts";
 export interface TokenPrice {
     readonly input: number;
     readonly cachedInput: number;
@@ -11,9 +12,18 @@ export declare const builtInPriceTable: {
     readonly prices: TokenPrices;
 };
 export declare function parseTokenPrices(value: string | undefined): TokenPrices;
+export declare function parseFallbackModels(value: string | undefined): readonly string[];
 export declare function priceForModel(prices: TokenPrices, model: string | null): TokenPrice | undefined;
 export declare function commandModel(command: readonly string[]): string | null;
-export declare function estimatedCostUsd(usage: WorkerUsage, pricing: {
-    readonly worker: "claude" | "codex";
+export declare function replaceCommandModel(command: readonly string[], model: string): readonly string[];
+interface SinglePricing {
+    readonly worker: NativeHarness;
     readonly price: TokenPrice | undefined;
-}): number | null;
+}
+interface ModelPricing {
+    readonly worker: "gemini";
+    readonly models: readonly WorkerModelUsage[];
+    readonly prices: TokenPrices;
+}
+export declare function estimatedCostUsd(usage: WorkerUsage, pricing: SinglePricing | ModelPricing): number | null;
+export {};

package/dist/src/token-prices.js

@@ -1,4 +1,4 @@
-import { priceOf, usageOf } from "./worker-usage.js";
+import { priceOf, sumPrices, usageOf, } from "./worker-usage.js";
 import { record } from "./protocol.js";
 export const builtInPriceTable = {
     date: "2026-10-18",
@@ -36,38 +36,83 @@ export function parseTokenPrices(value) {
         throw new Error("Invalid CLOVING_TOKEN_PRICES");
     }
 }
+export function parseFallbackModels(value) {
+    if (value === undefined)
+        return [];
+    try {
+        const models = JSON.parse(value);
+        if (Array.isArray(models) &&
+            models.length <= 3 &&
+            models.every((model) => typeof model === "string" && model.trim().length > 0))
+            return models.map(String);
+    }
+    catch {
+        throw new Error("The daemon did not start: invalid-fallback-models");
+    }
+    throw new Error("The daemon did not start: invalid-fallback-models");
+}
 export function priceForModel(prices, model) {
     return model !== null && Object.hasOwn(prices, model)
         ? prices[model]
         : undefined;
 }
-export function commandModel(command) {
-    let model = null;
-    for (let index = 1; index < command.length; index += 1) {
+function modelIndex(command) {
+    let selected;
+    const separator = command.indexOf("--", 1);
+    const end = separator === -1 ? command.length : separator;
+    for (let index = 1; index < end; index += 1) {
         const argument = command[index] ?? "";
-        if (argument === "--")
-            break;
         if (argument.startsWith("--model="))
-            model = argument.slice(8) || null;
-        if (argument === "--model" || argument === "-m") {
+            selected = argument.slice(8) ? index : undefined;
+        if (["--model", "-m"].includes(argument)) {
             const next = command[index + 1];
-            model = next && !next.startsWith("-") ? next : null;
+            selected = next && !next.startsWith("-") ? index + 1 : undefined;
             index += 1;
         }
     }
-    return model;
+    return selected;
+}
+export function commandModel(command) {
+    const index = modelIndex(command);
+    if (index === undefined)
+        return null;
+    const argument = command[index] ?? "";
+    return argument.startsWith("--model=") ? argument.slice(8) : argument;
+}
+export function replaceCommandModel(command, model) {
+    const index = modelIndex(command);
+    if (index === undefined)
+        return command;
+    return command.map((argument, position) => {
+        if (position !== index)
+            return argument;
+        return argument.startsWith("--model=") ? `--model=${model}` : model;
+    });
 }
 export function estimatedCostUsd(usage, pricing) {
+    return "models" in pricing
+        ? modelCostUsd(pricing)
+        : singleCostUsd(usage, pricing);
+}
+function modelCostUsd(pricing) {
+    return sumPrices(pricing.models.map(({ model, usage: counts }) => singleCostUsd(counts, {
+        worker: "gemini",
+        price: priceForModel(pricing.prices, model),
+    })));
+}
+function singleCostUsd(usage, pricing) {
     const { worker, price } = pricing;
     const counts = usageOf(usage);
     const cached = counts.cache_read_input_tokens;
     const output = counts.output_tokens;
     if (price === undefined ||
+        (worker === "cursor-agent" && counts.cache_creation_input_tokens !== 0) ||
         counts.input_tokens === null ||
         cached === null ||
         output === null)
         return null;
-    const input = counts.input_tokens - (worker === "codex" ? cached : 0);
+    const input = counts.input_tokens -
+        (worker === "codex" || worker === "gemini" ? cached : 0);
     if (input < 0)
         return null;
     return priceOf((input / 1_000_000) * price.input +

package/dist/src/turn-profile.d.ts

@@ -1,4 +1,5 @@
 export interface TurnProfile {
+    readonly harness?: string;
     readonly env?: Readonly<Record<string, string>>;
     readonly allowedTools?: readonly string[];
     readonly model?: string;

package/dist/src/turn-profile.js

@@ -1,4 +1,5 @@
 const fields = [
+    "harness",
     "env",
     "allowedTools",
     "model",
@@ -29,6 +30,8 @@ function environment(value) {
             text(item)));
 }
 function validField(name, value) {
+    if (name === "harness")
+        return typeof value === "string" && /^[a-z][a-z0-9-]{0,63}$/.test(value);
     if (name === "env")
         return environment(value);
     if (name === "allowedTools" || name === "workflows")
@@ -71,7 +74,11 @@ function retained(argumentsList, values) {
     for (let index = 0; index < argumentsList.length;) {
         const argument = argumentsList[index] ?? "";
         const name = argument.split("=")[0] ?? "";
-        const flag = name === "--allowed-tools" ? "--allowedTools" : name;
+        const aliases = {
+            "--allowed-tools": "--allowedTools",
+            "-m": "--model",
+        };
+        const flag = aliases[name] ?? name;
         if (!values.has(flag)) {
             kept.push(argument);
             index += 1;

package/dist/src/worker-usage.d.ts

@@ -1,14 +1,34 @@
+export type RetryKind = "capacity" | "network";
 export interface WorkerUsage {
+    readonly cache_creation_input_tokens?: number | null;
     readonly input_tokens: number | null;
     readonly cache_read_input_tokens: number | null;
     readonly output_tokens: number | null;
 }
 export interface WorkerTurnUsage {
+    readonly model?: string;
+    readonly summary?: string;
+    readonly harness?: string;
+    readonly attempts?: readonly WorkerAttemptUsage[];
     readonly estimatedCostUsd: number | null;
     readonly operationId: string;
     readonly usage: WorkerUsage;
     readonly costUsd: number | null;
 }
+export interface WorkerAttemptUsage {
+    readonly models?: readonly WorkerModelUsage[];
+    readonly retryKind?: RetryKind | null;
+    readonly attempt: number;
+    readonly model: string | null;
+    readonly usage: WorkerUsage;
+    readonly costUsd: number | null;
+    readonly estimatedCostUsd: number | null;
+}
+export interface WorkerModelUsage {
+    readonly model: string;
+    readonly usage: WorkerUsage;
+}
+export declare function modelUsageOf(value: unknown): readonly WorkerModelUsage[] | undefined;
 export interface WorkerTotals {
     readonly estimatedCostUsd: number | null;
     readonly workerTurns: readonly WorkerTurnUsage[];
@@ -19,4 +39,9 @@ export declare function priceOf(value: unknown): number | null;
 export declare function tokenCount(value: unknown): number | null;
 export declare function usageOf(value: unknown): WorkerUsage;
 export declare function sumUsage(values: readonly WorkerUsage[]): WorkerUsage;
+export declare function sumPrices(values: readonly (number | null)[]): number | null;
 export declare function workerTotals(workerTurns: readonly WorkerTurnUsage[]): WorkerTotals;
+export declare function attemptsOf(value: unknown): readonly WorkerAttemptUsage[] | undefined;
+export declare function attemptFields(value: unknown): {
+    readonly attempts?: readonly WorkerAttemptUsage[];
+};