cloving 1.2.0 → 1.3.0

package/dist/src/token-prices.js

@@ -1,4 +1,4 @@
-import { priceOf, usageOf } from "./worker-usage.js";
+import { priceOf, sumPrices, usageOf, } from "./worker-usage.js";
 import { record } from "./protocol.js";
 export const builtInPriceTable = {
     date: "2026-10-18",
@@ -90,16 +90,29 @@ export function replaceCommandModel(command, model) {
     });
 }
 export function estimatedCostUsd(usage, pricing) {
+    return "models" in pricing
+        ? modelCostUsd(pricing)
+        : singleCostUsd(usage, pricing);
+}
+function modelCostUsd(pricing) {
+    return sumPrices(pricing.models.map(({ model, usage: counts }) => singleCostUsd(counts, {
+        worker: "gemini",
+        price: priceForModel(pricing.prices, model),
+    })));
+}
+function singleCostUsd(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 ||
+        (worker === "cursor-agent" && counts.cache_creation_input_tokens !== 0) ||
         counts.input_tokens === null ||
         cached === null ||
         output === null)
         return null;
-    const input = counts.input_tokens - (worker === "codex" ? cached : 0);
+    const input = counts.input_tokens -
+        (worker === "codex" || worker === "gemini" ? cached : 0);
     if (input < 0)
         return null;
     return priceOf((input / 1_000_000) * price.input +

package/dist/src/turn-profile.d.ts

@@ -1,4 +1,5 @@
 export interface TurnProfile {
+    readonly harness?: string;
     readonly env?: Readonly<Record<string, string>>;
     readonly allowedTools?: readonly string[];
     readonly model?: string;

package/dist/src/turn-profile.js

@@ -1,4 +1,5 @@
 const fields = [
+    "harness",
     "env",
     "allowedTools",
     "model",
@@ -29,6 +30,8 @@ function environment(value) {
             text(item)));
 }
 function validField(name, value) {
+    if (name === "harness")
+        return typeof value === "string" && /^[a-z][a-z0-9-]{0,63}$/.test(value);
     if (name === "env")
         return environment(value);
     if (name === "allowedTools" || name === "workflows")
@@ -71,7 +74,11 @@ function retained(argumentsList, values) {
     for (let index = 0; index < argumentsList.length;) {
         const argument = argumentsList[index] ?? "";
         const name = argument.split("=")[0] ?? "";
-        const flag = name === "--allowed-tools" ? "--allowedTools" : name;
+        const aliases = {
+            "--allowed-tools": "--allowedTools",
+            "-m": "--model",
+        };
+        const flag = aliases[name] ?? name;
         if (!values.has(flag)) {
             kept.push(argument);
             index += 1;

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

@@ -1,9 +1,14 @@
+export type RetryKind = "capacity" | "network";
 export interface WorkerUsage {
+    readonly cache_creation_input_tokens?: number | null;
     readonly input_tokens: number | null;
     readonly cache_read_input_tokens: number | null;
     readonly output_tokens: number | null;
 }
 export interface WorkerTurnUsage {
+    readonly model?: string;
+    readonly summary?: string;
+    readonly harness?: string;
     readonly attempts?: readonly WorkerAttemptUsage[];
     readonly estimatedCostUsd: number | null;
     readonly operationId: string;
@@ -11,12 +16,19 @@ export interface WorkerTurnUsage {
     readonly costUsd: number | null;
 }
 export interface WorkerAttemptUsage {
+    readonly models?: readonly WorkerModelUsage[];
+    readonly retryKind?: RetryKind | null;
     readonly attempt: number;
     readonly model: string | null;
     readonly usage: WorkerUsage;
     readonly costUsd: number | null;
     readonly estimatedCostUsd: number | null;
 }
+export interface WorkerModelUsage {
+    readonly model: string;
+    readonly usage: WorkerUsage;
+}
+export declare function modelUsageOf(value: unknown): readonly WorkerModelUsage[] | undefined;
 export interface WorkerTotals {
     readonly estimatedCostUsd: number | null;
     readonly workerTurns: readonly WorkerTurnUsage[];
@@ -29,3 +41,7 @@ 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;
+export declare function attemptsOf(value: unknown): readonly WorkerAttemptUsage[] | undefined;
+export declare function attemptFields(value: unknown): {
+    readonly attempts?: readonly WorkerAttemptUsage[];
+};

package/dist/src/worker-usage.js

@@ -1,3 +1,15 @@
+export function modelUsageOf(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.flatMap((entry) => {
+        if (typeof entry !== "object" || entry === null)
+            return [];
+        const model = Reflect.get(entry, "model");
+        if (typeof model !== "string")
+            return [];
+        return [{ model, usage: usageOf(Reflect.get(entry, "usage")) }];
+    });
+}
 export function priceOf(value) {
     return typeof value === "number" && Number.isFinite(value) && value >= 0
         ? value
@@ -11,6 +23,11 @@ export function tokenCount(value) {
 export function usageOf(value) {
     const fields = typeof value === "object" && value !== null ? value : {};
     return {
+        ...(Object.hasOwn(fields, "cache_creation_input_tokens")
+            ? {
+                cache_creation_input_tokens: tokenCount(Reflect.get(fields, "cache_creation_input_tokens")),
+            }
+            : {}),
         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")),
@@ -23,6 +40,11 @@ function total(values) {
 }
 export function sumUsage(values) {
     return {
+        ...(values.some((value) => Object.hasOwn(value, "cache_creation_input_tokens"))
+            ? {
+                cache_creation_input_tokens: total(values.map((value) => value.cache_creation_input_tokens ?? null)),
+            }
+            : {}),
         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)),
@@ -42,3 +64,38 @@ export function workerTotals(workerTurns) {
         estimatedCostUsd: sumPrices(workerTurns.map((turn) => turn.estimatedCostUsd)),
     };
 }
+function retryKindField(value) {
+    return value === null || value === "capacity" || value === "network"
+        ? { retryKind: value }
+        : {};
+}
+export function attemptsOf(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.flatMap((entry) => {
+        const fields = typeof entry === "object" && entry !== null ? entry : {};
+        const field = (name) => Reflect.get(fields, name);
+        const attempt = tokenCount(field("attempt"));
+        const model = field("model");
+        const models = modelUsageOf(field("models"));
+        if (attempt === null ||
+            attempt === 0 ||
+            (model !== null && typeof model !== "string"))
+            return [];
+        return [
+            {
+                ...retryKindField(field("retryKind")),
+                attempt,
+                model,
+                ...(models === undefined ? {} : { models }),
+                usage: usageOf(field("usage")),
+                costUsd: priceOf(field("costUsd")),
+                estimatedCostUsd: priceOf(field("estimatedCostUsd")),
+            },
+        ];
+    });
+}
+export function attemptFields(value) {
+    const attempts = attemptsOf(value);
+    return attempts === undefined ? {} : { attempts };
+}

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

@@ -1,3 +1,4 @@
+import type { CommandWaits } from "./workflow-declaration.ts";
 export interface ToolchainIdentity {
     readonly sdk: string;
     readonly world: string;
@@ -23,11 +24,15 @@ export interface AdmissionPolicy {
     readonly capabilities: readonly string[];
 }
 export interface ExecutionManifest {
+    readonly queue?: boolean;
     readonly name: string;
     readonly workflowId: string;
     readonly steps: readonly string[];
     readonly capabilities: readonly string[];
     readonly handoffs?: readonly string[];
+    readonly commands?: readonly string[];
+    readonly commandWaits?: CommandWaits;
+    readonly bundleDigest?: string;
     readonly artifacts: Readonly<Record<string, string>>;
     readonly resources: Readonly<Record<string, string>>;
     readonly toolchain: ToolchainIdentity;

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

@@ -1,4 +1,4 @@
-import { type WorkflowDeclaration } from "./workflow-declaration.ts";
+import { type WorkflowQueueCode, type WorkflowDeclaration } from "./workflow-declaration.ts";
 export interface CandidateDeclaration {
     readonly workflow: WorkflowDeclaration;
     readonly methods: Readonly<Record<string, readonly string[]>>;
@@ -6,12 +6,14 @@ export interface CandidateDeclaration {
 export interface CandidateImport {
     readonly module: string;
     readonly names: readonly string[];
+    readonly source?: string;
 }
 export interface CandidateEffect {
     readonly capability: string | null;
     readonly method: string | null;
 }
 export interface CandidateAnalysis {
+    readonly localSources?: readonly string[];
     readonly imports: readonly CandidateImport[];
     readonly effects: readonly CandidateEffect[];
     readonly directEffects: readonly string[];
@@ -20,10 +22,13 @@ export interface CandidateAnalysis {
     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 type WorkflowCandidateCode = WorkflowQueueCode | "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 workflowHelperPath(source: string, imported: string): string | undefined;
+export declare function isCandidateDeclaration(value: unknown): value is CandidateDeclaration;
 export declare function checkWorkflowCandidate(input: WorkflowCandidateInput): readonly WorkflowCandidateCode[];
+export declare function candidateDeclarationRefusals(value: unknown): readonly WorkflowCandidateCode[];

package/dist/src/workflow-candidate.js

@@ -1,22 +1,58 @@
 import { record } from "./protocol.js";
-import { isWorkflowDeclaration, } from "./workflow-declaration.js";
+import { isWorkflowDeclaration, workflowQueueRefusals, } from "./workflow-declaration.js";
 const workflowModules = [
     "cloving/workflows",
     "cloving/workflows/steps/decision-gate",
+    "cloving/workflows/steps/wait-for-decision",
+    "cloving/workflows/steps/review-by-person",
+    "cloving/workflows/steps/review-by-agent",
+    "cloving/workflows/steps/merge-by-person",
+    "cloving/workflows/steps/merge-when-green",
+    "cloving/workflows/steps/review-subject",
     "cloving/workflows/steps/load-cycle",
     "cloving/workflows/steps/protected-effect",
     "cloving/workflows/steps/handoff",
+    "cloving/workflows/steps/wait-for-run",
+    "cloving/workflows/steps/run-command",
+    "cloving/workflows/steps/sleep",
 ];
+export function workflowHelperPath(source, imported) {
+    if (!imported.startsWith("./"))
+        return undefined;
+    const parts = [
+        ...source.split("/").slice(0, -1),
+        ...imported.slice(2).split("/"),
+    ];
+    if (parts.length < 2 ||
+        parts.some((part) => part.length === 0 ||
+            part === "." ||
+            part === ".." ||
+            part.toUpperCase() === "NODE_MODULES" ||
+            /[\\:\0]/.test(part) ||
+            part.startsWith("~")))
+        return undefined;
+    const path = parts.join("/");
+    return path.endsWith(".ts") && !path.endsWith(".d.ts") ? path : undefined;
+}
+function allowedImport(entry, analysis) {
+    if (workflowModules.includes(entry.module))
+        return true;
+    const path = workflowHelperPath(entry.source ?? "candidate.ts", entry.module);
+    return path !== undefined && (analysis.localSources ?? []).includes(path);
+}
 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) {
+export function isCandidateDeclaration(value) {
     const fields = record(value);
     if (!fields ||
-        Object.keys(fields).some((key) => key !== "workflow" && key !== "methods"))
+        Object.keys(fields).some((key) => !["workflow", "methods", "template"].includes(key)) ||
+        (Object.hasOwn(fields, "template") &&
+            (typeof fields["template"] !== "string" ||
+                !/^[a-z][a-z0-9-]{0,63}$/.test(fields["template"]))))
         return false;
     const workflow = fields["workflow"];
     const methods = record(fields["methods"]);
@@ -28,10 +64,10 @@ function isCandidateDeclaration(value) {
 }
 export function checkWorkflowCandidate(input) {
     if (!isCandidateDeclaration(input.declaration))
-        return ["invalid-declaration"];
+        return candidateDeclarationRefusals(input.declaration);
     const { analysis, declaration, installedExports } = input;
     const codes = [];
-    if (analysis.imports.some((entry) => !workflowModules.includes(entry.module)))
+    if (analysis.imports.some((entry) => !allowedImport(entry, analysis)))
         codes.push("forbidden-import");
     if (analysis.imports.some((entry) => {
         if (!workflowModules.includes(entry.module))
@@ -58,3 +94,9 @@ export function checkWorkflowCandidate(input) {
         codes.push("unsupported-source");
     return [...new Set(codes)].sort();
 }
+export function candidateDeclarationRefusals(value) {
+    if (isCandidateDeclaration(value))
+        return [];
+    const codes = workflowQueueRefusals(record(value)?.["workflow"]);
+    return codes.length > 0 ? codes : ["invalid-declaration"];
+}

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

@@ -1,22 +1,40 @@
-import type { SubmissionContract } from "./submission.ts";
+import { type SubmissionContract } from "./submission.ts";
+import { type WorkflowSchedule } from "./workflow-schedule.ts";
 export interface WorkflowStage {
     readonly name: string;
     readonly label: string;
     readonly operations?: readonly string[];
     readonly gateKinds?: readonly ("approval" | "question")[];
+    readonly gateIds?: readonly string[];
 }
 export type WorkflowStages = Readonly<Record<string, readonly WorkflowStage[]>>;
+export interface CommandWaitDeclaration {
+    readonly command: string;
+    readonly maximumWaitSeconds: number;
+    readonly pollEverySeconds: number;
+}
+export type CommandWaits = Readonly<Record<string, CommandWaitDeclaration>>;
 export interface WorkflowDeclaration {
     readonly workflowId: string;
     readonly effectLimit: number;
-    readonly capabilities: readonly ("claude" | "github" | "chats")[];
+    readonly capabilities: readonly ("claude" | "github" | "command")[];
     readonly input: SubmissionContract;
     readonly stages?: readonly WorkflowStage[];
     readonly handoffs?: readonly string[];
+    readonly commands?: readonly string[];
+    readonly commandWaits?: CommandWaits;
+    readonly queue?: boolean;
+    readonly schedule?: WorkflowSchedule;
 }
 export interface DeclaredWorkflow extends WorkflowDeclaration {
     readonly functionName: string;
 }
+export type WorkflowQueueCode = "queue-needs-ticket-field" | "queue-input-incomplete";
+export declare function workflowQueueRefusals(value: unknown): readonly WorkflowQueueCode[];
 export declare function isWorkflowStages(value: unknown): value is readonly WorkflowStage[];
-export declare function isWorkflowHandoffs(value: unknown): value is readonly string[];
+export declare function isWorkflowNames(value: unknown): value is readonly string[];
+export declare function isCommandWaits(value: unknown, permissions: {
+    readonly capabilities: readonly string[];
+    readonly commands: readonly string[];
+}): value is CommandWaits;
 export declare function isWorkflowDeclaration(value: unknown): value is WorkflowDeclaration;

package/dist/src/workflow-declaration.js

@@ -1,4 +1,17 @@
 import { record } from "./protocol.js";
+import { hasTicketField, } from "./submission.js";
+import { checkWorkflowSchedule, } from "./workflow-schedule.js";
+export function workflowQueueRefusals(value) {
+    const declaration = record(value);
+    if (declaration?.["queue"] !== true || !isInput(declaration["input"]))
+        return [];
+    const input = declaration["input"];
+    if (!hasTicketField(input))
+        return ["queue-needs-ticket-field"];
+    return Object.entries(input.fields).some(([name, rule]) => name !== "ticket" && (rule === "string" || rule.optional !== true))
+        ? ["queue-input-incomplete"]
+        : [];
+}
 function keys(fields, allowed) {
     return (fields !== undefined &&
         Object.keys(fields).every((key) => allowed.includes(key)));
@@ -28,7 +41,9 @@ function isField(value) {
         return false;
     if (fields["type"] === "integer")
         return integerBounds(fields);
-    return ((fields["type"] === "string" || fields["type"] === "boolean") &&
+    return ((fields["type"] === "string" ||
+        fields["type"] === "boolean" ||
+        fields["type"] === "ticket") &&
         !Object.hasOwn(fields, "minimum") &&
         !Object.hasOwn(fields, "maximum"));
 }
@@ -39,7 +54,7 @@ function isInput(value) {
     const fields = record(input["fields"]);
     return (integer(input["maximumBytes"], { minimum: 1, maximum: 1_048_576 }) &&
         fields !== undefined &&
-        Object.values(fields).every(isField));
+        Object.entries(fields).every(([name, rule]) => isField(rule) && (rule.type !== "ticket" || name === "ticket")));
 }
 function matches(value, pattern) {
     return typeof value === "string" && pattern.test(value);
@@ -56,18 +71,20 @@ function isStageLabel(label) {
 }
 function isStage(value) {
     const stage = record(value);
-    if (!keys(stage, ["name", "label", "operations", "gateKinds"]))
+    if (!keys(stage, ["name", "label", "operations", "gateKinds", "gateIds"]))
         return false;
     const { name, label } = stage;
     const operations = Object.hasOwn(stage, "operations")
         ? stage["operations"]
         : [];
     const gateKinds = Object.hasOwn(stage, "gateKinds") ? stage["gateKinds"] : [];
+    const gateIds = Object.hasOwn(stage, "gateIds") ? stage["gateIds"] : [];
     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);
+        selectors(gateIds, /^[A-Za-z0-9._:/-]{1,128}$/) &&
+        operations.length + gateKinds.length + gateIds.length > 0);
 }
 function unique(values) {
     return new Set(values).size === values.length;
@@ -81,18 +98,55 @@ export function isWorkflowStages(value) {
     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 ?? [])));
+        unique(stages.flatMap((stage) => stage.gateKinds ?? [])) &&
+        unique(stages.flatMap((stage) => stage.gateIds ?? [])));
 }
 function isCapabilities(value) {
     return (Array.isArray(value) &&
         value.length > 0 &&
         value.every((capability) => capability === "claude" ||
             capability === "github" ||
-            capability === "chats"));
+            capability === "command"));
 }
-export function isWorkflowHandoffs(value) {
+export function isWorkflowNames(value) {
     return selectors(value, /^[A-Za-z0-9-]{1,64}$/) && unique(value);
 }
+function declaredCommands(declaration, capabilities) {
+    const commands = declaration["commands"];
+    if (Object.hasOwn(declaration, "commands") && !isWorkflowNames(commands))
+        return false;
+    return ((!capabilities.includes("command") ||
+        (Array.isArray(commands) && commands.length > 0)) &&
+        declaredCommandWaits(declaration, capabilities));
+}
+function isCommandWait(value) {
+    const wait = record(value);
+    if (!keys(wait, ["command", "maximumWaitSeconds", "pollEverySeconds"]))
+        return false;
+    return (typeof wait["command"] === "string" &&
+        integer(wait["maximumWaitSeconds"], { minimum: 60, maximum: 2_592_000 }) &&
+        integer(wait["pollEverySeconds"], { minimum: 60, maximum: 86_400 }) &&
+        Number(wait["pollEverySeconds"]) <= Number(wait["maximumWaitSeconds"]));
+}
+export function isCommandWaits(value, permissions) {
+    const waits = record(value);
+    if (waits === undefined)
+        return false;
+    return Object.entries(waits).every(([name, wait]) => matches(name, /^[A-Za-z0-9-]{1,64}$/) &&
+        name.trim() === name &&
+        isCommandWait(wait) &&
+        permissions.capabilities.includes("command") &&
+        permissions.commands.includes(wait.command));
+}
+function declaredCommandWaits(declaration, capabilities) {
+    if (!Object.hasOwn(declaration, "commandWaits"))
+        return true;
+    const commands = declaration["commands"];
+    return isCommandWaits(declaration["commandWaits"], {
+        capabilities,
+        commands: isWorkflowNames(commands) ? commands : [],
+    });
+}
 export function isWorkflowDeclaration(value) {
     const declaration = record(value);
     if (!keys(declaration, [
@@ -102,14 +156,28 @@ export function isWorkflowDeclaration(value) {
         "input",
         "stages",
         "handoffs",
+        "commands",
+        "commandWaits",
+        "queue",
+        "schedule",
     ]))
         return false;
-    const { workflowId, effectLimit, capabilities, input, handoffs } = declaration;
+    const { workflowId, effectLimit, capabilities, input } = declaration;
     return (matches(workflowId, /^[A-Za-z0-9-]{1,64}$/) &&
         integer(effectLimit, { minimum: 1, maximum: 100 }) &&
         isCapabilities(capabilities) &&
+        declaredCommands(declaration, capabilities) &&
         isInput(input) &&
+        declaredOptions(declaration, input));
+}
+function declaredOptions(declaration, input) {
+    return ((!Object.hasOwn(declaration, "queue") ||
+        typeof declaration["queue"] === "boolean") &&
+        workflowQueueRefusals(declaration).length === 0 &&
         (!Object.hasOwn(declaration, "stages") ||
             isWorkflowStages(declaration["stages"])) &&
-        (!Object.hasOwn(declaration, "handoffs") || isWorkflowHandoffs(handoffs)));
+        (!Object.hasOwn(declaration, "handoffs") ||
+            isWorkflowNames(declaration["handoffs"])) &&
+        (!Object.hasOwn(declaration, "schedule") ||
+            checkWorkflowSchedule(input, declaration["schedule"]).kind === "valid"));
 }

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

@@ -4,11 +4,12 @@ export interface WorkflowReservation {
     readonly functionName?: string;
 }
 export interface WorkflowDiscoveryIdentity {
+    readonly queue?: boolean;
     readonly baseName: string;
     readonly workflowId: string | undefined;
     readonly functionNames: readonly string[];
 }
-export type WorkflowConflictCode = "workflow-conflict" | "bundled-name-reserved";
+export type WorkflowConflictCode = "workflow-conflict" | "bundled-name-reserved" | "queue-workflow-conflict";
 export declare function workflowConflicts(candidates: readonly WorkflowDiscoveryIdentity[], bundled: readonly WorkflowReservation[]): readonly (readonly WorkflowConflictCode[])[];
 export declare const bundledWorkflowIds: {
     readonly ticket: "develop-ticket";

package/dist/src/workflow-discovery.js

@@ -16,8 +16,11 @@ export function workflowConflicts(candidates, bundled) {
         ...entry,
         functionNames: entry.functionName === undefined ? [] : [entry.functionName],
     })));
-    return keys.map((names) => {
+    const queued = candidates.filter((candidate) => candidate.queue === true);
+    return keys.map((names, index) => {
         const codes = [];
+        if (queued.length > 1 && candidates[index]?.queue === true)
+            codes.push("queue-workflow-conflict");
         if (names.some((name) => reserved.has(name)))
             codes.push("bundled-name-reserved");
         if (names.some((name) => (counts.get(name) ?? 0) > 1))

package/dist/src/workflow-refusals.js

@@ -1,6 +1,9 @@
 import { record } from "./protocol.js";
 const refusalCodes = new Set([
     "invalid-declaration",
+    "queue-needs-ticket-field",
+    "queue-input-incomplete",
+    "queue-workflow-conflict",
     "forbidden-import",
     "missing-export",
     "unsupported-source",

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

@@ -0,0 +1,22 @@
+import { type Fields } from "./protocol.ts";
+import { type SubmissionContract } from "./submission.ts";
+export interface WorkflowSchedule {
+    readonly everySeconds: number;
+    readonly input: Fields;
+}
+export type ScheduleCheck = {
+    readonly kind: "valid";
+    readonly schedule: WorkflowSchedule;
+} | {
+    readonly kind: "rejected";
+    readonly code: string;
+};
+interface ScheduleSource {
+    readonly workflowId: string;
+    readonly input: SubmissionContract;
+    readonly schedule?: WorkflowSchedule;
+}
+export declare function parseSchedulesSetting(value: string | undefined): unknown;
+export declare function configuredSchedules(declarations: readonly ScheduleSource[], overrides: unknown): Readonly<Record<string, WorkflowSchedule>>;
+export declare function checkWorkflowSchedule(contract: SubmissionContract, value: unknown): ScheduleCheck;
+export {};

package/dist/src/workflow-schedule.js

@@ -0,0 +1,53 @@
+import { record } from "./protocol.js";
+import { checkSubmission } from "./submission.js";
+export function parseSchedulesSetting(value) {
+    try {
+        return JSON.parse(value ?? "{}");
+    }
+    catch {
+        throw new Error("invalid-schedules");
+    }
+}
+export function configuredSchedules(declarations, overrides) {
+    const settings = record(overrides);
+    if (settings === undefined)
+        throw new Error("invalid-schedules");
+    if (Object.keys(settings).some((id) => !declarations.some((entry) => entry.workflowId === id)))
+        throw new Error("unknown-schedule-workflow");
+    const schedules = [];
+    for (const declaration of declarations) {
+        const { workflowId } = declaration;
+        const selected = Object.hasOwn(settings, workflowId)
+            ? settings[workflowId]
+            : declaration.schedule;
+        if (selected === undefined && !Object.hasOwn(settings, workflowId))
+            continue;
+        const checked = checkWorkflowSchedule(declaration.input, selected);
+        if (checked.kind === "rejected")
+            throw new Error(checked.code);
+        schedules.push([workflowId, checked.schedule]);
+    }
+    return Object.fromEntries(schedules);
+}
+export function checkWorkflowSchedule(contract, value) {
+    const fields = record(value);
+    const seconds = fields?.["everySeconds"];
+    if (fields === undefined ||
+        Object.keys(fields).some((key) => !["everySeconds", "input"].includes(key)) ||
+        typeof seconds !== "number" ||
+        !Number.isInteger(seconds) ||
+        seconds < 60 ||
+        seconds > 86400)
+        return { kind: "rejected", code: "invalid-schedule-interval" };
+    const checked = checkSubmission(contract, {
+        workflowId: "schedule",
+        source: "declared",
+        submission: fields["input"],
+    });
+    if (checked.kind === "rejected")
+        return { kind: "rejected", code: "invalid-schedule-input" };
+    return {
+        kind: "valid",
+        schedule: { everySeconds: seconds, input: checked.submission },
+    };
+}