cloving 1.1.0 → 1.2.0

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

@@ -1,13 +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,
@@ -39,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,
@@ -78,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),
@@ -87,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,
@@ -122,17 +129,17 @@ 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;
-    const ticketStatus = event?.payload["ticketStatus"];
+    const { ticketStatus, promotionId, outcomeReason, issueUpdate } = payload;
     return {
         kind,
-        reason: event?.payload["outcomeReason"] ?? null,
+        reason: outcomeReason ?? null,
+        ...(promotionId === undefined ? {} : { promotionId }),
         ...(ticketStatus === undefined ? {} : { ticketStatus }),
-        ...(event?.payload["issueUpdate"] === "failed"
-            ? { issueUpdate: "failed" }
-            : {}),
+        ...(issueUpdate === "failed" ? { issueUpdate } : {}),
     };
 }
 function titleOf(input, workflowId) {
@@ -161,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()
@@ -173,21 +190,36 @@ 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)

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.js

@@ -1,5 +1,5 @@
 import { record } from "../protocol.js";
-import { priceOf, usageOf, workerTotals, } from "../worker-usage.js";
+import { priceOf, usageOf, tokenCount, workerTotals, } from "../worker-usage.js";
 function reportFields(text) {
     try {
         return record(JSON.parse(text ?? "null")) ?? {};
@@ -8,6 +8,28 @@ function reportFields(text) {
         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" &&
@@ -17,7 +39,9 @@ export async function usageTotals(context, runId) {
         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"]),

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

@@ -11,8 +11,10 @@ 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 replaceCommandModel(command: readonly string[], model: string): readonly string[];
 export declare function estimatedCostUsd(usage: WorkerUsage, pricing: {
     readonly worker: "claude" | "codex";
     readonly price: TokenPrice | undefined;

package/dist/src/token-prices.js

@@ -36,26 +36,58 @@ 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) {
     const { worker, price } = pricing;

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

@@ -4,11 +4,19 @@ export interface WorkerUsage {
     readonly output_tokens: number | null;
 }
 export interface WorkerTurnUsage {
+    readonly attempts?: readonly WorkerAttemptUsage[];
     readonly estimatedCostUsd: number | null;
     readonly operationId: string;
     readonly usage: WorkerUsage;
     readonly costUsd: number | null;
 }
+export interface WorkerAttemptUsage {
+    readonly attempt: number;
+    readonly model: string | null;
+    readonly usage: WorkerUsage;
+    readonly costUsd: number | null;
+    readonly estimatedCostUsd: number | null;
+}
 export interface WorkerTotals {
     readonly estimatedCostUsd: number | null;
     readonly workerTurns: readonly WorkerTurnUsage[];
@@ -19,4 +27,5 @@ 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;

package/dist/src/worker-usage.js

@@ -28,7 +28,7 @@ export function sumUsage(values) {
         output_tokens: total(values.map((value) => value.output_tokens)),
     };
 }
-function sumPrices(values) {
+export function sumPrices(values) {
     const prices = values.map(priceOf);
     if (prices.length === 0 || prices.includes(null))
         return null;

package/dist/src/workflow-admission.d.ts

@@ -27,6 +27,7 @@ export interface ExecutionManifest {
     readonly workflowId: string;
     readonly steps: readonly string[];
     readonly capabilities: readonly string[];
+    readonly handoffs?: readonly string[];
     readonly artifacts: Readonly<Record<string, string>>;
     readonly resources: Readonly<Record<string, string>>;
     readonly toolchain: ToolchainIdentity;

package/dist/src/workflow-candidate.js

@@ -5,6 +5,7 @@ const workflowModules = [
     "cloving/workflows/steps/decision-gate",
     "cloving/workflows/steps/load-cycle",
     "cloving/workflows/steps/protected-effect",
+    "cloving/workflows/steps/handoff",
 ];
 function isMethodList(value) {
     return (Array.isArray(value) &&

package/dist/src/workflow-contracts.d.ts

@@ -16,6 +16,7 @@ export type CycleOutcome = {
     readonly promotionId: string;
     readonly ticketStatus?: "complete" | "partial";
     readonly issueUpdate?: "failed";
+    readonly reason?: string;
 };
 export type Validation<Value> = {
     readonly kind: "valid";
@@ -24,6 +25,7 @@ export type Validation<Value> = {
     readonly kind: "invalid";
     readonly reason: string;
 };
+export declare function isPromotionId(value: unknown): value is string;
 export declare function isBlockedReason(value: unknown): value is string;
 export declare function validateDevelopmentInput(value: unknown): Validation<DevelopmentInput>;
 export declare function validateCycleOutcome(value: unknown, input: DevelopmentInput): Validation<CycleOutcome>;