cloving 1.3.0 → 1.5.0

package/dist/src/daemon/settings-reload.js

@@ -0,0 +1,82 @@
+import { turnHarness } from "../harness-defaults.js";
+import { reloadedSettingFields, } from "../project-settings.js";
+import { record } from "../protocol.js";
+import { parseFallbackModels, parseTokenPrices } from "../token-prices.js";
+import { isProfilesFile } from "../turn-profile.js";
+import { checkedProfiles } from "./worker-profile.js";
+export function turnSettingsSource(initial) {
+    let current = initial;
+    return {
+        current: () => current,
+        replace: (next) => {
+            current = next;
+        },
+    };
+}
+function turnSettingsOf(value) {
+    const fields = record(value) ?? {};
+    const profiles = { profiles: fields["profiles"] };
+    if (!isProfilesFile(profiles))
+        return undefined;
+    try {
+        return {
+            profiles: profiles.profiles,
+            fallbackModels: parseFallbackModels(JSON.stringify(fields["fallbackModels"])),
+            tokenPrices: parseTokenPrices(JSON.stringify(fields["tokenPrices"])),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function digestsOf(value) {
+    const fields = record(value);
+    if (fields === undefined)
+        return undefined;
+    const entries = Object.entries(fields);
+    const digests = entries.filter((entry) => typeof entry[1] === "string");
+    return digests.length === entries.length
+        ? Object.fromEntries(digests)
+        : undefined;
+}
+export function reloadedSettings(output) {
+    const turnSettings = turnSettingsOf(output?.["turnSettings"]);
+    const settingDigests = digestsOf(output?.["settingDigests"]);
+    return turnSettings === undefined || settingDigests === undefined
+        ? undefined
+        : { turnSettings, settingDigests };
+}
+export function settingChanges(current, next) {
+    const changed = [...new Set([...Object.keys(current), ...Object.keys(next)])]
+        .filter((field) => current[field] !== next[field])
+        .sort();
+    return {
+        reloadedFields: changed.filter((field) => reloadedSettingFields.includes(field)),
+        restartFields: changed.filter((field) => !reloadedSettingFields.includes(field)),
+    };
+}
+export function keptDigests(current, change) {
+    return {
+        ...current,
+        ...Object.fromEntries(Object.entries(change.digests).filter(([field]) => change.reloadedFields.includes(field))),
+    };
+}
+function newHarness(settings, profiles) {
+    const started = new Set([{}, ...Object.values(settings.profiles ?? {})].map((profile) => turnHarness(settings, profile).worker));
+    return Object.values(profiles)
+        .map((profile) => turnHarness(settings, profile).worker)
+        .find((name) => !started.has(name));
+}
+export function profileRefusal(settings, turnSettings) {
+    try {
+        checkedProfiles(settings, turnSettings.profiles);
+    }
+    catch (error) {
+        const detail = String(Reflect.get(Object(error), "message"));
+        return { code: detail.replace(/:.*$/s, ""), detail };
+    }
+    const added = newHarness(settings, turnSettings.profiles);
+    return added === undefined
+        ? undefined
+        : { code: "harness-no-worker", detail: `harness-no-worker: ${added}` };
+}

package/dist/src/daemon/ticket-registration.d.ts

@@ -1,10 +1,7 @@
 import { type DeclaredWorkflow } from "../workflow-declaration.ts";
 import type { Resolver, WorkflowRegistration } from "../service/registry.ts";
+import { type SubmissionContract } from "../submission.ts";
 import type { LocalCommands } from "../command-settings.ts";
-export declare const ticketWorkflow: "develop-ticket";
-export declare const promptWorkflow: "develop-prompt";
-export declare const issueWorkflow: "develop-issue";
-export declare const ticketCapabilities: string[];
 export type TicketRegistrations = {
     readonly kind: "admitted";
     readonly registrations: readonly WorkflowRegistration[];
@@ -24,10 +21,8 @@ export interface TicketRegistration extends Omit<WorkflowRegistration, "manifest
     readonly effectLimit: number;
     readonly capabilities?: readonly string[];
 }
-export declare function ticketResolver(source: TicketSource): Resolver;
-export declare function issueResolver(source: TicketSource): Resolver;
-export declare function promptResolver(repository: string): Resolver;
 export declare function ticketRegistrationTable(source: TicketSource, declarations?: readonly DeclaredWorkflow[]): readonly TicketRegistration[];
+export declare function declaredResolver(source: TicketSource, contract: SubmissionContract): Resolver;
 export declare function ticketRegistrations(manifests: Readonly<Record<string, string | undefined>>, options: {
     readonly table: readonly TicketRegistration[];
     readonly bundleDigest?: string;

package/dist/src/daemon/ticket-registration.js

@@ -1,45 +1,34 @@
-import { createHash } from "node:crypto";
 import { admitCompiled } from "../cli/validate.js";
 import { isCommandWaits, workflowQueueRefusals, } from "../workflow-declaration.js";
 import { ticketCommandText, ticketText } from "./ticket-source.js";
 import { declaredInput } from "./declared-input.js";
-import { bundledWorkflowIds } from "../workflow-discovery.js";
 import { declaredManifest } from "../execution-pin.js";
 import { record } from "../protocol.js";
 import { hasTicketField } from "../submission.js";
 import { issueIdentity } from "../issue-identity.js";
 import { ticketDependencyWaits, TicketDependencyReadError, } from "./ticket-dependency-waits.js";
-export const ticketWorkflow = bundledWorkflowIds.ticket;
-export const promptWorkflow = bundledWorkflowIds.prompt;
-export const issueWorkflow = bundledWorkflowIds.issue;
-export const ticketCapabilities = ["claude", "github"];
+const defaultCapabilities = ["claude", "github"];
 const ticketIdentifier = /^[A-Za-z0-9._:-]{1,64}$/;
 function rejected(code, detail) {
     return { kind: "rejected", code, detail };
 }
-function digest(commandId) {
-    return createHash("sha256").update(commandId).digest("hex");
-}
 async function ticket(source, request) {
-    const { command, repository } = source;
+    const { command } = source;
     const ticketId = String(request.submission["ticket"]);
     if (ticketId === "next")
         return nextTicket(source, request);
     if (!ticketIdentifier.test(ticketId))
         return rejected("invalid-ticket-id", "A ticket ID has letters, digits and the characters . _ : - only.");
     if (command === undefined)
-        return rejected("ticket-source-not-configured", "The daemon has no ticket command. Set CLOVING_TICKET_COMMAND, or use the workflow develop-prompt.");
+        return rejected("ticket-source-not-configured", "The daemon has no ticket command. Set CLOVING_TICKET_COMMAND.");
     const read = await ticketText(command, { ticketId, signal: request.signal });
     if (read.kind === "failed")
         return rejected("ticket-not-available", read.detail);
-    const name = ticketId.toLowerCase().replace(/[^a-z0-9-]/g, "-");
     return {
         kind: "resolved",
         input: {
-            cycleId: `${name}-${digest(request.commandId).slice(0, 8)}`,
             ticketId,
             ticket: read.text,
-            repository,
         },
     };
 }
@@ -63,17 +52,10 @@ async function nextTicket(source, request) {
         return rejected("invalid-ticket-id", "The next-ticket command must print one valid ticket ID other than next.");
     return ticket(source, { ...request, submission: { ticket: selected.text } });
 }
-export function ticketResolver(source) {
-    return {
-        id: "ticket-command",
-        version: "1",
-        resolve: (request) => ticket(source, request),
-    };
-}
-export function issueResolver(source) {
+function ticketResolver(source) {
     const waits = ticketDependencyWaits(source);
     return {
-        id: "issue-command",
+        id: "ticket-command",
         version: "1",
         skippedTickets: waits.skipped,
         resolve: (request) => issueTicket({ source, waits }, request).catch((error) => {
@@ -107,66 +89,18 @@ async function issueTicket(context, request) {
         return rejected("ticket-dependency-open", `Ticket ${String(input["ticketId"])} needs open issues: ${dependencies.map((id) => `#${id}`).join(", ")}.`);
     return {
         kind: "resolved",
-        input: { ...input, delivery: "pull-request" },
-    };
-}
-export function promptResolver(repository) {
-    return {
-        id: "ticket-prompt",
-        version: "1",
-        resolve: (request) => Promise.resolve({
-            kind: "resolved",
-            input: {
-                cycleId: `task-${digest(request.commandId).slice(0, 12)}`,
-                ticket: String(request.submission["prompt"]),
-                repository,
-            },
-        }),
+        input,
     };
 }
 export function ticketRegistrationTable(source, declarations = []) {
-    return [
-        {
-            workflowId: ticketWorkflow,
-            functionName: "developTicket",
-            effectLimit: 8,
-            handoffs: [],
-            submission: { maximumBytes: 4_096, fields: { ticket: "string" } },
-            resolver: ticketResolver(source),
-        },
-        {
-            workflowId: issueWorkflow,
-            functionName: "developTicket",
-            effectLimit: 20,
-            handoffs: [],
-            submission: { maximumBytes: 4_096, fields: { ticket: "string" } },
-            resolver: issueResolver(source),
-        },
-        {
-            workflowId: bundledWorkflowIds.prd,
-            functionName: "developPrd",
-            effectLimit: 8,
-            handoffs: [issueWorkflow],
-            submission: { maximumBytes: 65_536, fields: { prompt: "string" } },
-            resolver: promptResolver(source.repository),
-        },
-        {
-            workflowId: promptWorkflow,
-            functionName: "developTicket",
-            effectLimit: 8,
-            handoffs: [],
-            submission: { maximumBytes: 65_536, fields: { prompt: "string" } },
-            resolver: promptResolver(source.repository),
-        },
-        ...declarations.map(({ input, ...declaration }) => ({
-            ...declaration,
-            submission: input,
-            resolver: declaredResolver(source, input),
-        })),
-    ];
+    return declarations.map(({ input, ...declaration }) => ({
+        ...declaration,
+        submission: input,
+        resolver: declaredResolver(source, input),
+    }));
 }
-function declaredResolver(source, contract) {
-    const tickets = hasTicketField(contract) ? issueResolver(source) : undefined;
+export function declaredResolver(source, contract) {
+    const tickets = hasTicketField(contract) ? ticketResolver(source) : undefined;
     return {
         id: "declared-input",
         version: "1",
@@ -202,7 +136,7 @@ export async function ticketRegistrations(manifests, options) {
         return { kind: "rejected", detail: refusal };
     const registrations = [];
     for (const row of options.table) {
-        const { functionName, capabilities = ticketCapabilities, ...registration } = row;
+        const { functionName, capabilities = defaultCapabilities, ...registration } = row;
         const manifest = manifests[functionName];
         if (manifest === undefined)
             return {
@@ -254,7 +188,7 @@ function registrationRefusal(table, commands) {
 function commandRegistrationRefusal(row, commands) {
     if (Object.hasOwn(row, "commandWaits") &&
         !isCommandWaits(row.commandWaits, {
-            capabilities: row.capabilities ?? ticketCapabilities,
+            capabilities: row.capabilities ?? defaultCapabilities,
             commands: row.commands ?? [],
         }))
         return `invalid-command-waits: ${row.workflowId}`;

package/dist/src/daemon/turn-attempt-journal.d.ts

@@ -0,0 +1,38 @@
+import { type TurnEnd, type TurnProgress } from "./claude-turn.ts";
+import { attemptCommand, type Attempts } from "./turn-attempts.ts";
+declare function attemptEntry(attempts: Attempts, selected: ReturnType<typeof attemptCommand>): {
+    startedAt: string;
+    resumedAfter?: "daemon-restart";
+    attempt: number;
+    fallbackReason?: string;
+    budgetUsd?: number;
+    turnStartCommit: string | null;
+    model: string | null;
+};
+export declare function prepareAttempt(attempts: Attempts): Promise<{
+    entry: {
+        startedAt: string;
+        resumedAfter?: "daemon-restart";
+        attempt: number;
+        fallbackReason?: string;
+        budgetUsd?: number;
+        turnStartCommit: string | null;
+        model: string | null;
+    };
+    selected: {
+        fallbackReason?: string;
+        model: string | null;
+        budgetUsd?: number;
+        command: readonly string[];
+    };
+    folder: string;
+} | undefined>;
+export declare function attemptJournal(attempts: Attempts, entry: ReturnType<typeof attemptEntry>): {
+    progress: (snapshot: TurnProgress) => Promise<void>;
+    running: (identifier: number | null) => Promise<void>;
+};
+export declare function recordedEnd(attempts: Attempts, completion: {
+    readonly processId: number | null;
+    readonly end: TurnEnd;
+}): Promise<void>;
+export {};

package/dist/src/daemon/turn-attempt-journal.js

@@ -0,0 +1,136 @@
+import { join } from "node:path";
+import { mkdir } from "node:fs/promises";
+import { readRecord, writeRecord } from "./operation-journal.js";
+import { capacityRefusal, } from "./claude-turn.js";
+import { attemptCommand, attemptUsage, attemptCost, } from "./turn-attempts.js";
+function written(folder, entry) {
+    return writeRecord(folder, { ...entry, permissions: "private" });
+}
+function attemptEntry(attempts, selected) {
+    const attempt = attempts.ends.length + 1;
+    const resume = attempts.options.resume;
+    return {
+        ...attempts.options.metadata,
+        turnStartCommit: attempts.turnStartCommit,
+        model: selected.model,
+        ...(selected.budgetUsd === undefined
+            ? {}
+            : { budgetUsd: selected.budgetUsd }),
+        ...(selected.fallbackReason === undefined
+            ? {}
+            : { fallbackReason: selected.fallbackReason }),
+        attempt,
+        ...(resume !== undefined && attempt === resume.ends.length + 1
+            ? { resumedAfter: "daemon-restart" }
+            : {}),
+        startedAt: attempt === 1 ? attempts.startedAt : new Date().toISOString(),
+    };
+}
+export async function prepareAttempt(attempts) {
+    const selected = attemptCommand(attempts, attempts.ends.length + 1);
+    if (selected.budgetUsd === 0) {
+        attempts.failure = "claude-turn-budget-exhausted";
+        return undefined;
+    }
+    const entry = attemptEntry(attempts, selected);
+    const folder = entry.attempt === 1
+        ? attempts.start.folder
+        : join(attempts.start.folder, `attempt-${String(entry.attempt)}`);
+    await written(attempts.start.folder, {
+        name: "started.json",
+        value: {
+            ...entry,
+            startedAt: attempts.startedAt,
+            phase: "starting",
+            processId: null,
+        },
+    });
+    await mkdir(folder, { recursive: true, mode: 0o700 });
+    return { entry, selected, folder };
+}
+function progressFields(attempts, progress) {
+    const result = progress?.result;
+    const end = { exitCode: null, result };
+    if (result === undefined)
+        return {
+            sessionId: progress?.sessionId ?? null,
+            sessionCostUsd: null,
+            costUsd: null,
+        };
+    return {
+        sessionId: progress?.sessionId ?? null,
+        sessionCostUsd: result.costUsd,
+        costUsd: attemptCost([...attempts.ends, end], attempts.ends.length),
+        usage: result.usage,
+        turns: result.turns,
+    };
+}
+export function attemptJournal(attempts, entry) {
+    let saved = Promise.resolve();
+    let progress;
+    let processId = null;
+    const save = () => {
+        const value = {
+            ...entry,
+            phase: "running",
+            processId,
+            ...progressFields(attempts, progress),
+        };
+        saved = saved.then(() => written(attempts.start.folder, {
+            name: `attempt-${String(entry.attempt)}.json`,
+            value,
+        }));
+        return saved;
+    };
+    return {
+        progress: (snapshot) => {
+            progress = snapshot;
+            return save();
+        },
+        running: async (identifier) => {
+            processId = identifier;
+            await written(attempts.start.folder, {
+                name: "started.json",
+                value: {
+                    ...entry,
+                    startedAt: attempts.startedAt,
+                    phase: "running",
+                    processId,
+                },
+            });
+            await save();
+        },
+    };
+}
+export async function recordedEnd(attempts, completion) {
+    const { start, ends, options } = attempts;
+    const { processId, end } = completion;
+    const attempt = ends.length;
+    const selected = attemptCommand(attempts, attempt);
+    const name = `attempt-${String(attempt)}.json`;
+    const record = await readRecord(start.folder, name);
+    const started = typeof record === "object" && record !== null ? record : {};
+    const startedAt = Reflect.get(started, "startedAt");
+    if (typeof startedAt !== "string")
+        throw new Error("attempt-start-time-missing");
+    await written(start.folder, {
+        name,
+        value: {
+            ...started,
+            ...options.metadata,
+            turnStartCommit: attempts.turnStartCommit,
+            ...attemptUsage(attempts, { end, attempt }),
+            ...(selected.fallbackReason === undefined
+                ? {}
+                : { fallbackReason: selected.fallbackReason }),
+            attempt,
+            processId,
+            startedAt,
+            endedAt: new Date().toISOString(),
+            exitCode: end.exitCode,
+            capacity: capacityRefusal(end.result),
+            sessionCostUsd: end.result?.costUsd ?? null,
+            turns: end.result?.turns ?? null,
+        },
+    });
+}

package/dist/src/daemon/turn-attempts.d.ts

@@ -0,0 +1,47 @@
+import { usageOf, type WorkerAttemptUsage } from "../worker-usage.ts";
+import { type TokenPrices } from "../token-prices.ts";
+import { type TurnEnd, type TurnStart } from "./claude-turn.ts";
+import type { TurnResume } from "./claude-recovery.ts";
+export interface RetrySettings {
+    readonly tokenPrices?: TokenPrices;
+    readonly fallbackModels?: readonly string[];
+    readonly retryDelay?: (milliseconds: number, signal: AbortSignal) => Promise<void>;
+}
+export interface RetryOptions extends RetrySettings {
+    readonly resume?: TurnResume;
+    readonly stopping?: AbortController;
+    readonly stopMilliseconds?: number;
+    readonly metadata: Readonly<Record<string, unknown>>;
+}
+export interface Attempts {
+    failure?: string;
+    readonly start: TurnStart;
+    readonly turnStartCommit: string | null;
+    readonly startedAt: string;
+    readonly options: RetryOptions;
+    readonly stopping: AbortController;
+    readonly grace: {
+        milliseconds: number;
+    };
+    readonly ends: TurnEnd[];
+}
+export declare function total(values: readonly (number | null)[]): number | null;
+export declare function combined(attempts: Attempts): TurnEnd;
+export declare function attemptCommand(attempts: Attempts, attempt: number): {
+    fallbackReason?: string;
+    model: string | null;
+    budgetUsd?: number;
+    command: readonly string[];
+};
+export declare function attemptUsage(attempts: Attempts, completion: {
+    readonly end: TurnEnd;
+    readonly attempt: number;
+}): WorkerAttemptUsage;
+export declare function sessionCost(ends: readonly TurnEnd[]): number | null;
+export declare function attemptCost(ends: readonly TurnEnd[], index: number): number | null;
+export declare function attemptEstimate(attempts: Attempts, result: {
+    readonly end: TurnEnd;
+    readonly model: string | null;
+    readonly usage: ReturnType<typeof usageOf>;
+}): number | null;
+export declare function kindOf(attempts: Attempts, end: TurnEnd): import("../worker-usage.ts").RetryKind | null;

package/dist/src/daemon/turn-attempts.js

@@ -0,0 +1,166 @@
+import { priceOf, sumUsage, usageOf, } from "../worker-usage.js";
+import { commandModel, replaceCommandModel, estimatedCostUsd, priceForModel, } from "../token-prices.js";
+import { capacityRefusal, retryKind, } from "./claude-turn.js";
+import { nativeHarness } from "../harness-defaults.js";
+import { profileCommand } from "../turn-profile.js";
+export function total(values) {
+    if (values.includes(null))
+        return null;
+    return priceOf(values.reduce((sum, value) => sum + (value ?? 0), 0));
+}
+export function combined(attempts) {
+    const { ends } = attempts;
+    const last = ends.at(-1) ?? { exitCode: null, result: undefined };
+    const result = last.result ?? ends.find((end) => end.result)?.result;
+    if (result === undefined)
+        return last;
+    return {
+        ...last,
+        result: {
+            ...result,
+            attempts: ends.map((end, index) => attemptUsage(attempts, { end, attempt: index + 1 })),
+            ...(last.result === undefined ? { failed: true, text: "" } : {}),
+            usage: sumUsage(ends.map((end) => end.result?.usage ?? usageOf(null))),
+            costUsd: (attempts.start.worker ?? "claude") === "claude"
+                ? sessionCost(ends)
+                : total(ends.map((end) => end.result?.costUsd ?? null)),
+            turns: total(ends.map((end) => end.result?.turns ?? null)),
+        },
+    };
+}
+function selectedCommand(attempts, attempt) {
+    const { start, options } = attempts;
+    const original = start.command;
+    const previous = attempts.ends[attempt - 2];
+    if (options.resume !== undefined &&
+        attempt === options.resume.ends.length + 1) {
+        const model = previous?.result?.model;
+        return {
+            command: model == null ? original : replaceCommandModel(original, model),
+            fallback: undefined,
+        };
+    }
+    const ordinal = attempt -
+        attempts.ends
+            .slice(0, attempt - 1)
+            .filter((end) => end.resumedAfter !== undefined).length;
+    const fallback = previous !== undefined && kindOf(attempts, previous) === "capacity"
+        ? options.fallbackModels?.[ordinal - 3]
+        : undefined;
+    return {
+        command: fallback === undefined
+            ? original
+            : replaceCommandModel(original, fallback),
+        fallback,
+    };
+}
+export function attemptCommand(attempts, attempt) {
+    const { start } = attempts;
+    const { command: selected, fallback } = selectedCommand(attempts, attempt);
+    const budgetUsd = remainingBudget(attempts);
+    const command = budgetUsd === undefined
+        ? selected
+        : profileCommand(selected, { maxBudgetUsd: budgetUsd });
+    const model = start.output === "text" ? null : commandModel(command);
+    return {
+        command,
+        ...(budgetUsd === undefined ? {} : { budgetUsd }),
+        model,
+        ...(fallback !== undefined && model === null
+            ? { fallbackReason: "fallback-model-unavailable" }
+            : {}),
+    };
+}
+export function attemptUsage(attempts, completion) {
+    const { end, attempt } = completion;
+    const result = end.result ?? {
+        model: null,
+        usage: usageOf(null),
+        costUsd: null,
+        pricingModel: undefined,
+    };
+    const model = result.model ?? attemptCommand(attempts, attempt).model;
+    const usage = result.usage;
+    return {
+        attempt,
+        ...(end.resumedAfter === undefined
+            ? {}
+            : { resumedAfter: end.resumedAfter }),
+        retryKind: kindOf(attempts, end),
+        model,
+        ...(end.result?.models === undefined ? {} : { models: end.result.models }),
+        usage,
+        costUsd: (attempts.start.worker ?? "claude") === "claude"
+            ? attemptCost(attempts.ends, attempt - 1)
+            : result.costUsd,
+        estimatedCostUsd: attemptEstimate(attempts, { end, model, usage }),
+    };
+}
+export function sessionCost(ends) {
+    const sessions = new Map();
+    ends.forEach((end, index) => {
+        sessions.set(end.result?.sessionId ?? index, end.result?.costUsd ?? null);
+    });
+    return total([...sessions.values()]);
+}
+export function attemptCost(ends, index) {
+    const result = ends[index]?.result;
+    if (result?.costUsd == null)
+        return null;
+    const earlier = result.sessionId === null
+        ? undefined
+        : ends
+            .slice(0, index)
+            .findLast((end) => end.result?.sessionId === result.sessionId);
+    if (earlier === undefined)
+        return result.costUsd;
+    const cost = earlier.result?.costUsd;
+    return cost == null
+        ? null
+        : priceOf(Number((result.costUsd - cost).toFixed(12)));
+}
+function remainingBudget(attempts) {
+    if ((attempts.start.worker ?? "claude") !== "claude" ||
+        attempts.start.output === "text")
+        return undefined;
+    const budget = commandBudget(attempts.start.command);
+    if (budget === undefined)
+        return undefined;
+    const spent = sessionCost(attempts.ends);
+    return Math.max(0, Number((budget - (spent ?? 0)).toFixed(12)));
+}
+function commandBudget(original) {
+    const separator = original.indexOf("--");
+    const command = separator < 0 ? original : original.slice(0, separator);
+    const index = command.findLastIndex((part) => part === "--max-budget-usd" || part.startsWith("--max-budget-usd="));
+    if (index < 0)
+        return undefined;
+    const argument = command[index] ?? "";
+    const budget = Number(argument.includes("=") ? argument.split("=")[1] : command[index + 1]);
+    if (!Number.isFinite(budget) || budget < 0)
+        return undefined;
+    return budget;
+}
+export function attemptEstimate(attempts, result) {
+    const worker = attempts.start.worker ?? "claude";
+    if (!nativeHarness(worker))
+        return null;
+    const models = result.end.result?.models;
+    const prices = attempts.options.tokenPrices ?? {};
+    return estimatedCostUsd(result.usage, worker === "gemini" && models !== undefined
+        ? { worker, models, prices }
+        : {
+            worker,
+            price: priceForModel(prices, result.end.result?.pricingModel === undefined
+                ? result.model
+                : result.end.result.pricingModel),
+        });
+}
+export function kindOf(attempts, end) {
+    const { worker, output } = attempts.start;
+    if (output === "text" || !["claude", "codex"].includes(worker ?? "claude"))
+        return null;
+    if (worker !== "codex")
+        return end.retryKind ?? retryKind(end.result);
+    return capacityRefusal(end.result) ? "capacity" : null;
+}

package/dist/src/daemon/turn-details.d.ts

@@ -0,0 +1,4 @@
+import { type SweepSettings } from "./record-sweep.ts";
+import { type RunTurns, type TurnDetails } from "../record-retention.ts";
+export type TurnDetailsSettings = Pick<SweepSettings, "directory" | "retention" | "runs" | "now">;
+export declare function turnDetailsPlace(settings: TurnDetailsSettings): (turns: RunTurns) => Promise<TurnDetails | undefined>;