cloving 1.0.1 → 1.2.0

package/dist/src/token-prices.js

@@ -0,0 +1,108 @@
+import { priceOf, usageOf } from "./worker-usage.js";
+import { record } from "./protocol.js";
+export const builtInPriceTable = {
+    date: "2026-10-18",
+    source: "https://openai.com/api/pricing/",
+    prices: {
+        "gpt-6.1-sol": { input: 2, cachedInput: 0.1, output: 10 },
+        "gpt-6-astra": { input: 10, cachedInput: 1, output: 50 },
+    },
+};
+function tokenPrice(value) {
+    const fields = record(value);
+    const input = priceOf(fields?.["input"]);
+    const cachedInput = priceOf(fields?.["cachedInput"]);
+    const output = priceOf(fields?.["output"]);
+    if (input === null || cachedInput === null || output === null)
+        throw new Error("Invalid CLOVING_TOKEN_PRICES");
+    return { input, cachedInput, output };
+}
+export function parseTokenPrices(value) {
+    if (value === undefined)
+        return { ...builtInPriceTable.prices };
+    try {
+        const fields = record(JSON.parse(value));
+        if (fields === undefined)
+            throw new Error("Invalid CLOVING_TOKEN_PRICES");
+        return {
+            ...builtInPriceTable.prices,
+            ...Object.fromEntries(Object.entries(fields).map(([model, price]) => [
+                model,
+                tokenPrice(price),
+            ])),
+        };
+    }
+    catch {
+        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;
+}
+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.startsWith("--model="))
+            selected = argument.slice(8) ? index : undefined;
+        if (["--model", "-m"].includes(argument)) {
+            const next = command[index + 1];
+            selected = next && !next.startsWith("-") ? index + 1 : undefined;
+            index += 1;
+        }
+    }
+    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;
+    const counts = usageOf(usage);
+    const cached = counts.cache_read_input_tokens;
+    const output = counts.output_tokens;
+    if (price === undefined ||
+        counts.input_tokens === null ||
+        cached === null ||
+        output === null)
+        return null;
+    const input = counts.input_tokens - (worker === "codex" ? cached : 0);
+    if (input < 0)
+        return null;
+    return priceOf((input / 1_000_000) * price.input +
+        (cached / 1_000_000) * price.cachedInput +
+        (output / 1_000_000) * price.output);
+}

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

@@ -0,0 +1,31 @@
+export interface WorkerUsage {
+    readonly input_tokens: number | null;
+    readonly cache_read_input_tokens: number | null;
+    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[];
+    readonly usage: WorkerUsage;
+    readonly claudeCostUsd: number | null;
+}
+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

@@ -0,0 +1,44 @@
+export function priceOf(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0
+        ? value
+        : null;
+}
+export function tokenCount(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0
+        ? value
+        : null;
+}
+export function usageOf(value) {
+    const fields = typeof value === "object" && value !== null ? value : {};
+    return {
+        input_tokens: tokenCount(Reflect.get(fields, "input_tokens")),
+        cache_read_input_tokens: tokenCount(Reflect.get(fields, "cache_read_input_tokens")),
+        output_tokens: tokenCount(Reflect.get(fields, "output_tokens")),
+    };
+}
+function total(values) {
+    if (values.length === 0 || values.includes(null))
+        return null;
+    return tokenCount(values.reduce((sum, value) => sum + (value ?? 0), 0));
+}
+export function sumUsage(values) {
+    return {
+        input_tokens: total(values.map((value) => value.input_tokens)),
+        cache_read_input_tokens: total(values.map((value) => value.cache_read_input_tokens)),
+        output_tokens: total(values.map((value) => value.output_tokens)),
+    };
+}
+export function sumPrices(values) {
+    const prices = values.map(priceOf);
+    if (prices.length === 0 || prices.includes(null))
+        return null;
+    return priceOf(prices.reduce((sum, price) => sum + (price ?? 0), 0));
+}
+export function workerTotals(workerTurns) {
+    return {
+        workerTurns,
+        usage: sumUsage(workerTurns.map((turn) => turn.usage)),
+        claudeCostUsd: sumPrices(workerTurns.map((turn) => turn.costUsd)),
+        estimatedCostUsd: sumPrices(workerTurns.map((turn) => turn.estimatedCostUsd)),
+    };
+}

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

@@ -0,0 +1,29 @@
+import { type WorkflowDeclaration } from "./workflow-declaration.ts";
+export interface CandidateDeclaration {
+    readonly workflow: WorkflowDeclaration;
+    readonly methods: Readonly<Record<string, readonly string[]>>;
+}
+export interface CandidateImport {
+    readonly module: string;
+    readonly names: readonly string[];
+}
+export interface CandidateEffect {
+    readonly capability: string | null;
+    readonly method: string | null;
+}
+export interface CandidateAnalysis {
+    readonly imports: readonly CandidateImport[];
+    readonly effects: readonly CandidateEffect[];
+    readonly directEffects: readonly string[];
+    readonly unsupportedForms: readonly string[];
+    readonly knownCallCount: number;
+    readonly knownUnitTotal: number;
+}
+export type InstalledWorkflowExports = Readonly<Record<string, readonly string[]>>;
+export type WorkflowCandidateCode = "invalid-declaration" | "forbidden-import" | "missing-export" | "unsupported-source" | "dynamic-effect" | "undeclared-effect" | "effect-limit" | "direct-effect";
+export interface WorkflowCandidateInput {
+    readonly declaration: unknown;
+    readonly analysis: CandidateAnalysis;
+    readonly installedExports: InstalledWorkflowExports;
+}
+export declare function checkWorkflowCandidate(input: WorkflowCandidateInput): readonly WorkflowCandidateCode[];

package/dist/src/workflow-candidate.js

@@ -0,0 +1,60 @@
+import { record } from "./protocol.js";
+import { isWorkflowDeclaration, } from "./workflow-declaration.js";
+const workflowModules = [
+    "cloving/workflows",
+    "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) &&
+        value.length > 0 &&
+        Array.from(value).every((method) => typeof method === "string" && method.trim().length > 0) &&
+        new Set(value).size === value.length);
+}
+function isCandidateDeclaration(value) {
+    const fields = record(value);
+    if (!fields ||
+        Object.keys(fields).some((key) => key !== "workflow" && key !== "methods"))
+        return false;
+    const workflow = fields["workflow"];
+    const methods = record(fields["methods"]);
+    if (!isWorkflowDeclaration(workflow) || !methods)
+        return false;
+    const capabilities = workflow.capabilities;
+    return (Object.keys(methods).every((key) => capabilities.includes(key)) &&
+        capabilities.every((capability) => isMethodList(methods[capability])));
+}
+export function checkWorkflowCandidate(input) {
+    if (!isCandidateDeclaration(input.declaration))
+        return ["invalid-declaration"];
+    const { analysis, declaration, installedExports } = input;
+    const codes = [];
+    if (analysis.imports.some((entry) => !workflowModules.includes(entry.module)))
+        codes.push("forbidden-import");
+    if (analysis.imports.some((entry) => {
+        if (!workflowModules.includes(entry.module))
+            return false;
+        const names = installedExports[entry.module];
+        return (names === undefined || entry.names.some((name) => !names.includes(name)));
+    }))
+        codes.push("missing-export");
+    if (analysis.effects.some((effect) => effect.capability !== null &&
+        effect.method !== null &&
+        (!Object.hasOwn(declaration.methods, effect.capability) ||
+            !declaration.methods[effect.capability]?.includes(effect.method))))
+        codes.push("undeclared-effect");
+    if (analysis.effects.some((effect) => effect.capability === null || effect.method === null))
+        codes.push("dynamic-effect");
+    const counts = [analysis.knownCallCount, analysis.knownUnitTotal];
+    if (counts.some((count) => !Number.isSafeInteger(count) || count < 0))
+        codes.push("unsupported-source");
+    else if (counts.some((count) => count > declaration.workflow.effectLimit))
+        codes.push("effect-limit");
+    if (analysis.directEffects.length > 0)
+        codes.push("direct-effect");
+    if (analysis.unsupportedForms.length > 0)
+        codes.push("unsupported-source");
+    return [...new Set(codes)].sort();
+}

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

@@ -14,6 +14,9 @@ export type CycleOutcome = {
     readonly kind: "handoff_requested";
     readonly cycleId: string;
     readonly promotionId: string;
+    readonly ticketStatus?: "complete" | "partial";
+    readonly issueUpdate?: "failed";
+    readonly reason?: string;
 };
 export type Validation<Value> = {
     readonly kind: "valid";
@@ -22,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>;

package/dist/src/workflow-contracts.js

@@ -1,5 +1,9 @@
+import { isTicketStatus } from "./ticket-status.js";
 const identifier = /^[A-Za-z0-9._:-]{1,128}$/;
 const reason = /^\S[\s\S]{0,255}$/;
+export function isPromotionId(value) {
+    return typeof value === "string" && identifier.test(value);
+}
 export function isBlockedReason(value) {
     return typeof value === "string" && reason.test(value);
 }
@@ -39,6 +43,7 @@ const outcomes = {
     },
     handoff_requested: {
         keys: ["cycleId", "kind", "promotionId"],
+        optional: ["ticketStatus", "issueUpdate", "reason"],
         parse: (fields) => {
             const cycleId = textField(fields, {
                 key: "cycleId",
@@ -50,12 +55,26 @@ const outcomes = {
             });
             if (cycleId === null || promotionId === null)
                 return null;
-            return { kind: "handoff_requested", cycleId, promotionId };
+            const ticketStatus = fields["ticketStatus"];
+            const issueUpdate = fields["issueUpdate"];
+            const reason = fields["reason"];
+            if (issueUpdate !== undefined && issueUpdate !== "failed")
+                return null;
+            if (ticketStatus !== undefined && !isTicketStatus(ticketStatus))
+                return null;
+            if (reason !== undefined && !isBlockedReason(reason))
+                return null;
+            return {
+                kind: "handoff_requested",
+                cycleId,
+                promotionId,
+                ...Object.fromEntries(Object.entries({ issueUpdate, ticketStatus, reason }).filter(([, value]) => value !== undefined)),
+            };
         },
     },
 };
 export function validateDevelopmentInput(value) {
-    const fields = exactFields(value, ["cycleId"]);
+    const fields = exactFields(value, { required: ["cycleId"] });
     const cycleId = fields && textField(fields, { key: "cycleId", pattern: identifier });
     if (!cycleId)
         return { kind: "invalid", reason: "invalid-development-input" };
@@ -66,18 +85,26 @@ export function validateCycleOutcome(value, input) {
     const contract = typeof kind === "string" && Object.hasOwn(outcomes, kind)
         ? outcomes[kind]
         : undefined;
-    const fields = contract && exactFields(value, contract.keys);
+    const fields = contract &&
+        exactFields(value, {
+            required: contract.keys,
+            optional: contract.optional ?? [],
+        });
     const outcome = fields && contract.parse(fields);
     if (!outcome || outcome.cycleId !== input.cycleId)
         return { kind: "invalid", reason: "invalid-cycle-outcome" };
     return { kind: "valid", value: outcome };
 }
-function exactFields(value, keys) {
+function exactFields(value, shape) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return null;
     const fields = Object.fromEntries(Object.entries(value));
+    const keys = shape?.required;
+    const optional = shape?.optional ?? [];
     if (keys &&
-        JSON.stringify(Object.keys(fields).sort()) !== JSON.stringify(keys))
+        JSON.stringify(Object.keys(fields)
+            .filter((key) => !optional.includes(key))
+            .sort()) !== JSON.stringify(keys))
         return null;
     return fields;
 }

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

@@ -1,11 +1,22 @@
 import type { SubmissionContract } from "./submission.ts";
+export interface WorkflowStage {
+    readonly name: string;
+    readonly label: string;
+    readonly operations?: readonly string[];
+    readonly gateKinds?: readonly ("approval" | "question")[];
+}
+export type WorkflowStages = Readonly<Record<string, readonly WorkflowStage[]>>;
 export interface WorkflowDeclaration {
     readonly workflowId: string;
     readonly effectLimit: number;
-    readonly capabilities: readonly ("claude" | "github")[];
+    readonly capabilities: readonly ("claude" | "github" | "chats")[];
     readonly input: SubmissionContract;
+    readonly stages?: readonly WorkflowStage[];
+    readonly handoffs?: readonly string[];
 }
 export interface DeclaredWorkflow extends WorkflowDeclaration {
     readonly functionName: string;
 }
+export declare function isWorkflowStages(value: unknown): value is readonly WorkflowStage[];
+export declare function isWorkflowHandoffs(value: unknown): value is readonly string[];
 export declare function isWorkflowDeclaration(value: unknown): value is WorkflowDeclaration;

package/dist/src/workflow-declaration.js

@@ -1,6 +1,7 @@
 import { record } from "./protocol.js";
 function keys(fields, allowed) {
-    return Object.keys(fields).every((key) => allowed.includes(key));
+    return (fields !== undefined &&
+        Object.keys(fields).every((key) => allowed.includes(key)));
 }
 function integer(value, bounds) {
     return (typeof value === "number" &&
@@ -20,8 +21,7 @@ function integerBounds(fields) {
 }
 function isField(value) {
     const fields = record(value);
-    if (fields === undefined ||
-        !keys(fields, ["type", "optional", "minimum", "maximum"]))
+    if (!keys(fields, ["type", "optional", "minimum", "maximum"]))
         return false;
     if (fields["optional"] !== undefined &&
         typeof fields["optional"] !== "boolean")
@@ -34,24 +34,82 @@ function isField(value) {
 }
 function isInput(value) {
     const input = record(value);
-    if (input === undefined || !keys(input, ["maximumBytes", "fields"]))
+    if (!keys(input, ["maximumBytes", "fields"]))
         return false;
     const fields = record(input["fields"]);
     return (integer(input["maximumBytes"], { minimum: 1, maximum: 1_048_576 }) &&
         fields !== undefined &&
         Object.values(fields).every(isField));
 }
+function matches(value, pattern) {
+    return typeof value === "string" && pattern.test(value);
+}
+function selectors(value, pattern) {
+    return (Array.isArray(value) &&
+        Array.from(value).every((item) => matches(item, pattern)));
+}
+function isStageLabel(label) {
+    return (typeof label === "string" &&
+        /^[^\p{C}\p{Zl}\p{Zp}]{1,40}$/u.test(label) &&
+        label.trim() === label &&
+        !["Other", "Done", "Stopped"].includes(label));
+}
+function isStage(value) {
+    const stage = record(value);
+    if (!keys(stage, ["name", "label", "operations", "gateKinds"]))
+        return false;
+    const { name, label } = stage;
+    const operations = Object.hasOwn(stage, "operations")
+        ? stage["operations"]
+        : [];
+    const gateKinds = Object.hasOwn(stage, "gateKinds") ? stage["gateKinds"] : [];
+    return (matches(name, /^[A-Za-z0-9-]{1,64}$/) &&
+        isStageLabel(label) &&
+        selectors(operations, /^[A-Za-z0-9._:/-]{1,128}$/) &&
+        selectors(gateKinds, /^(approval|question)$/) &&
+        operations.length + gateKinds.length > 0);
+}
+function unique(values) {
+    return new Set(values).size === values.length;
+}
+export function isWorkflowStages(value) {
+    if (!Array.isArray(value) || value.length < 1 || value.length > 12)
+        return false;
+    const stages = Array.from(value);
+    if (!stages.every(isStage))
+        return false;
+    return (unique(stages.map((stage) => stage.name)) &&
+        unique(stages.map((stage) => stage.label)) &&
+        unique(stages.flatMap((stage) => stage.operations ?? [])) &&
+        unique(stages.flatMap((stage) => stage.gateKinds ?? [])));
+}
+function isCapabilities(value) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((capability) => capability === "claude" ||
+            capability === "github" ||
+            capability === "chats"));
+}
+export function isWorkflowHandoffs(value) {
+    return selectors(value, /^[A-Za-z0-9-]{1,64}$/) && unique(value);
+}
 export function isWorkflowDeclaration(value) {
     const declaration = record(value);
-    if (declaration === undefined ||
-        !keys(declaration, ["workflowId", "effectLimit", "capabilities", "input"]))
+    if (!keys(declaration, [
+        "workflowId",
+        "effectLimit",
+        "capabilities",
+        "input",
+        "stages",
+        "handoffs",
+    ]))
         return false;
-    const { workflowId, effectLimit, capabilities, input } = declaration;
-    return (typeof workflowId === "string" &&
-        /^[A-Za-z0-9-]{1,64}$/.test(workflowId) &&
+    const { workflowId, effectLimit, capabilities, input, handoffs } = declaration;
+    return (matches(workflowId, /^[A-Za-z0-9-]{1,64}$/) &&
         integer(effectLimit, { minimum: 1, maximum: 100 }) &&
-        Array.isArray(capabilities) &&
-        capabilities.length > 0 &&
-        capabilities.every((capability) => capability === "claude" || capability === "github") &&
-        isInput(input));
+        isCapabilities(capabilities) &&
+        isInput(input) &&
+        (!Object.hasOwn(declaration, "stages") ||
+            isWorkflowStages(declaration["stages"])) &&
+        (!Object.hasOwn(declaration, "handoffs") || isWorkflowHandoffs(handoffs)));
 }

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

@@ -0,0 +1,18 @@
+export interface WorkflowReservation {
+    readonly baseName?: string;
+    readonly workflowId?: string;
+    readonly functionName?: string;
+}
+export interface WorkflowDiscoveryIdentity {
+    readonly baseName: string;
+    readonly workflowId: string | undefined;
+    readonly functionNames: readonly string[];
+}
+export type WorkflowConflictCode = "workflow-conflict" | "bundled-name-reserved";
+export declare function workflowConflicts(candidates: readonly WorkflowDiscoveryIdentity[], bundled: readonly WorkflowReservation[]): readonly (readonly WorkflowConflictCode[])[];
+export declare const bundledWorkflowIds: {
+    readonly ticket: "develop-ticket";
+    readonly issue: "develop-issue";
+    readonly prompt: "develop-prompt";
+    readonly prd: "develop-prd";
+};

package/dist/src/workflow-discovery.js

@@ -0,0 +1,33 @@
+function identityKeys(identity) {
+    return [
+        ...(identity.baseName === undefined ? [] : [`base:${identity.baseName}`]),
+        ...(identity.workflowId === undefined ? [] : [`id:${identity.workflowId}`]),
+        ...identity.functionNames.map((name) => `function:${name}`),
+    ];
+}
+export function workflowConflicts(candidates, bundled) {
+    const keys = candidates.map(identityKeys);
+    const counts = new Map();
+    for (const names of keys) {
+        for (const name of new Set(names))
+            counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+    const reserved = new Set(bundled.flatMap((entry) => identityKeys({
+        ...entry,
+        functionNames: entry.functionName === undefined ? [] : [entry.functionName],
+    })));
+    return keys.map((names) => {
+        const codes = [];
+        if (names.some((name) => reserved.has(name)))
+            codes.push("bundled-name-reserved");
+        if (names.some((name) => (counts.get(name) ?? 0) > 1))
+            codes.push("workflow-conflict");
+        return codes;
+    });
+}
+export const bundledWorkflowIds = {
+    ticket: "develop-ticket",
+    issue: "develop-issue",
+    prompt: "develop-prompt",
+    prd: "develop-prd",
+};

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

@@ -0,0 +1,6 @@
+export interface WorkflowRefusal {
+    readonly scope: "project" | "user";
+    readonly label: string;
+    readonly codes: readonly string[];
+}
+export declare function workflowRefusals(value: unknown): readonly WorkflowRefusal[];

package/dist/src/workflow-refusals.js

@@ -0,0 +1,39 @@
+import { record } from "./protocol.js";
+const refusalCodes = new Set([
+    "invalid-declaration",
+    "forbidden-import",
+    "missing-export",
+    "unsupported-source",
+    "dynamic-effect",
+    "undeclared-effect",
+    "effect-limit",
+    "direct-effect",
+    "workflow-conflict",
+    "bundled-name-reserved",
+    "unsafe-workflow-path",
+    "workflow-read-failed",
+    "workflow-source-changed",
+    "compile-failed",
+]);
+function refusal(value) {
+    const { scope, label, codes } = record(value) ?? {};
+    if ((scope !== "project" && scope !== "user") ||
+        typeof label !== "string" ||
+        /^(?:[A-Za-z0-9][A-Za-z0-9._-]{0,127}\.ts|file-[a-f0-9]{16}|workflows\/)$/u.exec(label)?.[0] !== label ||
+        !Array.isArray(codes) ||
+        codes.length === 0)
+        return [];
+    const known = codes.filter((code) => typeof code === "string" && refusalCodes.has(code));
+    if (known.length !== codes.length)
+        return [];
+    return [{ scope, label, codes: [...new Set(known)].sort() }];
+}
+export function workflowRefusals(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap(refusal).sort((left, right) => {
+        const a = `${left.scope}\0${left.label}`;
+        const b = `${right.scope}\0${right.label}`;
+        return a < b ? -1 : Number(a > b);
+    });
+}

package/dist/src/workflows.d.ts

@@ -1,5 +1,7 @@
 export { loadCycle, type CycleLoad } from "./steps/load-cycle.ts";
 export { protectedEffect } from "./steps/protected-effect.ts";
 export { decisionGate } from "./steps/decision-gate.ts";
-export type { GateRequest, GateResult, ProtectedRequest, ProtectedResult, ProtectedScope, } from "./step-bridge.ts";
+export { handoff } from "./steps/handoff.ts";
+export type { GateRequest, GateResult, HandoffRequest, HandoffValue, ProtectedRequest, ProtectedResult, ProtectedScope, } from "./step-bridge.ts";
 export type { CycleOutcome, DevelopmentInput } from "./workflow-contracts.ts";
+export { ticketStatus, type TicketStatus } from "./ticket-status.ts";

package/dist/src/workflows.js

@@ -1,3 +1,5 @@
 export { loadCycle } from "./steps/load-cycle.js";
 export { protectedEffect } from "./steps/protected-effect.js";
 export { decisionGate } from "./steps/decision-gate.js";
+export { handoff } from "./steps/handoff.js";
+export { ticketStatus } from "./ticket-status.js";

package/dist/tools/admit-workflow.d.ts

@@ -0,0 +1,13 @@
+import { type WorkflowCandidateCode } from "../src/workflow-candidate.ts";
+import { type CandidatePackageOptions } from "./workflow-candidate-program.ts";
+export type WorkflowCandidateAdmission = {
+    readonly kind: "admitted";
+    readonly artifactDigest: string;
+} | {
+    readonly kind: "refused";
+    readonly codes: readonly (WorkflowCandidateCode | "compile-failed")[];
+};
+export declare function admitWorkflowCandidate(input: {
+    readonly source: string;
+    readonly declaration: unknown;
+}, installed?: CandidatePackageOptions): Promise<WorkflowCandidateAdmission>;