cloving 1.0.1 → 1.1.0

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

@@ -0,0 +1,185 @@
+import { join } from "node:path";
+import { mkdir } from "node:fs/promises";
+import { setTimeout as delay } from "node:timers/promises";
+import { priceOf, sumUsage, usageOf } from "../worker-usage.js";
+import { capacityRefusal, startTurn, } from "./claude-turn.js";
+import { readRecord, writeRecord } from "./operation-journal.js";
+const waits = [60_000, 180_000];
+const continuation = "An earlier attempt stopped because the model was at capacity; continue from the current state of the work tree.\n\n";
+function written(folder, entry) {
+    return writeRecord(folder, { ...entry, permissions: "private" });
+}
+function total(values) {
+    if (values.includes(null))
+        return null;
+    return priceOf(values.reduce((sum, value) => sum + (value ?? 0), 0));
+}
+function combined(ends) {
+    const last = ends.at(-1) ?? { exitCode: null, result: undefined };
+    if (ends.length < 2)
+        return last;
+    const result = last.result ?? ends.find((end) => end.result)?.result;
+    if (result === undefined)
+        return last;
+    return {
+        ...last,
+        result: {
+            ...result,
+            ...(last.result === undefined ? { failed: true, text: "" } : {}),
+            usage: sumUsage(ends.map((end) => end.result?.usage ?? usageOf(null))),
+            costUsd: total(ends.map((end) => end.result?.costUsd ?? null)),
+            turns: total(ends.map((end) => end.result?.turns ?? null)),
+        },
+    };
+}
+function controlled(attempts, start) {
+    const turn = startTurn(start);
+    const stop = () => {
+        turn.stop(attempts.grace.milliseconds);
+    };
+    attempts.stopping.signal.addEventListener("abort", stop, { once: true });
+    return {
+        ...turn,
+        ended: turn.ended.finally(() => {
+            attempts.stopping.signal.removeEventListener("abort", stop);
+        }),
+    };
+}
+async function launched(attempts) {
+    const { start, options, ends } = attempts;
+    const attempt = ends.length + 1;
+    const folder = start.mode === "analysis" || attempt === 1
+        ? start.folder
+        : join(start.folder, `attempt-${String(attempt)}`);
+    const entry = {
+        ...options.metadata,
+        attempt,
+        startedAt: attempt === 1 ? attempts.startedAt : new Date().toISOString(),
+    };
+    await written(start.folder, {
+        name: "started.json",
+        value: {
+            ...entry,
+            startedAt: attempts.startedAt,
+            phase: "starting",
+            processId: null,
+        },
+    });
+    await mkdir(folder, { recursive: true, mode: 0o700 });
+    if (attempts.stopping.signal.aborted)
+        return undefined;
+    const turn = controlled(attempts, {
+        ...start,
+        folder,
+        ...(attempt === 1 ? {} : { activityFolder: start.folder }),
+        prompt: attempt === 1 ? start.prompt : continuation + start.prompt,
+    });
+    try {
+        const value = { ...entry, phase: "running", processId: turn.processId };
+        await written(start.folder, {
+            name: "started.json",
+            value: { ...value, startedAt: attempts.startedAt },
+        });
+        await written(start.folder, {
+            name: `attempt-${String(attempt)}.json`,
+            value,
+        });
+        return turn;
+    }
+    catch (error) {
+        turn.stop(0);
+        await turn.ended;
+        throw error;
+    }
+}
+async function recordedEnd(attempts, completion) {
+    const { start, ends, options } = attempts;
+    const { processId, end } = completion;
+    const attempt = ends.length;
+    const name = `attempt-${String(attempt)}.json`;
+    const started = await readRecord(start.folder, name);
+    const startedAt = Reflect.get(Object(started), "startedAt");
+    if (typeof startedAt !== "string")
+        throw new Error("attempt-start-time-missing");
+    await written(start.folder, {
+        name,
+        value: {
+            ...options.metadata,
+            attempt,
+            processId,
+            startedAt,
+            endedAt: new Date().toISOString(),
+            exitCode: end.exitCode,
+            capacity: capacityRefusal(end.result),
+            usage: end.result?.usage ?? usageOf(null),
+            costUsd: end.result?.costUsd ?? null,
+        },
+    });
+}
+async function waited(attempts, milliseconds) {
+    const { start, options, stopping, ends } = attempts;
+    await written(start.folder, {
+        name: "started.json",
+        value: {
+            ...options.metadata,
+            startedAt: attempts.startedAt,
+            attempt: ends.length,
+            phase: "waiting",
+            processId: null,
+            waitMilliseconds: milliseconds,
+            waitingAt: new Date().toISOString(),
+        },
+    });
+    const wait = options.retryDelay ??
+        ((duration, signal) => delay(duration, undefined, { signal }));
+    await wait(milliseconds, stopping.signal).catch((error) => {
+        if (!stopping.signal.aborted)
+            throw error;
+    });
+}
+async function finished(attempts, first) {
+    const { ends } = attempts;
+    let turn = first;
+    while (turn !== undefined) {
+        const end = await turn.ended;
+        ends.push(end);
+        await recordedEnd(attempts, { processId: turn.processId, end });
+        const milliseconds = waits[ends.length - 1];
+        if (cancelled(attempts) ||
+            !capacityRefusal(end.result) ||
+            milliseconds === undefined)
+            break;
+        await waited(attempts, milliseconds);
+        if (cancelled(attempts))
+            return { ...combined(ends), stopped: true };
+        turn = await launched(attempts);
+    }
+    return {
+        ...combined(ends),
+        ...(cancelled(attempts) || turn === undefined ? { stopped: true } : {}),
+    };
+}
+function cancelled(attempts) {
+    return attempts.stopping.signal.aborted;
+}
+export async function startRetriedTurn(start, options) {
+    const attempts = {
+        start,
+        startedAt: new Date().toISOString(),
+        options,
+        stopping: new AbortController(),
+        ends: [],
+        grace: { milliseconds: 2_000 },
+    };
+    const turn = await launched(attempts);
+    if (turn === undefined)
+        throw new Error("turn-start-stopped");
+    return {
+        processId: turn.processId,
+        ended: finished(attempts, turn),
+        stop: (graceMilliseconds) => {
+            attempts.grace.milliseconds = graceMilliseconds;
+            attempts.stopping.abort();
+        },
+    };
+}

package/dist/src/host/world-reconciliation.d.ts

@@ -4,6 +4,8 @@ export type ReconciledState = Pick<AuthorityState, "runs" | "intents" | "details
 export interface WorkflowOutcome {
     readonly kind: string;
     readonly reason?: string;
+    readonly issueUpdate?: "failed";
+    readonly ticketStatus?: "complete" | "partial";
 }
 export interface ReconciliationPorts {
     readonly state: () => Promise<ReconciledState>;

package/dist/src/host/world-reconciliation.js

@@ -14,6 +14,12 @@ async function withOutcome(ports, observed) {
         : {
             ...world,
             outcome: read.outcome.kind,
+            ...(read.outcome.issueUpdate === "failed"
+                ? { issueUpdate: read.outcome.issueUpdate }
+                : {}),
+            ...(read.outcome.ticketStatus === undefined
+                ? {}
+                : { ticketStatus: read.outcome.ticketStatus }),
             ...(read.outcome.reason === undefined
                 ? {}
                 : { outcomeReason: read.outcome.reason }),

package/dist/src/host/world-runs.js

@@ -1,3 +1,4 @@
+import { isTicketStatus } from "../ticket-status.js";
 import { getRun } from "workflow/api";
 import { getWorld } from "workflow/runtime";
 export const runTag = "cloving.run";
@@ -44,7 +45,14 @@ export async function workflowOutcome(receipt) {
     if (typeof kind !== "string")
         return undefined;
     const reason = Reflect.get(Object(value), "reason");
-    return { kind, ...(typeof reason === "string" ? { reason } : {}) };
+    const issueUpdate = Reflect.get(Object(value), "issueUpdate");
+    const ticketStatus = Reflect.get(Object(value), "ticketStatus");
+    return {
+        kind,
+        ...(typeof reason === "string" ? { reason } : {}),
+        ...(issueUpdate === "failed" ? { issueUpdate } : {}),
+        ...(isTicketStatus(ticketStatus) ? { ticketStatus } : {}),
+    };
 }
 export async function cancelled(receipt) {
     const run = getRun(receipt);

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

@@ -1,6 +1,7 @@
 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";
 async function snapshot(context) {
     const { authority } = context;
@@ -95,26 +96,6 @@ function summary(view) {
         pendingDecisions: view.pendingDecisions,
     };
 }
-function costOf(text) {
-    try {
-        const cost = record(JSON.parse(text ?? "null"))?.["costUsd"];
-        return typeof cost === "number" ? cost : 0;
-    }
-    catch {
-        return 0;
-    }
-}
-async function claudeCost(context, runId) {
-    const { effects, queries } = context.authority;
-    const digests = (await effects.operations(runId))
-        .filter((operation) => operation.capability === "claude")
-        .map((operation) => operation.result)
-        .filter((digest) => digest !== null);
-    let total = 0;
-    for (const digest of digests)
-        total += costOf(await queries.document(digest));
-    return Math.round(total * 100) / 100;
-}
 function full(view) {
     return {
         ...summary(view),
@@ -123,6 +104,9 @@ function full(view) {
         lastConfirmedObservation: view.lastConfirmedObservation,
         recovery: view.recovery,
         claudeCostUsd: view.claudeCostUsd,
+        estimatedCostUsd: view.estimatedCostUsd,
+        usage: view.usage,
+        workerTurns: view.workerTurns,
         budget: view.budget,
         effects: view.effects,
         nextAction: view.nextAction,
@@ -141,7 +125,15 @@ async function outcomeOf(context, view) {
     const kind = event?.payload["outcome"];
     if (kind === undefined)
         return null;
-    return { kind, reason: event?.payload["outcomeReason"] ?? null };
+    const ticketStatus = event?.payload["ticketStatus"];
+    return {
+        kind,
+        reason: event?.payload["outcomeReason"] ?? null,
+        ...(ticketStatus === undefined ? {} : { ticketStatus }),
+        ...(event?.payload["issueUpdate"] === "failed"
+            ? { issueUpdate: "failed" }
+            : {}),
+    };
 }
 function titleOf(input, workflowId) {
     const ticket = input?.["ticket"];
@@ -200,10 +192,10 @@ export async function status(context, parameters) {
     const view = await viewOf(context, { snapshot: current, runId: named });
     if (view === undefined)
         return failed("unknown-run", { detail: `No run has the ID ${named}.` });
-    const claudeCostUsd = await claudeCost(context, view.runId);
+    const totals = await usageTotals(context, view.runId);
     return result("run-status", {
         run: {
-            ...full({ ...view, claudeCostUsd }),
+            ...full({ ...view, ...totals }),
             outcome: await outcomeOf(context, view),
             ...(await metadataOf(context, {
                 workflowId: view.workflowId,

package/dist/src/service/worker-totals.d.ts

@@ -0,0 +1,3 @@
+import { type WorkerTotals } from "../worker-usage.ts";
+import type { ServiceContext } from "./replies.ts";
+export declare function usageTotals(context: ServiceContext, runId: string): Promise<WorkerTotals>;

package/dist/src/service/worker-totals.js

@@ -0,0 +1,28 @@
+import { record } from "../protocol.js";
+import { priceOf, usageOf, workerTotals, } from "../worker-usage.js";
+function reportFields(text) {
+    try {
+        return record(JSON.parse(text ?? "null")) ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+export async function usageTotals(context, runId) {
+    const { effects, queries } = context.authority;
+    const operations = (await effects.operations(runId)).filter((operation) => operation.capability === "claude" &&
+        ["completed", "failed", "stopped", "cancelled", "refused"].includes(operation.status));
+    const turns = [];
+    for (const operation of operations) {
+        const report = reportFields(operation.result === null
+            ? undefined
+            : await queries.document(operation.result));
+        turns.push({
+            operationId: operation.operationId,
+            usage: usageOf(report["usage"]),
+            costUsd: priceOf(report["costUsd"]),
+            estimatedCostUsd: priceOf(report["estimatedCostUsd"]),
+        });
+    }
+    return workerTotals(turns);
+}

package/dist/src/ticket-status.d.ts

@@ -0,0 +1,8 @@
+export type TicketStatus = {
+    readonly kind: "complete";
+} | {
+    readonly kind: "partial";
+    readonly remaining: readonly string[];
+};
+export declare function ticketStatus(summary: string, preserved?: unknown): TicketStatus;
+export declare function isTicketStatus(value: unknown): value is "complete" | "partial";

package/dist/src/ticket-status.js

@@ -0,0 +1,45 @@
+function parsedStatus(summary) {
+    const lines = summary.trimEnd().split(/\r?\n/);
+    if (lines.filter((line) => /^Ticket status:/i.test(line)).length !== 1)
+        return undefined;
+    const status = lines.pop();
+    if (status === "Ticket status: complete")
+        return { kind: "complete" };
+    if (status !== "Ticket status: partial")
+        return undefined;
+    const heading = lines.lastIndexOf("Remaining:");
+    if (heading === -1)
+        return undefined;
+    const items = lines.slice(heading + 1);
+    if (items.length === 0 || items.some((line) => !/^- \S.*$/.test(line)))
+        return undefined;
+    return { kind: "partial", remaining: items.map((line) => line.slice(2)) };
+}
+function preservedStatus(value) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const kind = Reflect.get(value, "kind");
+    if (kind === "complete")
+        return { kind };
+    const remaining = Reflect.get(value, "remaining");
+    if (kind !== "partial" ||
+        !Array.isArray(remaining) ||
+        remaining.length === 0 ||
+        remaining.some((item) => typeof item !== "string" || item.trim() === "" || /[\r\n]/.test(item)))
+        return undefined;
+    return { kind, remaining: remaining.map(String) };
+}
+export function ticketStatus(summary, preserved) {
+    const parsed = preserved === undefined
+        ? parsedStatus(summary)
+        : preservedStatus(preserved);
+    if (parsed !== undefined)
+        return parsed;
+    return {
+        kind: "partial",
+        remaining: ["The worker report has no ticket status line."],
+    };
+}
+export function isTicketStatus(value) {
+    return value === "complete" || value === "partial";
+}

package/dist/src/token-prices.d.ts

@@ -0,0 +1,19 @@
+import { type WorkerUsage } from "./worker-usage.ts";
+export interface TokenPrice {
+    readonly input: number;
+    readonly cachedInput: number;
+    readonly output: number;
+}
+export type TokenPrices = Readonly<Record<string, TokenPrice>>;
+export declare const builtInPriceTable: {
+    readonly date: string;
+    readonly source: string;
+    readonly prices: TokenPrices;
+};
+export declare function parseTokenPrices(value: string | undefined): TokenPrices;
+export declare function priceForModel(prices: TokenPrices, model: string | null): TokenPrice | undefined;
+export declare function commandModel(command: readonly string[]): string | null;
+export declare function estimatedCostUsd(usage: WorkerUsage, pricing: {
+    readonly worker: "claude" | "codex";
+    readonly price: TokenPrice | undefined;
+}): number | null;

package/dist/src/token-prices.js

@@ -0,0 +1,76 @@
+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 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) {
+        const argument = command[index] ?? "";
+        if (argument === "--")
+            break;
+        if (argument.startsWith("--model="))
+            model = argument.slice(8) || null;
+        if (argument === "--model" || argument === "-m") {
+            const next = command[index + 1];
+            model = next && !next.startsWith("-") ? next : null;
+            index += 1;
+        }
+    }
+    return 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,22 @@
+export interface WorkerUsage {
+    readonly input_tokens: number | null;
+    readonly cache_read_input_tokens: number | null;
+    readonly output_tokens: number | null;
+}
+export interface WorkerTurnUsage {
+    readonly estimatedCostUsd: number | null;
+    readonly operationId: string;
+    readonly usage: WorkerUsage;
+    readonly costUsd: 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 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)),
+    };
+}
+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-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,59 @@
+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",
+];
+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,8 @@ export type CycleOutcome = {
     readonly kind: "handoff_requested";
     readonly cycleId: string;
     readonly promotionId: string;
+    readonly ticketStatus?: "complete" | "partial";
+    readonly issueUpdate?: "failed";
 };
 export type Validation<Value> = {
     readonly kind: "valid";