cloving 1.3.0 → 1.4.0

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

@@ -1,4 +1,5 @@
-import { metadataOf, outcomeOf } from "./run-metadata.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";
@@ -13,6 +14,7 @@ async function snapshot(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(),
@@ -64,9 +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 = {
         ...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,
@@ -84,10 +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 }),
@@ -96,6 +109,7 @@ 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,
@@ -106,6 +120,7 @@ function summary(view) {
         latestSequence: view.latestSequence,
         latestAt: view.latestAt,
         pendingDecisions: view.pendingDecisions,
+        commandWaits: view.commandWaits,
     };
 }
 function full(view) {
@@ -145,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
@@ -165,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 });

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

@@ -1,8 +1,22 @@
 import { type Fields } from "../protocol.ts";
 import type { RunView } from "../authority/status.ts";
-import type { ServiceContext } from "./replies.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

@@ -1,5 +1,43 @@
 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;
@@ -20,13 +58,22 @@ export async function outcomeOf(context, view) {
         ...(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 = input?.["ticket"];
-    if (typeof ticket !== "string")
+    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") {
+    if (workflowId === "develop-prompt" && !Object.hasOwn(input ?? {}, "input")) {
         const first = lines.find((line) => /\S/.test(line));
         return first === undefined
             ? fallback
@@ -42,12 +89,50 @@ export async function metadataOf(context, source) {
         ? 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,
+        ticketId: ticketIdOf(input),
         title: titleOf(input, source.workflowId),
-        ...(source.workflowId === "develop-issue"
-            ? { issueIdentity: issueIdentity(input?.["ticket"]) }
-            : {}),
+        ...(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/service.d.ts

@@ -5,6 +5,7 @@ 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 {
@@ -27,6 +28,7 @@ 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"];
@@ -48,6 +50,8 @@ export interface HostPorts {
     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;

package/dist/src/service/service.js

@@ -9,12 +9,13 @@ import { events } from "./event-handler.js";
 import { expiryScan } from "./expiry.js";
 import { commandGateway, workerCommandBound } from "./gateway.js";
 import { workflowRegistry, } from "./registry.js";
-import { failed, queryMetadata } 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,
@@ -59,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)],
@@ -149,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, registry }));
+    const host = await hosted(options, hostPorts(authority, { worker, registry, gateway }));
     if (host.kind === "refused") {
         await authority.close();
         return host;
@@ -169,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) {
@@ -186,6 +188,7 @@ function serviceGateway(authority, parts) {
 function hostPorts(authority, parts) {
     const { worker, registry } = parts;
     return {
+        commandWait: commandWaitPort({ authority, gateway: parts.gateway }),
         runWait: {
             target: (runId) => runWaitTarget(authority, runId),
             observe: worker.observe,
@@ -217,14 +220,11 @@ function hostPorts(authority, parts) {
         },
     };
 }
-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.js

@@ -7,6 +7,7 @@ import { documentDigest } from "../broker/decision-restore.js";
 import { record } from "../protocol.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)}`;
@@ -125,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: {
@@ -155,9 +159,20 @@ 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;
-    const tickets = workflowId === "develop-issue" || hasTicketField(workflow.submission);
+    const { commandId, submission, activeTickets } = request;
+    const tickets = hasTicketField(workflow.submission);
     if (tickets &&
         typeof submission["ticket"] === "string" &&
         activeTickets.some((input) => input["ticketId"] === submission["ticket"]))
@@ -235,8 +250,7 @@ export function submissionHandler(context) {
     return (parameters) => {
         const keys = [`command:${String(parameters["commandId"])}`];
         const workflowId = String(parameters["workflowId"]);
-        if (workflowId === "develop-issue" ||
-            hasTicketField(context.registry.byId(workflowId)?.submission) ||
+        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.js

@@ -86,7 +86,7 @@ function effectPort(parts) {
                 command: {
                     kind: "report-effect",
                     ...rest,
-                    ...(result === undefined ? {} : { result: documentDigest(result) }),
+                    ...reportedResult({ result, worker: report.worker }),
                 },
                 documents: result === undefined ? [] : [result],
                 epoch: epoch ?? authority.epoch,
@@ -124,3 +124,11 @@ export function workerPort(parts) {
         ...effectPort(parts),
     };
 }
+function reportedResult(report) {
+    if (report.result === undefined)
+        return {};
+    return {
+        result: documentDigest(report.result),
+        ...(report.worker === "command" ? { commandOutput: report.result } : {}),
+    };
+}

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

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

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

@@ -1,6 +1,6 @@
 import { record } from "../protocol.js";
 import { priceOf, usageOf, attemptsOf, workerTotals, } from "../worker-usage.js";
-function reportFields(text) {
+export function reportFields(text) {
     try {
         return record(JSON.parse(text ?? "null")) ?? {};
     }

package/dist/src/step-bridge.d.ts

@@ -64,6 +64,22 @@ export interface RunWaitOutcome {
     readonly reason: string | null;
     readonly promotionId: string | null;
 }
+export interface CommandWaitRequest {
+    readonly name: string;
+    readonly input: HandoffValue;
+}
+export type CommandWaitOutcome = {
+    readonly kind: "ready";
+    readonly value: HandoffValue;
+} | {
+    readonly kind: "timed-out" | "failed" | "refused" | "unavailable";
+    readonly reason: string;
+};
+export type CommandWaitProgress = CommandWaitOutcome | {
+    readonly kind: "pending";
+    readonly deadline: number;
+    readonly nextCheckAt: number;
+};
 export interface CommandRequest {
     readonly scope: ProtectedScope;
     readonly name: string;
@@ -80,6 +96,10 @@ export type GateResult = {
     readonly reason: string;
 };
 export interface StepBridge {
+    readonly openCommandWait?: (request: CommandWaitRequest) => Promise<CommandWaitProgress>;
+    readonly checkCommandWait?: (request: {
+        readonly name: string;
+    }) => Promise<CommandWaitProgress>;
     readonly effect: (request: ProtectedRequest) => Promise<ProtectedResult>;
     readonly gate: (request: GateRequest) => Promise<GateResult>;
     readonly waitForDecision?: (request: GateRequest) => Promise<DecisionWait>;

package/dist/src/steps/command-wait.d.ts

@@ -0,0 +1,12 @@
+import { type CommandWaitRequest, type CommandWaitProgress } from "../command-wait.ts";
+export declare function openCommandWait(request: CommandWaitRequest): Promise<CommandWaitProgress>;
+export declare namespace openCommandWait {
+    var maxRetries: number;
+}
+export declare function checkCommandWait(request: {
+    readonly name: string;
+}): Promise<CommandWaitProgress>;
+export declare namespace checkCommandWait {
+    var maxRetries: number;
+}
+export declare function commandWaitDate(milliseconds: number): Date;

package/dist/src/steps/command-wait.js

@@ -0,0 +1,26 @@
+import { isStepBridge, stepBridgeKey } from "../step-bridge.js";
+import { isCommandWaitRequest, } from "../command-wait.js";
+export async function openCommandWait(request) {
+    "use step";
+    if (!isCommandWaitRequest(request))
+        return { kind: "refused", reason: "invalid-command-wait-request" };
+    const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));
+    if (!isStepBridge(bridge) || bridge.openCommandWait === undefined)
+        return { kind: "unavailable", reason: "cloving-host-unavailable" };
+    return await bridge.openCommandWait({
+        name: request.name,
+        input: request.input,
+    });
+}
+export async function checkCommandWait(request) {
+    "use step";
+    const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));
+    if (!isStepBridge(bridge) || bridge.checkCommandWait === undefined)
+        return { kind: "unavailable", reason: "cloving-host-unavailable" };
+    return await bridge.checkCommandWait({ name: request.name });
+}
+openCommandWait.maxRetries = 0;
+checkCommandWait.maxRetries = 0;
+export function commandWaitDate(milliseconds) {
+    return new Date(milliseconds);
+}

package/dist/src/steps/open-decision-wait.d.ts

@@ -0,0 +1,2 @@
+import { type GateRequest, type DecisionWait } from "../step-bridge.ts";
+export declare function openDecisionWait(request: GateRequest): Promise<DecisionWait>;

package/dist/src/steps/{decision-gate.js → open-decision-wait.js}

@@ -1,11 +1,4 @@
 import { isStepBridge, stepBridgeKey, } from "../step-bridge.js";
-export async function decisionGate(request) {
-    "use step";
-    const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));
-    if (!isStepBridge(bridge))
-        return { kind: "unavailable", reason: "cloving-host-unavailable" };
-    return await bridge.gate(request);
-}
 export async function openDecisionWait(request) {
     "use step";
     const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));

package/dist/src/steps/review-by-person.js

@@ -1,11 +1,14 @@
 import { snapshotReviewSubject } from "./review-subject.js";
 import { waitForDecision } from "./wait-for-decision.js";
 export async function reviewByPerson(request) {
+    let draft = "draft" in request.subject ? request.subject.draft : null;
+    if (draft !== null && request.subject.commit !== undefined)
+        draft = `${request.subject.commit}\n${draft}`;
     const snapshot = await snapshotReviewSubject(request.subject);
     const decision = await waitForDecision({
         gateId: `review:${snapshot.subjectDigest}`,
         kind: "approval",
-        prompt: `Review this subject:\n${snapshot.prompt}`,
+        prompt: `Review this subject:\n${draft ?? snapshot.prompt}`,
     });
     return {
         accepted: decision.decision === "approved",

package/dist/src/steps/wait-for-command.d.ts

@@ -0,0 +1,3 @@
+import { type CommandWaitRequest, type CommandWaitOutcome } from "../command-wait.ts";
+export type { CommandWaitRequest, CommandWaitOutcome, } from "../command-wait.ts";
+export declare function waitForCommand(request: CommandWaitRequest): Promise<CommandWaitOutcome>;

package/dist/src/steps/wait-for-command.js

@@ -0,0 +1,17 @@
+import { sleep } from "workflow";
+import { isCommandWaitRequest, } from "../command-wait.js";
+import { openCommandWait, checkCommandWait, commandWaitDate, } from "./command-wait.js";
+export async function waitForCommand(request) {
+    if (!isCommandWaitRequest(request))
+        return { kind: "refused", reason: "invalid-command-wait-request" };
+    let result = await openCommandWait({
+        name: request.name,
+        input: request.input,
+    });
+    while (result.kind === "pending") {
+        result = await checkCommandWait({ name: request.name });
+        if (result.kind === "pending")
+            await sleep(commandWaitDate(Math.min(result.deadline, result.nextCheckAt)));
+    }
+    return result;
+}

package/dist/src/steps/wait-for-decision.js

@@ -51,7 +51,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { createHook } from "workflow";
-import { openDecisionWait } from "./decision-gate.js";
+import { openDecisionWait } from "./open-decision-wait.js";
 export async function waitForDecision(request) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {

package/dist/src/storage/command-wait-rows.d.ts

@@ -0,0 +1,30 @@
+import { type SqlConnection } from "./domain-rows.ts";
+import { type Statement } from "./statements.ts";
+export declare const commandWaitSchema = "\nCREATE TABLE command_waits (\n  run_id TEXT NOT NULL REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,\n  name TEXT NOT NULL,\n  command TEXT NOT NULL,\n  input_digest TEXT NOT NULL REFERENCES documents (digest) DEFERRABLE INITIALLY DEFERRED,\n  maximum_wait_seconds INTEGER NOT NULL,\n  poll_every_seconds INTEGER NOT NULL,\n  started_at INTEGER NOT NULL,\n  deadline INTEGER NOT NULL,\n  next_check_at INTEGER,\n  state TEXT NOT NULL,\n  settled_at INTEGER,\n  reason TEXT,\n  PRIMARY KEY (run_id, name)\n) STRICT;\n";
+export declare const commandWaitCheckSchema = "\nALTER TABLE command_waits ADD COLUMN check_count INTEGER NOT NULL DEFAULT 0;\nALTER TABLE command_waits ADD COLUMN check_operation TEXT;\nALTER TABLE command_waits ADD COLUMN last_check_settled_at INTEGER;\nALTER TABLE command_waits ADD COLUMN result TEXT;\n";
+export interface CommandWaitRow {
+    readonly runId: string;
+    readonly name: string;
+    readonly command: string;
+    readonly inputDigest: string;
+    readonly maximumWaitSeconds: number;
+    readonly pollEverySeconds: number;
+    readonly startedAt: number;
+    readonly deadline: number;
+    readonly nextCheckAt: number | null;
+    readonly state: string;
+    readonly checkCount: number;
+    readonly checkOperation: string | null;
+    readonly lastCheckSettledAt: number | null;
+    readonly result: string | null;
+    readonly settledAt: number | null;
+    readonly reason: string | null;
+}
+export declare function commandWaitRow(value: unknown): CommandWaitRow;
+export declare function loadCommandWaits(connection: SqlConnection, scope?: {
+    readonly runId?: string;
+    readonly version?: "opened";
+}): Promise<readonly CommandWaitRow[]>;
+export declare function commandWaitStatements(rows: readonly CommandWaitRow[], scope?: {
+    readonly version?: "opened";
+}): readonly Statement[];