cloving 1.1.0 → 1.3.0

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,12 +40,17 @@ 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)),
     };
 }
-function sumPrices(values) {
+export function sumPrices(values) {
     const prices = values.map(priceOf);
     if (prices.length === 0 || prices.includes(null))
         return null;
@@ -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,10 +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,21 +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"]);
@@ -27,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))
@@ -57,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-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>;

package/dist/src/workflow-contracts.js

@@ -1,6 +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);
 }
@@ -40,7 +43,7 @@ const outcomes = {
     },
     handoff_requested: {
         keys: ["cycleId", "kind", "promotionId"],
-        optional: ["ticketStatus", "issueUpdate"],
+        optional: ["ticketStatus", "issueUpdate", "reason"],
         parse: (fields) => {
             const cycleId = textField(fields, {
                 key: "cycleId",
@@ -54,16 +57,18 @@ const outcomes = {
                 return null;
             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,
-                ...(issueUpdate === "failed" ? { issueUpdate } : {}),
-                ...(ticketStatus === undefined ? {} : { ticketStatus }),
+                ...Object.fromEntries(Object.entries({ issueUpdate, ticketStatus, reason }).filter(([, value]) => value !== undefined)),
             };
         },
     },

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

@@ -1,11 +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 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,6 +1,20 @@
 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 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,40 +34,150 @@ 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")
         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"));
 }
 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));
+        Object.entries(fields).every(([name, rule]) => isField(rule) && (rule.type !== "ticket" || name === "ticket")));
+}
+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", "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)$/) &&
+        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;
+}
+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 ?? [])) &&
+        unique(stages.flatMap((stage) => stage.gateIds ?? [])));
+}
+function isCapabilities(value) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((capability) => capability === "claude" ||
+            capability === "github" ||
+            capability === "command"));
+}
+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 (declaration === undefined ||
-        !keys(declaration, ["workflowId", "effectLimit", "capabilities", "input"]))
+    if (!keys(declaration, [
+        "workflowId",
+        "effectLimit",
+        "capabilities",
+        "input",
+        "stages",
+        "handoffs",
+        "commands",
+        "commandWaits",
+        "queue",
+        "schedule",
+    ]))
         return false;
     const { workflowId, effectLimit, capabilities, input } = declaration;
-    return (typeof workflowId === "string" &&
-        /^[A-Za-z0-9-]{1,64}$/.test(workflowId) &&
+    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" ||
-            capability === "chats") &&
-        isInput(input));
+        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") ||
+            isWorkflowNames(declaration["handoffs"])) &&
+        (!Object.hasOwn(declaration, "schedule") ||
+            checkWorkflowSchedule(input, declaration["schedule"]).kind === "valid"));
 }

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

@@ -0,0 +1,19 @@
+export interface WorkflowReservation {
+    readonly baseName?: string;
+    readonly workflowId?: string;
+    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" | "queue-workflow-conflict";
+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,36 @@
+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],
+    })));
+    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))
+            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,42 @@
+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",
+    "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/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 {};