cloving 1.2.0 → 1.3.0

package/dist/src/steps/review-by-person.js

@@ -0,0 +1,16 @@
+import { snapshotReviewSubject } from "./review-subject.js";
+import { waitForDecision } from "./wait-for-decision.js";
+export async function reviewByPerson(request) {
+    const snapshot = await snapshotReviewSubject(request.subject);
+    const decision = await waitForDecision({
+        gateId: `review:${snapshot.subjectDigest}`,
+        kind: "approval",
+        prompt: `Review this subject:\n${snapshot.prompt}`,
+    });
+    return {
+        accepted: decision.decision === "approved",
+        feedback: decision.answer ?? "",
+        commit: snapshot.commit,
+        subjectDigest: snapshot.subjectDigest,
+    };
+}

package/dist/src/steps/review-subject.d.ts

@@ -0,0 +1,2 @@
+import { type ReviewSubject, type ReviewSnapshot } from "../review-subject.ts";
+export declare function snapshotReviewSubject(subject: ReviewSubject): Promise<ReviewSnapshot>;

package/dist/src/steps/review-subject.js

@@ -0,0 +1,11 @@
+import { operationDigest } from "../broker/operation-digest.js";
+import { reviewSubjectText, } from "../review-subject.js";
+export async function snapshotReviewSubject(subject) {
+    "use step";
+    const prompt = reviewSubjectText(subject);
+    return Promise.resolve({
+        commit: "draft" in subject ? null : subject.commit,
+        subjectDigest: `sha256:${operationDigest(prompt)}`,
+        prompt,
+    });
+}

package/dist/src/steps/run-command.d.ts

@@ -0,0 +1,2 @@
+import { type CommandRequest, type ProtectedResult } from "../step-bridge.ts";
+export declare function runCommand(request: CommandRequest): Promise<ProtectedResult>;

package/dist/src/steps/run-command.js

@@ -0,0 +1,15 @@
+import { isStepBridge, stepBridgeKey, } from "../step-bridge.js";
+export async function runCommand(request) {
+    "use step";
+    const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));
+    if (!isStepBridge(bridge))
+        return { kind: "unavailable", reason: "cloving-host-unavailable" };
+    return await bridge.effect({
+        scope: request.scope,
+        capability: "command",
+        method: `run:${request.name}`,
+        target: request.name,
+        payload: JSON.stringify(request.input),
+        units: 1,
+    });
+}

package/dist/src/steps/sleep.d.ts

@@ -0,0 +1,3 @@
+export declare function sleep(request: {
+    readonly seconds: number;
+}): Promise<void>;

package/dist/src/steps/sleep.js

@@ -0,0 +1,19 @@
+import { sleep as sdkSleep } from "workflow";
+export async function sleep(request) {
+    await sdkSleep(sleepSeconds(request) * 1000);
+}
+function sleepSeconds(request) {
+    if (typeof request !== "object" ||
+        request === null ||
+        Reflect.ownKeys(request).length !== 1)
+        throw new Error("invalid-sleep-seconds");
+    const field = Object.getOwnPropertyDescriptor(request, "seconds") ?? {};
+    const seconds = field.value;
+    if (field.enumerable !== true ||
+        typeof seconds !== "number" ||
+        !Number.isInteger(seconds) ||
+        seconds < 1 ||
+        seconds > 86400)
+        throw new Error("invalid-sleep-seconds");
+    return seconds;
+}

package/dist/src/steps/wait-for-decision.d.ts

@@ -0,0 +1,2 @@
+import type { DecisionResult, GateRequest } from "../step-bridge.ts";
+export declare function waitForDecision(request: GateRequest): Promise<DecisionResult>;

package/dist/src/steps/wait-for-decision.js

@@ -0,0 +1,71 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { createHook } from "workflow";
+import { openDecisionWait } from "./decision-gate.js";
+export async function waitForDecision(request) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const wait = await openDecisionWait(request);
+        if ("decision" in wait)
+            return wait;
+        const hook = __addDisposableResource(env_1, createHook({ token: wait.token }), false);
+        return await hook;
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+}

package/dist/src/steps/wait-for-run.d.ts

@@ -0,0 +1,5 @@
+import { type RunWaitOutcome, type RunWaitRequest } from "../step-bridge.ts";
+export declare function waitForRun(request: RunWaitRequest): Promise<RunWaitOutcome>;
+export declare namespace waitForRun {
+    var maxRetries: number;
+}

package/dist/src/steps/wait-for-run.js

@@ -0,0 +1,9 @@
+import { isStepBridge, stepBridgeKey, } from "../step-bridge.js";
+export async function waitForRun(request) {
+    "use step";
+    const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));
+    if (!isStepBridge(bridge) || bridge.waitForRun === undefined)
+        throw new Error("cloving-host-unavailable");
+    return await bridge.waitForRun(request);
+}
+waitForRun.maxRetries = 86401;

package/dist/src/storage/decision-snapshots.d.ts

@@ -12,6 +12,7 @@ export interface DecidedSnapshot extends DomainSnapshot, DecisionRows {
 export interface CurrentSnapshot extends DecidedSnapshot {
     readonly effects: EffectRows;
 }
+export declare function loadOperationSnapshot(connection: SqlConnection): Promise<Pick<ProjectionSnapshot, "outbox" | "deliveries">>;
 export declare function loadProjections(connection: SqlConnection): Promise<ProjectionSnapshot>;
 export declare function loadDecided(connection: SqlConnection): Promise<DecidedSnapshot>;
 export declare function loadCurrent(connection: SqlConnection): Promise<CurrentSnapshot>;

package/dist/src/storage/decision-snapshots.js

@@ -1,6 +1,12 @@
 import { loadDecisions, loadDocuments, } from "./decision-rows.js";
-import { latestSequence, loadAttempts, loadSnapshot, projectionRows, text, } from "./domain-rows.js";
+import { latestSequence, loadAttempts, loadSnapshot, outboxRow, projectionRows, text, } from "./domain-rows.js";
 import { loadEffects } from "./effect-rows.js";
+export async function loadOperationSnapshot(connection) {
+    return {
+        outbox: (await connection.all("SELECT operation_id, kind, run_id, created_sequence, released_sequence FROM outbox ORDER BY created_sequence, rowid")).map(outboxRow),
+        deliveries: await loadAttempts(connection),
+    };
+}
 export async function loadProjections(connection) {
     return {
         ...(await projectionRows(connection)),

package/dist/src/submission.d.ts

@@ -5,6 +5,9 @@ export type SubmissionField = {
 } | {
     readonly type: "boolean";
     readonly optional?: boolean;
+} | {
+    readonly type: "ticket";
+    readonly optional?: boolean;
 } | {
     readonly type: "integer";
     readonly optional?: boolean;
@@ -15,6 +18,7 @@ export interface SubmissionContract {
     readonly maximumBytes: number;
     readonly fields: Readonly<Record<string, "string" | SubmissionField>>;
 }
+export declare function hasTicketField(contract: SubmissionContract | undefined): boolean;
 export type SubmissionCheck = {
     readonly kind: "valid";
     readonly normalized: string;

package/dist/src/submission.js

@@ -1,4 +1,8 @@
 import { record } from "./protocol.js";
+export function hasTicketField(contract) {
+    const rule = contract?.fields["ticket"];
+    return rule !== undefined && rule !== "string" && rule.type === "ticket";
+}
 function rejected(code, detail) {
     return { kind: "rejected", code, detail };
 }
@@ -14,11 +18,11 @@ function invalidField(contract, submission) {
     return Object.entries(contract.fields).find(([key, rule]) => {
         if (rule !== "string" && rule.optional && !Object.hasOwn(submission, key))
             return false;
-        return !validValue(rule, submission[key]);
+        return !validValue(rule === "string" ? { type: "string" } : rule, submission[key]);
     })?.[0];
 }
 function validValue(rule, value) {
-    if (rule === "string" || rule.type === "string")
+    if (rule.type === "string" || rule.type === "ticket")
         return typeof value === "string" && value.trim().length > 0;
     if (rule.type === "boolean")
         return typeof value === "boolean";

package/dist/src/testing.d.ts

@@ -0,0 +1,29 @@
+import { type HandoffValue, type ProtectedResult, type GateResult, type DecisionResult, type RunWaitOutcome, type ProtectedRequest, type GateRequest, type HandoffRequest, type RunWaitRequest } from "./step-bridge.ts";
+export interface StepScenario {
+    readonly turn?: ProtectedResult;
+    readonly effects?: Readonly<Record<string, readonly ProtectedResult[]>>;
+    readonly gate?: GateResult;
+    readonly waits?: readonly RunWaitOutcome[];
+    readonly decisions?: readonly DecisionResult[];
+    readonly effectLimit?: number;
+}
+export interface WorkflowScenario extends StepScenario {
+    readonly workflow: string;
+    readonly exportName: string;
+    readonly input: HandoffValue;
+    readonly decision?: HandoffValue;
+}
+export type ScenarioRequest = readonly ["effect", ProtectedRequest] | readonly ["gate", GateRequest] | readonly ["waitForDecision", GateRequest] | readonly ["handoff", HandoffRequest] | readonly ["waitForRun", RunWaitRequest] | readonly ["sleep", {
+    readonly seconds: number;
+}];
+export interface ScenarioResult {
+    readonly spent?: number;
+    readonly outcome: unknown;
+    readonly requests: readonly ScenarioRequest[];
+}
+export declare function fakeStepBridge(scenario: StepScenario): {
+    requests: ScenarioRequest[];
+    readonly spent: number;
+    [Symbol.dispose](): void;
+};
+export declare function runScenario(scenario: WorkflowScenario): Promise<ScenarioResult>;

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-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/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;
@@ -15,7 +16,14 @@ export declare function parseFallbackModels(value: string | undefined): readonly
 export declare function priceForModel(prices: TokenPrices, model: string | null): TokenPrice | undefined;
 export declare function commandModel(command: readonly string[]): string | null;
 export declare function replaceCommandModel(command: readonly string[], model: string): readonly string[];
-export declare function estimatedCostUsd(usage: WorkerUsage, pricing: {
-    readonly worker: "claude" | "codex";
+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 {};