cloving 1.2.0 → 1.4.0

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, tokenCount, workerTotals, } from "../worker-usage.js";
-function reportFields(text) {
+import { priceOf, usageOf, attemptsOf, workerTotals, } from "../worker-usage.js";
+export function reportFields(text) {
     try {
         return record(JSON.parse(text ?? "null")) ?? {};
     }
@@ -8,28 +8,6 @@ function reportFields(text) {
         return {};
     }
 }
-function attemptsOf(value) {
-    if (!Array.isArray(value))
-        return undefined;
-    return value.flatMap((entry) => {
-        const fields = record(entry) ?? {};
-        const attempt = tokenCount(fields["attempt"]);
-        const model = fields["model"];
-        if (attempt === null ||
-            attempt === 0 ||
-            (model !== null && typeof model !== "string"))
-            return [];
-        return [
-            {
-                attempt,
-                model,
-                usage: usageOf(fields["usage"]),
-                costUsd: priceOf(fields["costUsd"]),
-                estimatedCostUsd: priceOf(fields["estimatedCostUsd"]),
-            },
-        ];
-    });
-}
 export async function usageTotals(context, runId) {
     const { effects, queries } = context.authority;
     const operations = (await effects.operations(runId)).filter((operation) => operation.capability === "claude" &&
@@ -40,7 +18,14 @@ export async function usageTotals(context, runId) {
             ? undefined
             : await queries.document(operation.result));
         const attempts = attemptsOf(report["attempts"]);
+        const model = report["model"];
+        const summary = report["summary"];
+        const harness = report["harness"] ??
+            (await context.workerHarness?.(operation.operationId));
         turns.push({
+            ...(typeof model === "string" ? { model } : {}),
+            ...(typeof summary === "string" ? { summary } : {}),
+            ...(typeof harness === "string" ? { harness } : {}),
             ...(attempts === undefined ? {} : { attempts }),
             operationId: operation.operationId,
             usage: usageOf(report["usage"]),

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

@@ -41,6 +41,13 @@ export interface GateRequest {
     readonly prompt: string;
     readonly expiresAt?: string;
 }
+export interface DecisionResult {
+    readonly decision: "approved" | "denied" | "answered" | "expired";
+    readonly answer: string | null;
+}
+export type DecisionWait = {
+    readonly token: string;
+} | DecisionResult;
 export type HandoffValue = string | number | boolean | null | readonly HandoffValue[] | {
     readonly [key: string]: HandoffValue;
 };
@@ -48,6 +55,36 @@ export interface HandoffRequest {
     readonly workflowId: string;
     readonly input: Readonly<Record<string, HandoffValue>>;
 }
+export interface RunWaitRequest {
+    readonly runId: string;
+    readonly maximumWaitSeconds: number;
+}
+export interface RunWaitOutcome {
+    readonly kind: string;
+    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;
+    readonly input: HandoffValue;
+}
 export type GateResult = {
     readonly kind: "opened";
     readonly decisionId: string;
@@ -59,8 +96,14 @@ 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>;
     readonly handoff?: (request: HandoffRequest) => Promise<ProtectedResult>;
+    readonly waitForRun?: (request: RunWaitRequest) => Promise<RunWaitOutcome>;
 }
 export declare function isStepBridge(value: unknown): value is StepBridge;

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/merge-by-person.d.ts

@@ -0,0 +1,2 @@
+import { type MergeRequest, type MergeResult } from "../merge-request.ts";
+export declare function mergeByPerson(request: MergeRequest): Promise<MergeResult>;

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

@@ -0,0 +1,18 @@
+import { mergeRequest, } from "../merge-request.js";
+import { mergeWhenGreen } from "./merge-when-green.js";
+import { waitForDecision } from "./wait-for-decision.js";
+export async function mergeByPerson(request) {
+    const { pull, check, round } = mergeRequest(request);
+    const decision = await waitForDecision({
+        gateId: `merge:${String(pull.number)}:${pull.commit}`,
+        kind: "approval",
+        prompt: `Merge pull request #${String(pull.number)} (${pull.url}) at commit ${pull.commit} ${check === null ? "with no local check" : `after the local check ${check}`}.`,
+    });
+    if (decision.decision !== "approved")
+        return {
+            merged: false,
+            reason: "not-approved",
+            output: decision.answer ?? "",
+        };
+    return await mergeWhenGreen({ pull, check, round });
+}

package/dist/src/steps/merge-when-green.d.ts

@@ -0,0 +1,2 @@
+import { type MergeRequest, type MergeResult } from "../merge-request.ts";
+export declare function mergeWhenGreen(request: MergeRequest): Promise<MergeResult>;

package/dist/src/steps/merge-when-green.js

@@ -0,0 +1,62 @@
+import { mergeRequest, } from "../merge-request.js";
+import { record } from "../protocol.js";
+import { protectedEffect } from "./protected-effect.js";
+const repairReasons = [
+    "check-failed",
+    "merge-conflict",
+    "ci-failed",
+    "ci-pending",
+];
+export async function mergeWhenGreen(request) {
+    const { pull, check, round } = mergeRequest(request);
+    const effect = await protectedEffect({
+        capability: "github",
+        method: "merge",
+        target: pull.target,
+        payload: JSON.stringify({
+            number: pull.number,
+            commit: pull.commit,
+            check,
+        }),
+        scope: {
+            phase: "merge",
+            operation: "merge",
+            round,
+            key: `${String(pull.number)}:${pull.commit}`,
+        },
+        units: 1,
+    });
+    return mergeOutcome(effect, pull);
+}
+function mergeOutcome(effect, pull) {
+    if (effect.kind !== "completed")
+        return notMerged(effect);
+    const result = parsedResult(effect.result);
+    const reason = repairReasons.find((name) => name === result["reason"]);
+    if (reason !== undefined && typeof result["output"] === "string")
+        return { merged: false, reason, output: result["output"] };
+    if (result["reason"] !== undefined ||
+        result["number"] !== pull.number ||
+        result["commit"] !== pull.commit ||
+        typeof result["merged"] !== "string")
+        throw new Error("invalid-merge-result");
+    return { merged: true, reason: null, output: "" };
+}
+function notMerged(effect) {
+    if (effect.kind === "failed" && effect.reason === "check-not-configured")
+        return { merged: false, reason: "check-not-configured", output: "" };
+    throw new Error(effect.reason ?? effect.kind);
+}
+function parsedResult(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text ?? "null");
+    }
+    catch {
+        throw new Error("invalid-merge-result");
+    }
+    const result = record(parsed);
+    if (result === undefined)
+        throw new Error("invalid-merge-result");
+    return result;
+}

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/open-decision-wait.js

@@ -0,0 +1,8 @@
+import { isStepBridge, stepBridgeKey, } from "../step-bridge.js";
+export async function openDecisionWait(request) {
+    "use step";
+    const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));
+    if (!isStepBridge(bridge) || bridge.waitForDecision === undefined)
+        throw new Error("cloving-host-unavailable");
+    return await bridge.waitForDecision(request);
+}

package/dist/src/steps/review-by-agent.d.ts

@@ -0,0 +1,5 @@
+import type { ReviewResult, ReviewSubject, Reviewer } from "../review-subject.ts";
+export declare function reviewByAgent(request: {
+    readonly subject: ReviewSubject;
+    readonly reviewer: Reviewer;
+}): Promise<ReviewResult>;

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

@@ -0,0 +1,124 @@
+import { record } from "../protocol.js";
+import { protectedEffect } from "./protected-effect.js";
+import { snapshotReviewSubject } from "./review-subject.js";
+export async function reviewByAgent(request) {
+    const reviewer = selectedReviewer(request.reviewer);
+    const subject = { ...request.subject };
+    const snapshot = await snapshotReviewSubject(subject);
+    const effect = await protectedEffect({
+        ...reviewEffect({ subject, snapshot, reviewer }),
+        scope: {
+            phase: "review",
+            operation: reviewer.kind === "greptile" ? "greptile" : `turn:${reviewer.profile}`,
+            round: 1,
+            key: snapshot.subjectDigest,
+        },
+        units: 1,
+    });
+    if (effect.kind !== "completed")
+        throw new Error(effect.reason ?? effect.kind);
+    let parsed;
+    try {
+        parsed = JSON.parse(effect.result ?? "null");
+    }
+    catch {
+        throw new Error("invalid-review-result");
+    }
+    return {
+        ...(reviewer.kind === "turn"
+            ? turnResult(parsed)
+            : greptileFeedback(parsed, subject)),
+        commit: snapshot.commit,
+        subjectDigest: snapshot.subjectDigest,
+    };
+}
+function selectedReviewer(value) {
+    const reviewer = record(value);
+    if (reviewer?.["kind"] === "greptile")
+        return { kind: "greptile" };
+    if (reviewer?.["kind"] === "turn" &&
+        typeof reviewer["profile"] === "string" &&
+        /^[A-Za-z0-9_-]{1,119}$/.test(reviewer["profile"]))
+        return { kind: "turn", profile: reviewer["profile"] };
+    throw new Error("invalid-reviewer");
+}
+function reviewEffect(input) {
+    const { subject, snapshot, reviewer } = input;
+    if (reviewer.kind === "turn")
+        return {
+            capability: "claude",
+            method: `run-turn:${reviewer.profile}`,
+            target: "draft" in subject ? snapshot.subjectDigest : subject.target,
+            payload: `Review only this immutable subject. Do not change it. For a commit, inspect that exact commit, not the current branch head.\n${snapshot.prompt}\nEnd your report with exactly one of these lines:\nReview verdict: accept\nReview verdict: change`,
+        };
+    if ("draft" in subject ||
+        !Number.isSafeInteger(subject.number) ||
+        Number(subject.number) < 1)
+        throw new Error("invalid-greptile-subject");
+    return {
+        capability: "github",
+        method: "wait-review",
+        target: subject.target,
+        payload: JSON.stringify({ number: subject.number, commit: subject.commit }),
+    };
+}
+function turnResult(parsed) {
+    const result = record(parsed);
+    if (result &&
+        (result["reviewVerdict"] === null || result["reviewVerdict"] === undefined))
+        return {
+            accepted: false,
+            feedback: "The review turn has no verdict line.",
+        };
+    if (!result ||
+        typeof result["summary"] !== "string" ||
+        (result["reviewVerdict"] !== "accept" &&
+            result["reviewVerdict"] !== "change"))
+        throw new Error("invalid-review-result");
+    return {
+        accepted: result["reviewVerdict"] === "accept",
+        feedback: result["summary"],
+    };
+}
+function greptileFeedback(parsed, subject) {
+    if ("draft" in subject)
+        throw new Error("invalid-greptile-subject");
+    const result = greptileResult(parsed, subject);
+    return {
+        accepted: result.score === 5,
+        feedback: [result.summary, ...result.findings].filter(Boolean).join("\n\n"),
+    };
+}
+function greptileResult(parsed, subject) {
+    const result = record(parsed);
+    if (!result)
+        throw new Error("invalid-review-result");
+    const score = result["score"];
+    const summary = result["summary"];
+    const findings = result["findings"];
+    if (result["number"] !== subject.number ||
+        result["commit"] !== subject.commit ||
+        typeof score !== "number" ||
+        !Number.isInteger(score) ||
+        score < 0 ||
+        score > 5 ||
+        typeof summary !== "string" ||
+        !Array.isArray(findings))
+        throw new Error("invalid-review-result");
+    return {
+        score,
+        summary,
+        findings: findings.map((value) => {
+            const finding = record(value);
+            if (!finding)
+                throw new Error("invalid-review-result");
+            const { path, line, body } = finding;
+            if (typeof path !== "string" ||
+                typeof body !== "string" ||
+                !(line === null ||
+                    (typeof line === "number" && Number.isSafeInteger(line) && line > 0)))
+                throw new Error("invalid-review-result");
+            return `${path}${line === null ? "" : `:${String(line)}`}\n${body}`;
+        }),
+    };
+}

package/dist/src/steps/review-by-person.d.ts

@@ -0,0 +1,4 @@
+import type { ReviewResult, ReviewSubject } from "../review-subject.ts";
+export declare function reviewByPerson(request: {
+    readonly subject: ReviewSubject;
+}): Promise<ReviewResult>;

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

@@ -0,0 +1,19 @@
+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${draft ?? snapshot.prompt}`,
+    });
+    return {
+        accepted: decision.decision === "approved",
+        feedback: decision.answer ?? "",
+        commit: snapshot.commit,
+        subjectDigest: snapshot.subjectDigest,
+    };
+}

package/dist/src/steps/review-subject.d.ts

@@ -0,0 +1,2 @@
+import { type ReviewSubject, type ReviewSnapshot } from "../review-subject.ts";
+export declare function snapshotReviewSubject(subject: ReviewSubject): Promise<ReviewSnapshot>;

package/dist/src/steps/review-subject.js

@@ -0,0 +1,11 @@
+import { operationDigest } from "../broker/operation-digest.js";
+import { reviewSubjectText, } from "../review-subject.js";
+export async function snapshotReviewSubject(subject) {
+    "use step";
+    const prompt = reviewSubjectText(subject);
+    return Promise.resolve({
+        commit: "draft" in subject ? null : subject.commit,
+        subjectDigest: `sha256:${operationDigest(prompt)}`,
+        prompt,
+    });
+}

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

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

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

@@ -0,0 +1,15 @@
+import { isStepBridge, stepBridgeKey, } from "../step-bridge.js";
+export async function runCommand(request) {
+    "use step";
+    const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));
+    if (!isStepBridge(bridge))
+        return { kind: "unavailable", reason: "cloving-host-unavailable" };
+    return await bridge.effect({
+        scope: request.scope,
+        capability: "command",
+        method: `run:${request.name}`,
+        target: request.name,
+        payload: JSON.stringify(request.input),
+        units: 1,
+    });
+}

package/dist/src/steps/sleep.d.ts

@@ -0,0 +1,3 @@
+export declare function sleep(request: {
+    readonly seconds: number;
+}): Promise<void>;

package/dist/src/steps/sleep.js

@@ -0,0 +1,19 @@
+import { sleep as sdkSleep } from "workflow";
+export async function sleep(request) {
+    await sdkSleep(sleepSeconds(request) * 1000);
+}
+function sleepSeconds(request) {
+    if (typeof request !== "object" ||
+        request === null ||
+        Reflect.ownKeys(request).length !== 1)
+        throw new Error("invalid-sleep-seconds");
+    const field = Object.getOwnPropertyDescriptor(request, "seconds") ?? {};
+    const seconds = field.value;
+    if (field.enumerable !== true ||
+        typeof seconds !== "number" ||
+        !Number.isInteger(seconds) ||
+        seconds < 1 ||
+        seconds > 86400)
+        throw new Error("invalid-sleep-seconds");
+    return seconds;
+}

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.d.ts

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

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

@@ -0,0 +1,71 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { createHook } from "workflow";
+import { openDecisionWait } from "./open-decision-wait.js";
+export async function waitForDecision(request) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const wait = await openDecisionWait(request);
+        if ("decision" in wait)
+            return wait;
+        const hook = __addDisposableResource(env_1, createHook({ token: wait.token }), false);
+        return await hook;
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+}

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

@@ -0,0 +1,5 @@
+import { type RunWaitOutcome, type RunWaitRequest } from "../step-bridge.ts";
+export declare function waitForRun(request: RunWaitRequest): Promise<RunWaitOutcome>;
+export declare namespace waitForRun {
+    var maxRetries: number;
+}

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

@@ -0,0 +1,9 @@
+import { isStepBridge, stepBridgeKey, } from "../step-bridge.js";
+export async function waitForRun(request) {
+    "use step";
+    const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));
+    if (!isStepBridge(bridge) || bridge.waitForRun === undefined)
+        throw new Error("cloving-host-unavailable");
+    return await bridge.waitForRun(request);
+}
+waitForRun.maxRetries = 86401;

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[];