cloving 1.2.0 → 1.4.0

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

@@ -1,17 +1,20 @@
-import { issueIdentity } from "../issue-identity.js";
+import { commandWaitDisplay } from "./command-waits.js";
+import { scheduleMetadata, scheduledMetadata, metadataOf, outcomeOf, ticketMetadataPage, workflowMetadata, } from "./run-metadata.js";
 import { linksOf } from "../authority/handoff-chain.js";
 import { runView, unresolvedEffects, } from "../authority/status.js";
 import { record } from "../protocol.js";
 import { committed, failed, invalidRequest, isIdentifier, publicReceipt, rejection, result, wholeNumber, } from "./replies.js";
 import { usageTotals } from "./worker-totals.js";
-import { feedbackOf } from "./decision-handler.js";
-import { queueOverview } from "./submission-handler.js";
+import { commandFields } from "./command-effects.js";
+import { decidedOf, feedbackOf } from "./decision-handler.js";
+import { queueOverview } from "./active-tickets.js";
 import { queueRunStatuses } from "./queue-runs.js";
 async function snapshot(context) {
     const { authority } = context;
     const state = await authority.state();
     const sequences = await authority.queries.sequences();
     return {
+        now: context.clock(),
         links: await authority.queries.runLinks(),
         state,
         operations: await authority.operations(),
@@ -44,6 +47,7 @@ async function effectInput(context, runId) {
     const budget = await effects.budget(runId);
     const stored = await effects.operations(runId);
     return {
+        commandOperations: stored.filter((operation) => operation.capability === "command"),
         budget: budget ? { limit: budget.limit, spent: budget.spent } : null,
         effects: stored.map((operation) => ({
             operationId: operation.operationId,
@@ -62,8 +66,16 @@ async function viewOf(context, scope) {
     if (run === undefined)
         return undefined;
     const details = state.details[run.runId];
+    const workflowId = scope.snapshot.workflowIds[run.runId] ?? run.workflow;
+    const effects = await effectInput(context, run.runId);
     const input = {
-        ...(await effectInput(context, run.runId)),
+        ...effects,
+        commandWaits: await commandWaitDisplay({
+            authority: context.authority,
+            runId: run.runId,
+            waits: state.commandWaits,
+            now: scope.snapshot.now,
+        }),
         closure: run.status === "cancelled"
             ? await context.authority.effects.closure(run.runId)
             : null,
@@ -81,9 +93,14 @@ async function viewOf(context, scope) {
     };
     return {
         ...runView(input),
+        ...(await scheduledMetadata(context, {
+            runId: run.runId,
+            workflowId,
+        })),
+        commandOperations: effects.commandOperations,
         ...linksOf({ runId: run.runId, ...scope.snapshot.links[run.runId] }),
         input: await submittedInput(context, details?.submission),
-        workflowId: scope.snapshot.workflowIds[run.runId] ?? run.workflow,
+        workflowId,
         latestAt: times[run.runId] ?? null,
         unresolvedEffects: unresolvedEffects(input),
         feedback: await feedbackOf(context, { state, runId: run.runId }),
@@ -92,15 +109,18 @@ async function viewOf(context, scope) {
 function summary(view) {
     return {
         runId: view.runId,
+        ...(view.scheduled === undefined ? {} : { scheduled: view.scheduled }),
         ...linksOf(view),
         input: view.input,
         workflowId: view.workflowId,
         state: view.state,
         condition: view.condition,
+        awaitedRunId: view.awaitedRunId,
         revision: view.revision,
         latestSequence: view.latestSequence,
         latestAt: view.latestAt,
         pendingDecisions: view.pendingDecisions,
+        commandWaits: view.commandWaits,
     };
 }
 function full(view) {
@@ -122,57 +142,6 @@ function full(view) {
         feedback: view.feedback,
     };
 }
-async function outcomeOf(context, view) {
-    if (view.state !== "completed")
-        return null;
-    const event = await context.authority.queries.latestCompletion({
-        runId: view.runId,
-        atOrBefore: view.latestSequence,
-    });
-    const payload = event?.payload ?? {};
-    const kind = payload["outcome"];
-    if (kind === undefined)
-        return null;
-    const { ticketStatus, promotionId, outcomeReason, issueUpdate } = payload;
-    return {
-        kind,
-        reason: outcomeReason ?? null,
-        ...(promotionId === undefined ? {} : { promotionId }),
-        ...(ticketStatus === undefined ? {} : { ticketStatus }),
-        ...(issueUpdate === "failed" ? { issueUpdate } : {}),
-    };
-}
-function titleOf(input, workflowId) {
-    const ticket = input?.["ticket"];
-    if (typeof ticket !== "string")
-        return null;
-    const fallback = `Cloving task ${String(input?.["cycleId"])}`;
-    const lines = ticket.split("\n");
-    if (workflowId === "develop-prompt") {
-        const first = lines.find((line) => /\S/.test(line));
-        return first === undefined
-            ? fallback
-            : first.replace(/^# /, "").trim().slice(0, 200);
-    }
-    const first = lines[0] ?? "";
-    return first.startsWith("# ")
-        ? first.slice(2).trim().slice(0, 200)
-        : fallback;
-}
-async function metadataOf(context, source) {
-    const document = source.digest
-        ? await context.authority.queries.document(source.digest)
-        : undefined;
-    const input = record(JSON.parse(document ?? "null"));
-    const ticketId = input?.["ticketId"];
-    return {
-        ticketId: typeof ticketId === "string" && ticketId !== "" ? ticketId : null,
-        title: titleOf(input, source.workflowId),
-        ...(source.workflowId === "develop-issue"
-            ? { issueIdentity: issueIdentity(input?.["ticket"]) }
-            : {}),
-    };
-}
 async function submittedInput(context, digest) {
     const document = digest
         ? await context.authority.queries.document(digest)
@@ -191,6 +160,7 @@ async function listed(context, page) {
     const runs = views.filter((view) => view !== undefined).map(summary);
     return result("run-list", {
         ...(await queueOverview(context)),
+        ...(await scheduleMetadata(context)),
         workflows: context.registry.workflowIds,
         workflowRefusals: context.workflowRefusals ?? [],
         ...(Object.keys(context.registry.workflowStages).length === 0
@@ -211,12 +181,16 @@ function listParameters(parameters) {
     return { after, limit };
 }
 export async function status(context, parameters) {
+    if (parameters["metadata"] === "workflows")
+        return workflowMetadata(context, parameters["runIds"]);
     if (parameters["runIds"] !== undefined)
         return queueRunStatuses(context, parameters["runIds"]);
     const { runId } = parameters;
     const page = listParameters(parameters);
     if (page === undefined)
         return invalidRequest("The status request is not valid.");
+    if (parameters["metadata"] === "tickets")
+        return ticketMetadataPage(context, page);
     const current = await snapshot(context);
     if (runId === undefined)
         return listed(context, { snapshot: current, ...page });
@@ -228,7 +202,12 @@ export async function status(context, parameters) {
     return result("run-status", {
         run: {
             ...full({ ...view, ...totals }),
+            ...(await commandFields(context, view.commandOperations)),
             outcome: await outcomeOf(context, view),
+            decisions: await decidedOf(context, {
+                state: current.state,
+                runId: view.runId,
+            }),
             ...(await metadataOf(context, {
                 workflowId: view.workflowId,
                 digest: current.state.details[view.runId]?.input,

package/dist/src/service/run-metadata.d.ts

@@ -0,0 +1,22 @@
+import { type Fields } from "../protocol.ts";
+import type { RunView } from "../authority/status.ts";
+import { type ServiceContext } from "./replies.ts";
+export declare function workflowMetadata(context: ServiceContext, runIds: unknown): Promise<import("../protocol.ts").Reply>;
+export declare function ticketMetadataPage(context: ServiceContext, page: {
+    readonly after: string;
+    readonly limit: number;
+}): Promise<import("../protocol.ts").Reply>;
+export declare function outcomeOf(context: ServiceContext, view: Pick<RunView, "state" | "runId" | "latestSequence">): Promise<Fields | null>;
+export declare function metadataOf(context: ServiceContext, source: {
+    readonly workflowId: string;
+    readonly digest: string | null | undefined;
+}): Promise<Fields>;
+export declare function scheduleMetadata(context: ServiceContext): Promise<Fields>;
+export declare function scheduledMetadata(context: ServiceContext, run: {
+    readonly runId: string;
+    readonly workflowId: string;
+}): Promise<{
+    readonly scheduled?: {
+        readonly slot: number;
+    };
+}>;

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

@@ -0,0 +1,138 @@
+import { issueIdentity } from "../issue-identity.js";
+import { record } from "../protocol.js";
+import { invalidRequest, isIdentifier, result, } from "./replies.js";
+export async function workflowMetadata(context, runIds) {
+    if (!Array.isArray(runIds) ||
+        runIds.length === 0 ||
+        runIds.length > 500 ||
+        !runIds.every(isIdentifier) ||
+        new Set(runIds).size !== runIds.length)
+        return invalidRequest("Workflow metadata needs one to 500 distinct run IDs.");
+    const identities = await context.authority.queries.workflowIds(runIds);
+    return result("run-workflow-metadata", {
+        runs: runIds.map((runId) => ({
+            runId,
+            workflowId: identities[runId] ?? null,
+        })),
+    });
+}
+export async function ticketMetadataPage(context, page) {
+    const state = await context.authority.state();
+    const identifiers = Object.keys(state.runs)
+        .sort()
+        .filter((runId) => runId > page.after);
+    const shown = identifiers.slice(0, page.limit);
+    const runs = [];
+    for (const runId of shown) {
+        const digest = state.details[runId]?.input;
+        const document = digest
+            ? await context.authority.queries.document(digest)
+            : "{}";
+        const input = record(JSON.parse(document ?? "null"));
+        if (input === undefined)
+            throw new Error("report-ticket-metadata-unavailable");
+        runs.push({ runId, ticketId: ticketIdOf(input) });
+    }
+    return result("run-ticket-metadata", {
+        runs,
+        next: identifiers.length > shown.length ? shown.at(-1) : null,
+    });
+}
+export async function outcomeOf(context, view) {
+    if (view.state !== "completed")
+        return null;
+    const event = await context.authority.queries.latestCompletion({
+        runId: view.runId,
+        atOrBefore: view.latestSequence,
+    });
+    const payload = event?.payload ?? {};
+    const kind = payload["outcome"];
+    if (kind === undefined)
+        return null;
+    const { ticketStatus, promotionId, outcomeReason, issueUpdate } = payload;
+    return {
+        kind,
+        reason: outcomeReason ?? null,
+        ...(promotionId === undefined ? {} : { promotionId }),
+        ...(ticketStatus === undefined ? {} : { ticketStatus }),
+        ...(issueUpdate === "failed" ? { issueUpdate } : {}),
+    };
+}
+function ticketOf(input) {
+    const declared = record(record(input?.["input"])?.["ticket"]);
+    const id = declared === undefined ? input?.["ticketId"] : declared["id"];
+    const text = declared === undefined ? input?.["ticket"] : declared["text"];
+    return {
+        id: typeof id === "string" ? id : undefined,
+        text: typeof text === "string" ? text : undefined,
+    };
+}
+function titleOf(input, workflowId) {
+    const ticket = ticketOf(input).text;
+    if (ticket === undefined)
+        return null;
+    const fallback = `Cloving task ${String(input?.["cycleId"])}`;
+    const lines = ticket.split("\n");
+    if (workflowId === "develop-prompt" && !Object.hasOwn(input ?? {}, "input")) {
+        const first = lines.find((line) => /\S/.test(line));
+        return first === undefined
+            ? fallback
+            : first.replace(/^# /, "").trim().slice(0, 200);
+    }
+    const first = lines[0] ?? "";
+    return first.startsWith("# ")
+        ? first.slice(2).trim().slice(0, 200)
+        : fallback;
+}
+export async function metadataOf(context, source) {
+    const document = source.digest
+        ? await context.authority.queries.document(source.digest)
+        : undefined;
+    const input = record(JSON.parse(document ?? "null"));
+    return {
+        ticketId: ticketIdOf(input),
+        title: titleOf(input, source.workflowId),
+        ...(ticketOf(input).text === undefined
+            ? {}
+            : { issueIdentity: issueIdentity(ticketOf(input).text) }),
+    };
+}
+function ticketIdOf(input) {
+    const ticketId = ticketOf(input).id;
+    return ticketId === undefined || ticketId === "" ? null : ticketId;
+}
+export async function scheduleMetadata(context) {
+    if (context.schedule === undefined)
+        return {};
+    const reply = await context.schedule({ action: "list" });
+    if (reply.kind !== "result" || !Array.isArray(reply.result["schedules"]))
+        return { schedules: { status: "unavailable" } };
+    const schedules = reply.result["schedules"];
+    if (schedules.length === 0)
+        return {};
+    return {
+        schedules: schedules.map((value) => {
+            const schedule = record(value) ?? {};
+            return Object.fromEntries([
+                "workflowId",
+                "everySeconds",
+                "state",
+                "failuresInRow",
+                "nextAt",
+                "stoppedAt",
+            ].map((name) => [name, schedule[name]]));
+        }),
+    };
+}
+export async function scheduledMetadata(context, run) {
+    const commandId = (await context.authority.queries.run(run.runId))
+        ?.admissionCommandId;
+    const prefix = `schedule:${run.workflowId}:`;
+    if (typeof commandId !== "string" || !commandId.startsWith(prefix))
+        return {};
+    const suffix = commandId.slice(prefix.length);
+    const slot = Number(suffix);
+    return /^(0|[1-9][0-9]*)$/.test(suffix) && Number.isSafeInteger(slot)
+        ? { scheduled: { slot } }
+        : {};
+}

package/dist/src/service/run-waits.d.ts

@@ -0,0 +1,3 @@
+import type { Authority } from "../broker/actor/authority.ts";
+import type { RunWaitTarget } from "../run-wait.ts";
+export declare function runWaitTarget(authority: Authority, runId: string): Promise<RunWaitTarget | undefined>;

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

@@ -0,0 +1,41 @@
+function outcomeOf(event, status) {
+    if (event === undefined)
+        return null;
+    return {
+        kind: event.payload["outcome"] ?? status,
+        reason: event.payload["outcomeReason"] ?? null,
+        promotionId: event.payload["promotionId"] ?? null,
+    };
+}
+async function settled(authority, run) {
+    if (run.status !== "cancelled")
+        return ["completed", "failed"].includes(run.status);
+    const closure = await authority.effects.closure(run.runId);
+    return (!closure.open &&
+        closure.closure === "cancelled" &&
+        closure.unresolved.length === 0);
+}
+export async function runWaitTarget(authority, runId) {
+    const run = await authority.queries.run(runId);
+    const origin = (await authority.queries.runOrigins())[runId];
+    if (run === undefined || origin === undefined)
+        return undefined;
+    const terminal = await settled(authority, run);
+    const event = terminal
+        ? await authority.queries.latestCompletion({
+            runId,
+            atOrBefore: run.sequence,
+            terminal: true,
+        })
+        : undefined;
+    const endedAt = event === undefined ? null : Date.parse(event.recordedAt);
+    const stoppedAt = run.status === "cancelled" && terminal
+        ? await authority.effects.settledAt(runId)
+        : null;
+    return {
+        parentRunId: origin.parentRunId,
+        status: run.status,
+        endedAt: endedAt === null ? null : Math.max(endedAt, stoppedAt ?? endedAt),
+        outcome: outcomeOf(event, run.status),
+    };
+}

package/dist/src/service/service.d.ts

@@ -1,7 +1,11 @@
 import { type Authority, type AuthorityTiming, type Delivery, type EffectSettings, type Refusal } from "../broker/actor/authority.ts";
 import { type WorkflowRefusal } from "../workflow-refusals.ts";
-import { type WorkflowRegistration } from "./registry.ts";
+import { type Registry, type WorkflowRegistration, type WorkflowBundleStore } from "./registry.ts";
+import { type ServiceContext } from "./replies.ts";
 import { type WorkerPort } from "./worker-port.ts";
+import type { RunWaitTarget } from "../run-wait.ts";
+import type { CommandEffects } from "../command-settings.ts";
+import { type CommandWaitPort } from "./command-waits.ts";
 export type { WorkflowRegistration } from "./registry.ts";
 export type { EffectReply, EffectReport, EffectRequest, WorkerPort, } from "./worker-port.ts";
 export interface ServiceTiming {
@@ -24,22 +28,38 @@ export interface ServiceHost {
     readonly reports?: () => readonly unknown[];
 }
 export interface HostPorts {
+    readonly commandWait: CommandWaitPort;
+    readonly runWait?: {
+        readonly target: (runId: string) => Promise<RunWaitTarget | undefined>;
+        readonly observe: WorkerPort["observe"];
+    };
     readonly state: Authority["state"];
     readonly submit: WorkerPort["submit"];
     readonly input: (runId: string) => Promise<string | undefined>;
     readonly document: (digest: string) => Promise<string | undefined>;
-    readonly workflowId: (runId: string) => Promise<string | undefined>;
+    readonly workflow: {
+        readonly id: (runId: string) => Promise<string | undefined>;
+        readonly manifest: Authority["queries"]["manifest"];
+        readonly available: (runId: string, workflowId?: string) => Promise<boolean>;
+    };
     readonly requestEffect: WorkerPort["requestEffect"];
     readonly operation: Authority["effects"]["operation"];
+    readonly operations: Authority["effects"]["operations"];
     readonly reportEffect: WorkerPort["reportEffect"];
     readonly openGate: WorkerPort["openGate"];
     readonly registerWait: WorkerPort["registerWait"];
 }
 export interface ServiceOptions {
+    readonly schedule?: NonNullable<ServiceContext["schedule"]>;
+    readonly queueDailySpendLimitUsd?: number;
+    readonly workerHarness?: ServiceContext["workerHarness"];
+    readonly commandEffects?: CommandEffects;
     readonly stateDirectory: string;
     readonly runtimeDirectory: string;
     readonly workflows: readonly WorkflowRegistration[];
     readonly retainedWorkflows?: readonly WorkflowRegistration[];
+    readonly workflowBundles?: WorkflowBundleStore;
+    readonly retainedWorkflow?: Registry["available"];
     readonly workflowRefusals?: readonly WorkflowRefusal[];
     readonly delivery: Delivery;
     readonly host?: (ports: HostPorts) => Promise<ServiceHost>;

package/dist/src/service/service.js

@@ -2,18 +2,20 @@ import { lstat, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { authorityTiming, openAuthority, } from "../broker/actor/authority.js";
 import { socketAddress } from "../broker/socket-address.js";
-import { workflowRefusals, } from "../workflow-refusals.js";
+import {} from "../workflow-refusals.js";
 import { changeSignal } from "./changes.js";
 import { decision, questions } from "./decision-handler.js";
 import { events } from "./event-handler.js";
 import { expiryScan } from "./expiry.js";
 import { commandGateway, workerCommandBound } from "./gateway.js";
 import { workflowRegistry, } from "./registry.js";
-import { failed } from "./replies.js";
+import { errorMessage, failed, queryMetadata, scheduleRequest, } from "./replies.js";
 import { runCommand, status } from "./run-handlers.js";
 import { submissionHandler } from "./submission-handler.js";
 import { connectionLimits, listen, reachable } from "./transport.js";
 import { workerPort } from "./worker-port.js";
+import { runWaitTarget } from "./run-waits.js";
+import { commandWaitPort } from "./command-waits.js";
 export const serviceTiming = {
     authority: authorityTiming,
     expiryScanMilliseconds: 1_000,
@@ -58,6 +60,7 @@ function dispatcher(context) {
     const run = submissionHandler(context);
     const operations = new Map([
         ["run", (request) => run(request.parameters)],
+        ["schedule", (request) => scheduleRequest(context, request.parameters)],
         ["status", (request) => status(context, request.parameters)],
         ["questions", (request) => questions(context, request.parameters)],
         ["decision", (request) => decision(context, request.parameters)],
@@ -88,7 +91,7 @@ async function started(authority, setup) {
         handle: dispatcher({
             authority,
             registry,
-            workflowRefusals: workflowRefusals(options.workflowRefusals),
+            ...queryMetadata(options),
             gateway,
             clock,
             changed: changes.next,
@@ -135,7 +138,7 @@ export async function startService(options) {
     if (typeof path !== "string")
         return path;
     const timing = options.timing ?? serviceTiming;
-    const registry = workflowRegistry(options.workflows, options.retainedWorkflows);
+    const registry = workflowRegistry(options.workflows, options);
     const opening = await openAuthority(options.stateDirectory, {
         delivery: options.delivery,
         timing: timing.authority,
@@ -148,7 +151,7 @@ export async function startService(options) {
     const { authority } = opening;
     const gateway = serviceGateway(authority, { options, registry });
     const worker = workerPort({ gateway, authority });
-    const host = await hosted(options, hostPorts(authority, worker));
+    const host = await hosted(options, hostPorts(authority, { worker, registry, gateway }));
     if (host.kind === "refused") {
         await authority.close();
         return host;
@@ -168,8 +171,8 @@ export async function startService(options) {
         };
     }
     catch (error) {
-        const unclosed = await released(authority, host.host).then(() => "", (failure) => `; the close failed: ${message(failure)}`);
-        return refused("transport-failure", `${message(error)}${unclosed}`);
+        const unclosed = await released(authority, host.host).then(() => "", (failure) => `; the close failed: ${errorMessage(failure)}`);
+        return refused("transport-failure", `${errorMessage(error)}${unclosed}`);
     }
 }
 function serviceGateway(authority, parts) {
@@ -182,8 +185,14 @@ function serviceGateway(authority, parts) {
         pendingWorkerCommands: limits.pendingWorkerCommands,
     });
 }
-function hostPorts(authority, worker) {
+function hostPorts(authority, parts) {
+    const { worker, registry } = parts;
     return {
+        commandWait: commandWaitPort({ authority, gateway: parts.gateway }),
+        runWait: {
+            target: (runId) => runWaitTarget(authority, runId),
+            observe: worker.observe,
+        },
         state: authority.state,
         submit: worker.submit,
         input: async (runId) => {
@@ -198,17 +207,24 @@ function hostPorts(authority, worker) {
         openGate: worker.openGate,
         registerWait: worker.registerWait,
         operation: authority.effects.operation,
-        workflowId: async (runId) => (await authority.queries.workflowIds())[runId],
+        operations: authority.effects.operations,
+        workflow: {
+            id: async (runId) => (await authority.queries.workflowIds())[runId],
+            manifest: authority.queries.manifest,
+            available: async (runId, workflowId) => {
+                const manifest = await authority.queries.manifest(runId);
+                return (manifest !== undefined &&
+                    (workflowId === undefined || manifest.workflowId === workflowId) &&
+                    (await registry.available(manifest)) !== undefined);
+            },
+        },
     };
 }
-function message(error) {
-    return String(Reflect.get(Object(error), "message"));
-}
 async function hosted(options, ports) {
     try {
         return { kind: "started", host: await options.host?.(ports) };
     }
     catch (error) {
-        return refused("host-unavailable", message(error));
+        return refused("host-unavailable", errorMessage(error));
     }
 }

package/dist/src/service/submission-handler.d.ts

@@ -1,5 +1,4 @@
 import { type Fields, type Reply } from "../protocol.ts";
 import { type ServiceContext } from "./replies.ts";
 export declare function runIdentity(commandId: string): string;
-export declare function queueOverview(context: ServiceContext): Promise<Fields>;
 export declare function submissionHandler(context: ServiceContext): (parameters: Fields) => Promise<Reply>;

package/dist/src/service/submission-handler.js

@@ -5,7 +5,9 @@ import { setTimeout as delay } from "node:timers/promises";
 import { isCommandId, isIdentifier as isWorkflowIdentifier, } from "../authority/commands.js";
 import { documentDigest } from "../broker/decision-restore.js";
 import { record } from "../protocol.js";
-import { checkResolution, checkSubmission, normalizedRequest, } from "../submission.js";
+import { checkResolution, checkSubmission, hasTicketField, normalizedRequest, } from "../submission.js";
+import { activeWorkflow } from "./active-tickets.js";
+import { queueSpend } from "./queue-spend.js";
 import { committed, failed, invalidRequest, publicReceipt, rejection, result, } from "./replies.js";
 export function runIdentity(commandId) {
     return `run-${createHash("sha256").update(commandId).digest("hex").slice(0, 32)}`;
@@ -124,6 +126,9 @@ async function admit(context, admission) {
     const { input } = resolution;
     if (Buffer.byteLength(input) > context.documentBytes)
         return unresolved(context, { kind: "failure", commandId });
+    const held = await spendRefusal(context, admission);
+    if (held !== undefined)
+        return held;
     const receipt = await context.gateway.execute({
         principal: "operator",
         command: {
@@ -154,16 +159,28 @@ async function admit(context, admission) {
         replayed: receipt.kind === "duplicate",
     });
 }
+async function spendRefusal(context, admission) {
+    if (admission.workflow.manifest.queue !== true)
+        return undefined;
+    const spend = record((await queueSpend(context))["spend"]);
+    return spend?.["holding"] === true
+        ? failed("queue-spend-limit", {
+            commandId: admission.commandId,
+            detail: "Queue holding for spend limit.",
+        })
+        : undefined;
+}
 function admissionRefusal(workflow, request) {
-    const { workflowId, commandId, submission, activeTickets } = request;
-    if (workflowId === "develop-issue" &&
+    const { commandId, submission, activeTickets } = request;
+    const tickets = hasTicketField(workflow.submission);
+    if (tickets &&
         typeof submission["ticket"] === "string" &&
         activeTickets.some((input) => input["ticketId"] === submission["ticket"]))
         return failed("ticket-active", {
             commandId,
             detail: "An active run already works on this ticket.",
         });
-    if (workflowId === "develop-issue" && submission["ticket"] !== "next")
+    if (tickets && submission["ticket"] !== "next")
         return undefined;
     return capacityRefusal(workflow, request);
 }
@@ -228,43 +245,12 @@ async function submitted(context, parameters) {
         activeTickets,
     });
 }
-async function activeWorkflow(context, workflowId) {
-    const workflows = await context.authority.queries.workflowIds();
-    const state = await context.authority.state();
-    const runs = Object.values(state.runs).filter((run) => workflows[run.runId] === workflowId &&
-        !["completed", "failed", "cancelled"].includes(run.status));
-    return Promise.all(runs.map(async (run) => {
-        const digest = state.details[run.runId]?.input;
-        const text = digest
-            ? await context.authority.queries.document(digest)
-            : undefined;
-        return record(JSON.parse(text ?? "null")) ?? {};
-    }));
-}
-export async function queueOverview(context) {
-    const workflow = context.registry.byId("develop-issue");
-    if (workflow?.admission === undefined)
-        return {};
-    const active = await activeWorkflow(context, "develop-issue");
-    return {
-        queue: {
-            lanes: workflow.admission === "when-idle" ? 1 : workflow.admission,
-            busy: active.length,
-            skipped: [
-                ...active.flatMap((input) => typeof input["ticketId"] === "string"
-                    ? [{ ticketId: input["ticketId"], reason: "ticket-active" }]
-                    : []),
-                ...(workflow.resolver.skippedTickets?.() ?? []),
-            ],
-        },
-    };
-}
 export function submissionHandler(context) {
     const pending = new Map();
     return (parameters) => {
         const keys = [`command:${String(parameters["commandId"])}`];
         const workflowId = String(parameters["workflowId"]);
-        if (workflowId === "develop-issue" ||
+        if (hasTicketField(context.registry.byId(workflowId)?.submission) ||
             context.registry.byId(workflowId)?.admission !== undefined)
             keys.push(`workflow:${workflowId}`);
         const next = () => submitted(context, parameters);

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

@@ -8,6 +8,7 @@ interface Revised extends Identified {
     readonly expectedRevision: number;
 }
 export interface GateOpening extends Revised {
+    readonly waitMode?: "hook";
     readonly gateId: string;
     readonly kind: "question" | "approval";
     readonly prompt: string;