cloving 1.0.1 → 1.2.0

package/dist/src/service/run-handlers.js

@@ -1,12 +1,18 @@
+import { issueIdentity } from "../issue-identity.js";
+import { linksOf } from "../authority/handoff-chain.js";
 import { runView, unresolvedEffects, } from "../authority/status.js";
 import { record } from "../protocol.js";
 import { committed, failed, invalidRequest, isIdentifier, publicReceipt, rejection, result, wholeNumber, } from "./replies.js";
+import { usageTotals } from "./worker-totals.js";
 import { feedbackOf } from "./decision-handler.js";
+import { queueOverview } from "./submission-handler.js";
+import { queueRunStatuses } from "./queue-runs.js";
 async function snapshot(context) {
     const { authority } = context;
     const state = await authority.state();
     const sequences = await authority.queries.sequences();
     return {
+        links: await authority.queries.runLinks(),
         state,
         operations: await authority.operations(),
         sequences: sequences.runs,
@@ -38,9 +44,7 @@ async function effectInput(context, runId) {
     const budget = await effects.budget(runId);
     const stored = await effects.operations(runId);
     return {
-        budget: budget === undefined
-            ? null
-            : { limit: budget.limit, spent: budget.spent },
+        budget: budget ? { limit: budget.limit, spent: budget.spent } : null,
         effects: stored.map((operation) => ({
             operationId: operation.operationId,
             status: operation.status,
@@ -77,6 +81,8 @@ async function viewOf(context, scope) {
     };
     return {
         ...runView(input),
+        ...linksOf({ runId: run.runId, ...scope.snapshot.links[run.runId] }),
+        input: await submittedInput(context, details?.submission),
         workflowId: scope.snapshot.workflowIds[run.runId] ?? run.workflow,
         latestAt: times[run.runId] ?? null,
         unresolvedEffects: unresolvedEffects(input),
@@ -86,6 +92,8 @@ async function viewOf(context, scope) {
 function summary(view) {
     return {
         runId: view.runId,
+        ...linksOf(view),
+        input: view.input,
         workflowId: view.workflowId,
         state: view.state,
         condition: view.condition,
@@ -95,26 +103,6 @@ function summary(view) {
         pendingDecisions: view.pendingDecisions,
     };
 }
-function costOf(text) {
-    try {
-        const cost = record(JSON.parse(text ?? "null"))?.["costUsd"];
-        return typeof cost === "number" ? cost : 0;
-    }
-    catch {
-        return 0;
-    }
-}
-async function claudeCost(context, runId) {
-    const { effects, queries } = context.authority;
-    const digests = (await effects.operations(runId))
-        .filter((operation) => operation.capability === "claude")
-        .map((operation) => operation.result)
-        .filter((digest) => digest !== null);
-    let total = 0;
-    for (const digest of digests)
-        total += costOf(await queries.document(digest));
-    return Math.round(total * 100) / 100;
-}
 function full(view) {
     return {
         ...summary(view),
@@ -123,6 +111,9 @@ function full(view) {
         lastConfirmedObservation: view.lastConfirmedObservation,
         recovery: view.recovery,
         claudeCostUsd: view.claudeCostUsd,
+        estimatedCostUsd: view.estimatedCostUsd,
+        usage: view.usage,
+        workerTurns: view.workerTurns,
         budget: view.budget,
         effects: view.effects,
         nextAction: view.nextAction,
@@ -138,10 +129,18 @@ async function outcomeOf(context, view) {
         runId: view.runId,
         atOrBefore: view.latestSequence,
     });
-    const kind = event?.payload["outcome"];
+    const payload = event?.payload ?? {};
+    const kind = payload["outcome"];
     if (kind === undefined)
         return null;
-    return { kind, reason: event?.payload["outcomeReason"] ?? null };
+    const { ticketStatus, promotionId, outcomeReason, issueUpdate } = payload;
+    return {
+        kind,
+        reason: outcomeReason ?? null,
+        ...(promotionId === undefined ? {} : { promotionId }),
+        ...(ticketStatus === undefined ? {} : { ticketStatus }),
+        ...(issueUpdate === "failed" ? { issueUpdate } : {}),
+    };
 }
 function titleOf(input, workflowId) {
     const ticket = input?.["ticket"];
@@ -169,8 +168,18 @@ async function metadataOf(context, source) {
     return {
         ticketId: typeof ticketId === "string" && ticketId !== "" ? ticketId : null,
         title: titleOf(input, source.workflowId),
+        ...(source.workflowId === "develop-issue"
+            ? { issueIdentity: issueIdentity(input?.["ticket"]) }
+            : {}),
     };
 }
+async function submittedInput(context, digest) {
+    const document = digest
+        ? await context.authority.queries.document(digest)
+        : undefined;
+    const request = record(JSON.parse(document ?? "null"));
+    return record(request?.["submission"]) ?? null;
+}
 async function listed(context, page) {
     const identifiers = Object.keys(page.snapshot.state.runs)
         .sort()
@@ -181,29 +190,44 @@ async function listed(context, page) {
         views.push(await viewOf(context, { snapshot: page.snapshot, runId }));
     const runs = views.filter((view) => view !== undefined).map(summary);
     return result("run-list", {
+        ...(await queueOverview(context)),
         workflows: context.registry.workflowIds,
+        workflowRefusals: context.workflowRefusals ?? [],
+        ...(Object.keys(context.registry.workflowStages).length === 0
+            ? {}
+            : {
+                workflowStages: context.registry.workflowStages,
+            }),
         runs,
         next: identifiers.length > shown.length ? (shown.at(-1) ?? null) : null,
         worldReports: context.worldReports?.() ?? [],
     });
 }
-export async function status(context, parameters) {
-    const { runId } = parameters;
+function listParameters(parameters) {
     const after = parameters["after"] ?? "";
     const limit = parameters["limit"] ?? 50;
     if (typeof after !== "string" || !wholeNumber(limit, 1) || limit > 500)
+        return undefined;
+    return { after, limit };
+}
+export async function status(context, parameters) {
+    if (parameters["runIds"] !== undefined)
+        return queueRunStatuses(context, parameters["runIds"]);
+    const { runId } = parameters;
+    const page = listParameters(parameters);
+    if (page === undefined)
         return invalidRequest("The status request is not valid.");
     const current = await snapshot(context);
     if (runId === undefined)
-        return listed(context, { snapshot: current, after, limit });
+        return listed(context, { snapshot: current, ...page });
     const named = typeof runId === "string" ? runId : "";
     const view = await viewOf(context, { snapshot: current, runId: named });
     if (view === undefined)
         return failed("unknown-run", { detail: `No run has the ID ${named}.` });
-    const claudeCostUsd = await claudeCost(context, view.runId);
+    const totals = await usageTotals(context, view.runId);
     return result("run-status", {
         run: {
-            ...full({ ...view, claudeCostUsd }),
+            ...full({ ...view, ...totals }),
             outcome: await outcomeOf(context, view),
             ...(await metadataOf(context, {
                 workflowId: view.workflowId,

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

@@ -1,4 +1,5 @@
 import { type Authority, type AuthorityTiming, type Delivery, type EffectSettings, type Refusal } from "../broker/actor/authority.ts";
+import { type WorkflowRefusal } from "../workflow-refusals.ts";
 import { type WorkflowRegistration } from "./registry.ts";
 import { type WorkerPort } from "./worker-port.ts";
 export type { WorkflowRegistration } from "./registry.ts";
@@ -38,6 +39,8 @@ export interface ServiceOptions {
     readonly stateDirectory: string;
     readonly runtimeDirectory: string;
     readonly workflows: readonly WorkflowRegistration[];
+    readonly retainedWorkflows?: readonly WorkflowRegistration[];
+    readonly workflowRefusals?: readonly WorkflowRefusal[];
     readonly delivery: Delivery;
     readonly host?: (ports: HostPorts) => Promise<ServiceHost>;
     readonly timing?: ServiceTiming;

package/dist/src/service/service.js

@@ -2,6 +2,7 @@ import { lstat, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { authorityTiming, openAuthority, } from "../broker/actor/authority.js";
 import { socketAddress } from "../broker/socket-address.js";
+import { workflowRefusals, } from "../workflow-refusals.js";
 import { changeSignal } from "./changes.js";
 import { decision, questions } from "./decision-handler.js";
 import { events } from "./event-handler.js";
@@ -87,6 +88,7 @@ async function started(authority, setup) {
         handle: dispatcher({
             authority,
             registry,
+            workflowRefusals: workflowRefusals(options.workflowRefusals),
             gateway,
             clock,
             changed: changes.next,
@@ -133,7 +135,7 @@ export async function startService(options) {
     if (typeof path !== "string")
         return path;
     const timing = options.timing ?? serviceTiming;
-    const registry = workflowRegistry(options.workflows);
+    const registry = workflowRegistry(options.workflows, options.retainedWorkflows);
     const opening = await openAuthority(options.stateDirectory, {
         delivery: options.delivery,
         timing: timing.authority,

package/dist/src/service/submission-handler.d.ts

@@ -1,4 +1,5 @@
 import { type Fields, type Reply } from "../protocol.ts";
 import { type ServiceContext } from "./replies.ts";
 export declare function runIdentity(commandId: string): string;
+export declare function queueOverview(context: ServiceContext): Promise<Fields>;
 export declare function submissionHandler(context: ServiceContext): (parameters: Fields) => Promise<Reply>;

package/dist/src/service/submission-handler.js

@@ -1,10 +1,12 @@
 import { createHash } from "node:crypto";
+import { handoffChain } from "../authority/handoff-chain.js";
+import { executionCapabilities } from "../execution-pin.js";
 import { setTimeout as delay } from "node:timers/promises";
-import { isIdentifier as isWorkflowIdentifier } from "../authority/commands.js";
+import { isCommandId, isIdentifier as isWorkflowIdentifier, } from "../authority/commands.js";
 import { documentDigest } from "../broker/decision-restore.js";
 import { record } from "../protocol.js";
 import { checkResolution, checkSubmission, normalizedRequest, } from "../submission.js";
-import { committed, failed, invalidRequest, isIdentifier, publicReceipt, rejection, result, } from "./replies.js";
+import { committed, failed, invalidRequest, publicReceipt, rejection, result, } from "./replies.js";
 export function runIdentity(commandId) {
     return `run-${createHash("sha256").update(commandId).digest("hex").slice(0, 32)}`;
 }
@@ -49,7 +51,7 @@ function effectBudget(workflow) {
         return {};
     return {
         effectLimit: workflow.effectLimit,
-        capabilities: JSON.stringify([...workflow.manifest.capabilities].sort()),
+        capabilities: executionCapabilities(workflow.manifest),
     };
 }
 function usable(workflow, workflowId) {
@@ -73,7 +75,13 @@ async function resolved(context, admission) {
     const { workflow, workflowId, commandId, submission } = admission;
     const limit = new AbortController();
     const timer = new AbortController();
-    const request = { workflowId, submission, commandId, signal: limit.signal };
+    const request = {
+        workflowId,
+        submission,
+        commandId,
+        signal: limit.signal,
+        activeTickets: admission.activeTickets,
+    };
     const call = Promise.resolve(request)
         .then((given) => workflow.resolver.resolve(given))
         .then((value) => checkResolution(value) ?? "failure")
@@ -110,6 +118,9 @@ async function admit(context, admission) {
         return unresolved(context, { kind: resolution, commandId });
     if (resolution.kind === "rejected")
         return failed(resolution.code, { commandId, detail: resolution.detail });
+    const limited = capacityRefusal(workflow, admission);
+    if (limited !== undefined)
+        return limited;
     const { input } = resolution;
     if (Buffer.byteLength(input) > context.documentBytes)
         return unresolved(context, { kind: "failure", commandId });
@@ -124,6 +135,12 @@ async function admit(context, admission) {
             input: documentDigest(input),
             resolver: `${workflow.resolver.id}:${workflow.resolver.version}`,
             ...effectBudget(workflow),
+            ...(admission.chain.kind === "handoff"
+                ? {
+                    parentRunId: admission.chain.parentRunId,
+                    chainId: admission.chain.chainId,
+                }
+                : {}),
         },
         documents: [normalized, input],
     });
@@ -137,9 +154,32 @@ async function admit(context, admission) {
         replayed: receipt.kind === "duplicate",
     });
 }
+function admissionRefusal(workflow, request) {
+    const { workflowId, commandId, submission, activeTickets } = request;
+    if (workflowId === "develop-issue" &&
+        typeof submission["ticket"] === "string" &&
+        activeTickets.some((input) => input["ticketId"] === submission["ticket"]))
+        return failed("ticket-active", {
+            commandId,
+            detail: "An active run already works on this ticket.",
+        });
+    if (workflowId === "develop-issue" && submission["ticket"] !== "next")
+        return undefined;
+    return capacityRefusal(workflow, request);
+}
+function capacityRefusal(workflow, request) {
+    if (workflow.admission !== undefined &&
+        request.activeTickets.length >=
+            (workflow.admission === "when-idle" ? 1 : workflow.admission))
+        return failed("workflow-active", {
+            commandId: request.commandId,
+            detail: `The workflow ${request.workflowId} already has an active run.`,
+        });
+    return undefined;
+}
 async function submitted(context, parameters) {
     const { workflowId, commandId } = parameters;
-    if (!isWorkflowIdentifier(workflowId) || !isIdentifier(commandId))
+    if (!isWorkflowIdentifier(workflowId) || !isCommandId(commandId))
         return invalidRequest("The workflow ID or the command ID is not valid.");
     const existing = await context.authority.queries.receipt(commandId);
     if (existing !== undefined)
@@ -147,6 +187,14 @@ async function submitted(context, parameters) {
             workflowId,
             submission: parameters["submission"],
         });
+    const chain = handoffChain(commandId, commandId.startsWith("handoff:")
+        ? await context.authority.queries.runOrigins()
+        : {});
+    if (chain.kind === "refused")
+        return failed(chain.reason, {
+            commandId,
+            detail: "A hand-off chain permits at most five runs and requires a recorded parent.",
+        });
     const found = usable(context.registry.byId(workflowId), workflowId);
     if (found.kind === "unusable")
         return found.reply;
@@ -161,32 +209,63 @@ async function submitted(context, parameters) {
     });
     if (check.kind === "rejected")
         return failed(check.code, { commandId, detail: check.detail });
-    if (found.workflow.admission === "when-idle" &&
-        (await activeWorkflow(context, workflowId)))
-        return failed("workflow-active", {
-            commandId,
-            detail: `The workflow ${workflowId} already has an active run.`,
-        });
+    const activeTickets = await activeWorkflow(context, workflowId);
+    const refusal = admissionRefusal(found.workflow, {
+        workflowId,
+        commandId,
+        submission: check.submission,
+        activeTickets,
+    });
+    if (refusal !== undefined)
+        return refusal;
     return admit(context, {
+        chain,
         workflow: found.workflow,
         workflowId,
         commandId,
         submission: check.submission,
         normalized: check.normalized,
+        activeTickets,
     });
 }
 async function activeWorkflow(context, workflowId) {
     const workflows = await context.authority.queries.workflowIds();
     const state = await context.authority.state();
-    return Object.values(state.runs).some((run) => workflows[run.runId] === workflowId &&
+    const runs = Object.values(state.runs).filter((run) => workflows[run.runId] === workflowId &&
         !["completed", "failed", "cancelled"].includes(run.status));
+    return Promise.all(runs.map(async (run) => {
+        const digest = state.details[run.runId]?.input;
+        const text = digest
+            ? await context.authority.queries.document(digest)
+            : undefined;
+        return record(JSON.parse(text ?? "null")) ?? {};
+    }));
+}
+export async function queueOverview(context) {
+    const workflow = context.registry.byId("develop-issue");
+    if (workflow?.admission === undefined)
+        return {};
+    const active = await activeWorkflow(context, "develop-issue");
+    return {
+        queue: {
+            lanes: workflow.admission === "when-idle" ? 1 : workflow.admission,
+            busy: active.length,
+            skipped: [
+                ...active.flatMap((input) => typeof input["ticketId"] === "string"
+                    ? [{ ticketId: input["ticketId"], reason: "ticket-active" }]
+                    : []),
+                ...(workflow.resolver.skippedTickets?.() ?? []),
+            ],
+        },
+    };
 }
 export function submissionHandler(context) {
     const pending = new Map();
     return (parameters) => {
         const keys = [`command:${String(parameters["commandId"])}`];
         const workflowId = String(parameters["workflowId"]);
-        if (context.registry.byId(workflowId)?.admission === "when-idle")
+        if (workflowId === "develop-issue" ||
+            context.registry.byId(workflowId)?.admission !== undefined)
             keys.push(`workflow:${workflowId}`);
         const next = () => submitted(context, parameters);
         const previous = keys

package/dist/src/service/worker-totals.d.ts

@@ -0,0 +1,3 @@
+import { type WorkerTotals } from "../worker-usage.ts";
+import type { ServiceContext } from "./replies.ts";
+export declare function usageTotals(context: ServiceContext, runId: string): Promise<WorkerTotals>;

package/dist/src/service/worker-totals.js

@@ -0,0 +1,52 @@
+import { record } from "../protocol.js";
+import { priceOf, usageOf, tokenCount, workerTotals, } from "../worker-usage.js";
+function reportFields(text) {
+    try {
+        return record(JSON.parse(text ?? "null")) ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+function attemptsOf(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.flatMap((entry) => {
+        const fields = record(entry) ?? {};
+        const attempt = tokenCount(fields["attempt"]);
+        const model = fields["model"];
+        if (attempt === null ||
+            attempt === 0 ||
+            (model !== null && typeof model !== "string"))
+            return [];
+        return [
+            {
+                attempt,
+                model,
+                usage: usageOf(fields["usage"]),
+                costUsd: priceOf(fields["costUsd"]),
+                estimatedCostUsd: priceOf(fields["estimatedCostUsd"]),
+            },
+        ];
+    });
+}
+export async function usageTotals(context, runId) {
+    const { effects, queries } = context.authority;
+    const operations = (await effects.operations(runId)).filter((operation) => operation.capability === "claude" &&
+        ["completed", "failed", "stopped", "cancelled", "refused"].includes(operation.status));
+    const turns = [];
+    for (const operation of operations) {
+        const report = reportFields(operation.result === null
+            ? undefined
+            : await queries.document(operation.result));
+        const attempts = attemptsOf(report["attempts"]);
+        turns.push({
+            ...(attempts === undefined ? {} : { attempts }),
+            operationId: operation.operationId,
+            usage: usageOf(report["usage"]),
+            costUsd: priceOf(report["costUsd"]),
+            estimatedCostUsd: priceOf(report["estimatedCostUsd"]),
+        });
+    }
+    return workerTotals(turns);
+}

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

@@ -39,6 +39,14 @@ export interface GateRequest {
     readonly gateId: string;
     readonly kind: "question" | "approval";
     readonly prompt: string;
+    readonly expiresAt?: string;
+}
+export type HandoffValue = string | number | boolean | null | readonly HandoffValue[] | {
+    readonly [key: string]: HandoffValue;
+};
+export interface HandoffRequest {
+    readonly workflowId: string;
+    readonly input: Readonly<Record<string, HandoffValue>>;
 }
 export type GateResult = {
     readonly kind: "opened";
@@ -53,5 +61,6 @@ export type GateResult = {
 export interface StepBridge {
     readonly effect: (request: ProtectedRequest) => Promise<ProtectedResult>;
     readonly gate: (request: GateRequest) => Promise<GateResult>;
+    readonly handoff?: (request: HandoffRequest) => Promise<ProtectedResult>;
 }
 export declare function isStepBridge(value: unknown): value is StepBridge;

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

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

package/dist/src/steps/handoff.js

@@ -0,0 +1,13 @@
+import { isStepBridge, stepBridgeKey, } from "../step-bridge.js";
+export async function handoff(request) {
+    "use step";
+    const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));
+    if (!isStepBridge(bridge) || bridge.handoff === undefined)
+        throw new Error("cloving-host-unavailable");
+    const result = await bridge.handoff(request);
+    if (result.kind !== "completed")
+        throw new Error(result.reason ?? result.kind);
+    if (result.result === null)
+        throw new Error("handoff-result-missing");
+    return result.result;
+}

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.d.ts

@@ -0,0 +1,8 @@
+export type TicketStatus = {
+    readonly kind: "complete";
+} | {
+    readonly kind: "partial";
+    readonly remaining: readonly string[];
+};
+export declare function ticketStatus(summary: string, preserved?: unknown): TicketStatus;
+export declare function isTicketStatus(value: unknown): value is "complete" | "partial";

package/dist/src/ticket-status.js

@@ -0,0 +1,48 @@
+function parsedStatus(summary) {
+    const lines = summary.trimEnd().split(/\r?\n/);
+    if (lines.filter((line) => /^Ticket status:/i.test(line)).length !== 1)
+        return undefined;
+    const status = lines.pop();
+    if (status === "Ticket status: complete")
+        return { kind: "complete" };
+    if (status !== "Ticket status: partial")
+        return undefined;
+    const heading = lines.lastIndexOf("Remaining:");
+    const items = heading === -1
+        ? []
+        : lines.slice(heading + 1).filter((line) => line.trim() !== "");
+    if (items.length === 0 || items.some((line) => !/^- \S.*$/.test(line)))
+        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) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const kind = Reflect.get(value, "kind");
+    if (kind === "complete")
+        return { kind };
+    const remaining = Reflect.get(value, "remaining");
+    if (kind !== "partial" ||
+        !Array.isArray(remaining) ||
+        remaining.length === 0 ||
+        remaining.some((item) => typeof item !== "string" || item.trim() === "" || /[\r\n]/.test(item)))
+        return undefined;
+    return { kind, remaining: remaining.map(String) };
+}
+export function ticketStatus(summary, preserved) {
+    const parsed = preserved === undefined
+        ? parsedStatus(summary)
+        : preservedStatus(preserved);
+    if (parsed !== undefined)
+        return parsed;
+    return {
+        kind: "partial",
+        remaining: ["The worker report has no ticket status line."],
+    };
+}
+export function isTicketStatus(value) {
+    return value === "complete" || value === "partial";
+}

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

@@ -0,0 +1,21 @@
+import { type WorkerUsage } from "./worker-usage.ts";
+export interface TokenPrice {
+    readonly input: number;
+    readonly cachedInput: number;
+    readonly output: number;
+}
+export type TokenPrices = Readonly<Record<string, TokenPrice>>;
+export declare const builtInPriceTable: {
+    readonly date: string;
+    readonly source: string;
+    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 replaceCommandModel(command: readonly string[], model: string): readonly string[];
+export declare function estimatedCostUsd(usage: WorkerUsage, pricing: {
+    readonly worker: "claude" | "codex";
+    readonly price: TokenPrice | undefined;
+}): number | null;