cloving 1.3.0 → 1.5.0

package/dist/src/daemon/workflow-schedules.js

@@ -1,10 +1,12 @@
 import { join } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { mutate } from "../cli/client.js";
-import { record } from "../protocol.js";
+import { record, } from "../protocol.js";
 import { runIdentity } from "../service/submission-handler.js";
 import { configuredSchedules } from "../workflow-schedule.js";
 import { declaredInput } from "./declared-input.js";
+import { finishedScheduleRun } from "../schedule-progress.js";
+import { scheduleControl } from "./schedule-control.js";
 import { scheduleJournal, } from "./schedule-journal.js";
 export function scheduledDeclarations(settings, limits) {
     try {
@@ -60,6 +62,8 @@ async function pending(settings, entry) {
     const { pending: planned, ...rest } = progress;
     if (planned === undefined)
         return progress;
+    if (progress.state !== "active")
+        throw new Error("invalid-schedule-state");
     const identity = commandId(workflowId, progress.lastSlot);
     if (planned.kind === "skip") {
         const receipt = await settings.submit({
@@ -86,10 +90,7 @@ async function pending(settings, entry) {
         throw new Error(reply.error.code);
     return { ...rest, activeCommandId: identity };
 }
-async function active(settings, progress) {
-    if (progress.activeCommandId === undefined)
-        return undefined;
-    const runId = runIdentity(progress.activeCommandId);
+async function scheduledRunStatus(settings, runId) {
     const reply = await request(settings, {
         operation: "status",
         parameters: { runId },
@@ -99,45 +100,76 @@ async function active(settings, progress) {
     const run = record(reply.result["run"]);
     if (typeof run?.["state"] !== "string")
         throw new Error("invalid-schedule-run");
+    return run;
+}
+async function active(settings, progress) {
+    if (progress.activeCommandId === undefined)
+        return progress;
+    const now = (settings.scheduleClock ?? Date.now)();
+    const observedAt = settings.observationClock();
+    const next = settings.nextObservations.get(progress.activeCommandId) ?? 0;
+    const due = progress.state === "active" && now >= progress.nextAt;
+    if (!due && observedAt < next)
+        return progress;
+    const runId = runIdentity(progress.activeCommandId);
+    const run = await scheduledRunStatus(settings, runId);
+    settings.nextObservations.set(progress.activeCommandId, observedAt + 5000);
     if (run["condition"] === "cancelling")
-        return runId;
-    return ["completed", "failed", "cancelled"].includes(run["state"])
+        return progress;
+    if (!["completed", "failed", "cancelled"].includes(String(run["state"])))
+        return progress;
+    settings.nextObservations.delete(progress.activeCommandId);
+    return finishedScheduleRun(progress, {
+        runId,
+        status: run,
+        now: (settings.scheduleClock ?? Date.now)(),
+    });
+}
+async function advance(settings, declaration) {
+    settings.signal.throwIfAborted();
+    const { workflowId, schedule } = declaration;
+    if (schedule === undefined)
+        return;
+    let progress = settings.journal.entries.get(workflowId);
+    if (progress === undefined)
+        throw new Error("missing-schedule-state");
+    if (progress.pending !== undefined) {
+        progress = await pending(settings, { workflowId, progress });
+        settings.journal.entries.set(workflowId, progress);
+        await settings.journal.save();
+        if (settings.now < progress.nextAt)
+            return;
+    }
+    const observed = await active(settings, progress);
+    if (observed !== progress) {
+        progress = observed;
+        settings.journal.entries.set(workflowId, progress);
+        await settings.journal.save();
+    }
+    if (progress.state !== "active" || settings.now < progress.nextAt)
+        return;
+    const runId = progress.activeCommandId === undefined
         ? undefined
-        : runId;
+        : runIdentity(progress.activeCommandId);
+    const planned = runId === undefined
+        ? { kind: "run", input: schedule.input }
+        : { kind: "skip", runId };
+    const elapsed = Math.floor((settings.now - progress.nextAt) / (schedule.everySeconds * 1000)) + 1;
+    progress = {
+        ...progress,
+        lastSlot: progress.lastSlot + elapsed,
+        nextAt: progress.nextAt + elapsed * schedule.everySeconds * 1000,
+        pending: planned,
+    };
+    settings.journal.entries.set(workflowId, progress);
+    await settings.journal.save();
+    settings.journal.entries.set(workflowId, await pending(settings, { workflowId, progress }));
+    await settings.journal.save();
 }
 async function tick(settings, journal) {
     const now = (settings.scheduleClock ?? Date.now)();
-    for (const declaration of settings.declarations ?? []) {
-        settings.signal.throwIfAborted();
-        const { workflowId, schedule } = declaration;
-        if (schedule === undefined)
-            continue;
-        let progress = journal.entries.get(workflowId);
-        if (progress === undefined)
-            throw new Error("missing-schedule-state");
-        if (progress.pending !== undefined) {
-            progress = await pending(settings, { workflowId, progress });
-            journal.entries.set(workflowId, progress);
-            await journal.save();
-        }
-        if (now < progress.nextAt)
-            continue;
-        const runId = await active(settings, progress);
-        const planned = runId === undefined
-            ? { kind: "run", input: schedule.input }
-            : { kind: "skip", runId };
-        const elapsed = Math.floor((now - progress.nextAt) / (schedule.everySeconds * 1000)) + 1;
-        progress = {
-            ...progress,
-            lastSlot: progress.lastSlot + elapsed,
-            nextAt: progress.nextAt + elapsed * schedule.everySeconds * 1000,
-            pending: planned,
-        };
-        journal.entries.set(workflowId, progress);
-        await journal.save();
-        journal.entries.set(workflowId, await pending(settings, { workflowId, progress }));
-        await journal.save();
-    }
+    for (const declaration of settings.declarations ?? [])
+        await advance({ ...settings, journal, now }, declaration);
 }
 async function initialized(settings) {
     const journal = await scheduleJournal(join(settings.directory, "state"));
@@ -150,36 +182,57 @@ async function initialized(settings) {
         if (prior?.everySeconds === schedule.everySeconds)
             continue;
         journal.entries.set(workflowId, {
-            ...prior,
+            ...(prior ?? {
+                lastSlot: 0,
+                state: "active",
+                failuresInRow: 0,
+                failedRunIds: [],
+            }),
             everySeconds: schedule.everySeconds,
-            lastSlot: prior?.lastSlot ?? 0,
             nextAt: now + schedule.everySeconds * 1000,
         });
     }
-    await journal.save();
+    if (settings.declarations?.some((entry) => entry.schedule !== undefined))
+        await journal.save();
     return journal;
 }
 export async function workflowSchedules(settings) {
-    if (!(settings.declarations ?? []).some((entry) => entry.schedule !== undefined))
-        return { stop: () => Promise.resolve() };
+    const declarations = settings.declarations ?? [];
     const journal = await initialized(settings);
     const stopping = new AbortController();
     const stopped = () => stopping.signal.aborted;
+    const context = {
+        ...settings,
+        signal: stopping.signal,
+        nextObservations: new Map(),
+        observationClock: settings.scheduleObservationClock ?? (() => performance.now()),
+    };
+    const control = scheduleControl({
+        journal,
+        declarations,
+        clock: settings.scheduleClock ?? Date.now,
+        signal: stopping.signal,
+        recoverPending: (entry) => pending(context, entry),
+        tick: () => tick(context, journal),
+    });
     const running = (async () => {
         while (!stopped()) {
             await delay(250, undefined, { signal: stopping.signal }).catch(() => undefined);
             if (stopped())
                 return;
-            await tick({ ...settings, signal: stopping.signal }, journal);
+            await control.tick();
         }
     })().catch((error) => {
         if (!stopped())
             process.stderr.write(`Schedules stopped: ${String(error)}\n`);
+        stopping.abort();
     });
     return {
+        request: control.request,
         stop: async () => {
             stopping.abort();
             await running;
+            await control.drain();
         },
     };
 }

package/dist/src/daemon/worktree-processes.d.ts

@@ -0,0 +1,9 @@
+export declare function recordedProcessDirectory(processId: number): Promise<string | undefined>;
+interface StopRequest {
+    readonly directory: string;
+    readonly folder: string;
+    readonly signal: AbortSignal;
+    readonly stopMilliseconds?: number;
+}
+export declare function stopTreeProcesses(request: StopRequest): Promise<boolean>;
+export {};

package/dist/src/daemon/worktree-processes.js

@@ -0,0 +1,151 @@
+import { execFile } from "node:child_process";
+import { readdir, readlink, realpath } from "node:fs/promises";
+import { resolve, sep } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { promisify } from "node:util";
+import { writeRecord } from "./operation-journal.js";
+const execute = promisify(execFile);
+async function output(command, arguments_) {
+    return (await execute(command, arguments_, {
+        encoding: "utf8",
+        timeout: 5000,
+        maxBuffer: 8 * 1024 * 1024,
+    })).stdout;
+}
+async function directories() {
+    if (process.platform === "linux") {
+        const entries = await readdir("/proc");
+        const links = await Promise.all(entries
+            .filter((entry) => /^\d+$/.test(entry))
+            .map(async (entry) => {
+            const directory = await readlink(`/proc/${entry}/cwd`).catch(() => undefined);
+            return [Number(entry), directory];
+        }));
+        return new Map(links.filter((entry) => entry[1] !== undefined));
+    }
+    const text = await output("lsof", ["-d", "cwd", "-Fpn", "-n", "-P"]);
+    const found = new Map();
+    let processId = 0;
+    for (const line of text.split("\n")) {
+        if (line.startsWith("p"))
+            processId = Number(line.slice(1));
+        if (line.startsWith("n"))
+            found.set(processId, line.slice(1));
+    }
+    return found;
+}
+async function processes() {
+    try {
+        const text = await output("ps", ["-axo", "pid=,pgid=,uid="]);
+        const entries = text
+            .trim()
+            .split("\n")
+            .map((line) => {
+            const [processId = 0, group = 0, user = -1] = line
+                .trim()
+                .split(/\s+/)
+                .map(Number);
+            return { processId, group, user };
+        });
+        const working = await directories();
+        return entries.map((entry) => {
+            const directory = working.get(entry.processId);
+            return { ...entry, ...(directory === undefined ? {} : { directory }) };
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+function inTree(entry, directory) {
+    if (entry.processId <= 1 ||
+        entry.processId === process.pid ||
+        entry.directory === undefined)
+        return false;
+    const root = resolve(directory);
+    return entry.directory === root || entry.directory.startsWith(root + sep);
+}
+export async function recordedProcessDirectory(processId) {
+    return (await processes())?.find((entry) => entry.processId === processId)
+        ?.directory;
+}
+function terminate(entries, request) {
+    const { directory, signal } = request;
+    const maySignal = (entry) => entry.user === process.getuid?.() && inTree(entry, directory);
+    const found = entries.filter(maySignal);
+    const groups = new Set();
+    for (const entry of found) {
+        const safeGroup = entry.group > 1 &&
+            entries.filter((other) => other.group === entry.group).every(maySignal);
+        const target = safeGroup ? -entry.group : entry.processId;
+        if (groups.has(target))
+            continue;
+        groups.add(target);
+        try {
+            process.kill(target, signal);
+        }
+        catch {
+            continue;
+        }
+    }
+    return found.map((entry) => entry.processId);
+}
+async function treeSnapshot(directory) {
+    const entries = await processes();
+    return entries?.some((entry) => inTree(entry, directory)) === false
+        ? processes()
+        : entries;
+}
+async function waitForTree(request, deadline) {
+    while (!request.signal.aborted) {
+        const entries = await treeSnapshot(request.directory);
+        if (entries === undefined ||
+            !entries.some((entry) => inTree(entry, request.directory)) ||
+            performance.now() >= deadline)
+            return entries;
+        await delay(Math.min(250, Math.max(0, deadline - performance.now())));
+    }
+    return undefined;
+}
+export async function stopTreeProcesses(request) {
+    const directory = await realpath(request.directory).catch(() => undefined);
+    return directory === undefined
+        ? false
+        : stopCanonicalTree({ ...request, directory });
+}
+async function stopCanonicalTree(request) {
+    const entries = await treeSnapshot(request.directory);
+    const aborted = () => request.signal.aborted;
+    if (entries === undefined || aborted())
+        return false;
+    const processIds = terminate(entries, {
+        directory: request.directory,
+        signal: "SIGTERM",
+    });
+    let remaining = processIds.length === 0
+        ? entries
+        : await waitForTree(request, performance.now() + (request.stopMilliseconds ?? 15_000));
+    if (remaining === undefined || aborted())
+        return recordCleanup(request, { processIds, remaining });
+    const killed = terminate(remaining, {
+        directory: request.directory,
+        signal: "SIGKILL",
+    });
+    processIds.push(...killed);
+    if (killed.length > 0)
+        remaining = await waitForTree(request, performance.now() + 1000);
+    return recordCleanup(request, { processIds, remaining });
+}
+async function recordCleanup(request, cleanup) {
+    const remainingProcessIds = cleanup.remaining
+        ?.filter((entry) => inTree(entry, request.directory))
+        .map((entry) => entry.processId);
+    await writeRecord(request.folder, {
+        name: "resume-processes.json",
+        value: {
+            processIds: [...new Set(cleanup.processIds)],
+            remainingProcessIds,
+        },
+    });
+    return !request.signal.aborted && remainingProcessIds?.length === 0;
+}

package/dist/src/doctor-report.d.ts

@@ -1,8 +1,8 @@
 import { type SubmissionContract } from "./submission.ts";
-export declare const doctorCodes: readonly ["git-repository", "node-version", "harnesses", "default-harness", "gh-login", "github-origin", "greptile-review", "settings-files", "runtime-directory", "service", "ticket-command", "next-command", "check-command", "queue-interval", "private-texts"];
+export declare const doctorCodes: readonly ["git-repository", "node-version", "harnesses", "default-harness", "gh-login", "github-origin", "greptile-review", "settings-files", "no-workflow", "runtime-directory", "service", "ticket-command", "next-command", "check-command", "queue-interval", "private-texts", "retention"];
 export type DoctorCode = (typeof doctorCodes)[number];
 export interface DoctorObservation {
-    readonly result: "ok" | "fail" | "skip";
+    readonly result: "ok" | "warn" | "fail" | "skip";
     readonly detail: string;
 }
 export interface DoctorCheck extends DoctorObservation {
@@ -14,11 +14,9 @@ export declare const doctorFixes: Readonly<Record<DoctorCode, string>>;
 export declare function doctorExitCode(checks: readonly DoctorCheck[]): number;
 export interface DoctorWorkflow {
     readonly queue?: boolean;
-    readonly scope: "bundled" | "project" | "user";
+    readonly scope: "project" | "user";
     readonly workflowId: string;
     readonly capabilities: readonly string[];
     readonly input?: SubmissionContract;
 }
-export declare function requiredDoctorCodes(workflows: readonly DoctorWorkflow[], options: {
-    readonly queueSeconds: string | undefined;
-}): readonly DoctorCode[];
+export declare function requiredDoctorCodes(workflows: readonly DoctorWorkflow[]): readonly DoctorCode[];

package/dist/src/doctor-report.js

@@ -8,6 +8,7 @@ export const doctorCodes = [
     "github-origin",
     "greptile-review",
     "settings-files",
+    "no-workflow",
     "runtime-directory",
     "service",
     "ticket-command",
@@ -15,6 +16,7 @@ export const doctorCodes = [
     "check-command",
     "queue-interval",
     "private-texts",
+    "retention",
 ];
 export const doctorFixes = {
     "git-repository": "Change to the repository, or run: git init",
@@ -25,6 +27,7 @@ export const doctorFixes = {
     "github-origin": "Set a GitHub origin: git remote add origin git@github.com:OWNER/REPO.git || git remote set-url origin git@github.com:OWNER/REPO.git",
     "greptile-review": "Install the Greptile app at https://github.com/apps/greptile, then open a first pull request: gh pr create",
     "settings-files": "Fix the project JSON: ${EDITOR:-vi} .cloving/config.json; for private JSON, edit <config>/cloving/projects/<repository-id>.json",
+    "no-workflow": "cloving init",
     "runtime-directory": 'Select a private writable runtime: CLOVING_RUNTIME_DIR="$HOME/.local/state/cloving/doctor/run" cloving doctor',
     service: "Start the service: cloving start",
     "ticket-command": "Set tickets.command to an executable list: ${EDITOR:-vi} .cloving/config.json",
@@ -32,39 +35,31 @@ export const doctorFixes = {
     "check-command": "Set checks.beforeMerge to an executable list: ${EDITOR:-vi} .cloving/config.json",
     "queue-interval": "Set an interval from 10 to 3600: CLOVING_QUEUE_SECONDS=30 cloving doctor",
     "private-texts": `Set a nonblank private text: CLOVING_PRIVATE_TEXTS='["TEXT TO KEEP PRIVATE"]' cloving doctor`,
+    retention: "Set a retention period: cloving config set retention.days 30 --private",
 };
 export function doctorExitCode(checks) {
     return checks.some((check) => check.required && check.result !== "ok")
         ? 1
         : 0;
 }
-export function requiredDoctorCodes(workflows, options) {
+export function requiredDoctorCodes(workflows) {
     const codes = new Set([
         "git-repository",
         "node-version",
         "default-harness",
         "settings-files",
+        "no-workflow",
         "runtime-directory",
     ]);
     if (workflows.some((workflow) => workflow.capabilities.includes("github"))) {
         codes.add("gh-login");
         codes.add("github-origin");
     }
-    const bundled = workflows
-        .filter((workflow) => workflow.scope === "bundled")
-        .map((workflow) => workflow.workflowId);
-    const issue = bundled.includes("develop-issue");
-    if (issue)
-        codes.add("check-command");
-    if (workflows.some((workflow) => workflow.queue === true) ||
-        (issue && options.queueSeconds !== undefined)) {
+    if (workflows.some((workflow) => workflow.queue === true)) {
         codes.add("next-command");
         codes.add("queue-interval");
     }
-    if (workflows.some((workflow) => hasTicketField(workflow.input)) ||
-        bundled.some((name) => ["develop-ticket", "develop-issue"].includes(name)))
+    if (workflows.some((workflow) => hasTicketField(workflow.input)))
         codes.add("ticket-command");
-    if (bundled.includes("develop-prd"))
-        codes.add("private-texts");
     return [...codes];
 }

package/dist/src/harness-start.d.ts

@@ -0,0 +1,15 @@
+import { type ShellMode } from "./agent-harness-shell.ts";
+import type { HarnessSelection } from "./configuration-change.ts";
+export interface HarnessStartRequest {
+    readonly executable: string;
+    readonly arguments: readonly string[];
+    readonly directory: string;
+    readonly environment: Readonly<Record<string, string | undefined>>;
+}
+export declare function harnessStartRequest(entry: HarnessSelection & {
+    readonly shellMode?: ShellMode;
+}, context: {
+    readonly repository: string;
+    readonly environment: Readonly<NodeJS.ProcessEnv>;
+    readonly message: string;
+}): HarnessStartRequest;

package/dist/src/harness-start.js

@@ -0,0 +1,37 @@
+import { shellArguments, shellRunScript, } from "./agent-harness-shell.js";
+const shellStartScript = `
+set +m
+kind=
+if [ -n "\${ZSH_VERSION-}" ]; then
+  kind=$(builtin whence -w -- "$1" 2>/dev/null) || kind=
+  kind="\${kind##*: }"
+elif [ -n "\${BASH_VERSION-}" ]; then
+  kind=$(builtin type -t -- "$1" 2>/dev/null) || kind=
+fi
+case "$kind" in
+  function|alias) ;;
+  *) printf '%s\\n' 'Open your agent in this repository and tell it: run \`cloving init-prompt\`.' >&2; exit 1 ;;
+esac
+${shellRunScript}
+`;
+export function harnessStartRequest(entry, context) {
+    const argumentsList = entry.name === "opencode"
+        ? ["--prompt", context.message]
+        : [context.message];
+    const executable = entry.kind === "shell" ? (context.environment["SHELL"] ?? "") : entry.path;
+    const args = entry.kind === "shell"
+        ? [
+            ...shellArguments(entry.shellMode ?? "login"),
+            shellStartScript,
+            "cloving-init",
+            entry.path,
+            ...argumentsList,
+        ]
+        : argumentsList;
+    return {
+        executable,
+        arguments: args,
+        directory: context.repository,
+        environment: context.environment,
+    };
+}

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

@@ -0,0 +1,38 @@
+import type { CommandWaitState } from "../authority/command-waits.ts";
+import type { CommandWaitRequest, CommandWaitProgress } from "../step-bridge.ts";
+interface WaitName {
+    readonly runId: string;
+    readonly name: string;
+}
+interface WaitCall extends WaitName {
+    readonly commandId: string;
+}
+interface WaitReceipt {
+    readonly kind: string;
+    readonly reason?: string;
+}
+export interface CommandWaitPorts {
+    readonly open: (request: WaitCall & {
+        readonly input: string;
+    }) => Promise<WaitReceipt>;
+    readonly check: (request: WaitCall) => Promise<WaitReceipt>;
+    readonly read: (request: WaitName) => Promise<CommandWaitState | undefined>;
+}
+interface WaitHost {
+    readonly commandWait?: CommandWaitPorts;
+    readonly runStatus: (runId: string) => Promise<string | undefined>;
+    readonly subject: () => Promise<{
+        readonly runId: string;
+        readonly commandId: string;
+    } | undefined>;
+    readonly stopped: AbortSignal;
+    readonly pollMilliseconds: number;
+    readonly retryMilliseconds: number;
+}
+export declare function commandWaitBridge(host: WaitHost): {
+    openCommandWait: (request: CommandWaitRequest) => Promise<CommandWaitProgress>;
+    checkCommandWait: (request: {
+        readonly name: string;
+    }) => Promise<CommandWaitProgress>;
+};
+export {};

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

@@ -0,0 +1,115 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { commandWaitValue, isCommandWaitRequest } from "../command-wait.js";
+function progress(wait) {
+    if (wait === undefined)
+        return { kind: "refused", reason: "unknown-command-wait" };
+    if (wait.state === "waiting")
+        return waiting(wait);
+    if (wait.state === "timed-out")
+        return { kind: "timed-out", reason: "command-wait-timeout" };
+    if (wait.state !== "completed")
+        return { kind: "failed", reason: wait.reason ?? "command-wait-failed" };
+    const value = JSON.parse(wait.result ?? "null");
+    return commandWaitValue(value)
+        ? { kind: "ready", value }
+        : { kind: "failed", reason: "command-wait-invalid-output" };
+}
+function refused(receipt) {
+    if (["accepted", "duplicate"].includes(receipt.kind))
+        return undefined;
+    return {
+        kind: receipt.kind === "failed" ? "failed" : "refused",
+        reason: receipt.reason ?? receipt.kind,
+    };
+}
+async function requested(context, send) {
+    const { host, call, retryReasons = ["service-busy"] } = context;
+    for (;;) {
+        if (host.stopped.aborted)
+            await new Promise(() => undefined);
+        const receipt = await send();
+        if (receipt.kind !== "rejected" ||
+            !retryReasons.includes(receipt.reason ?? ""))
+            return receipt;
+        if (receipt.reason === "command-wait-run-not-running" &&
+            !["queued", "running", "waiting_gate", "paused"].includes((await host.runStatus(call.runId)) ?? ""))
+            return receipt;
+        await delay(host.retryMilliseconds, undefined, {
+            signal: host.stopped,
+        }).catch(() => undefined);
+    }
+}
+async function settled(context, request) {
+    const { host, port } = context;
+    for (;;) {
+        if (host.stopped.aborted)
+            await new Promise(() => undefined);
+        const wait = await port.read(request);
+        if (wait?.state !== "waiting" || wait.checkOperation === null)
+            return progress(wait);
+        await delay(host.pollMilliseconds, undefined, {
+            signal: host.stopped,
+        }).catch(() => undefined);
+    }
+}
+export function commandWaitBridge(host) {
+    return {
+        openCommandWait: async (request) => {
+            if (!isCommandWaitRequest(request))
+                return { kind: "refused", reason: "invalid-command-wait-request" };
+            const subject = await host.subject();
+            const port = host.commandWait;
+            if (subject === undefined || port === undefined)
+                return { kind: "unavailable", reason: "cloving-host-unavailable" };
+            const call = {
+                ...subject,
+                name: request.name,
+                input: JSON.stringify(request.input),
+            };
+            const receipt = await requested({
+                host,
+                call,
+                retryReasons: ["service-busy", "command-wait-run-not-running"],
+            }, () => port.open(call));
+            return (refused(receipt) ??
+                progress(await port.read({ ...subject, name: request.name })));
+        },
+        checkCommandWait: async (request) => {
+            const subject = await host.subject();
+            const port = host.commandWait;
+            if (subject === undefined || port === undefined)
+                return { kind: "unavailable", reason: "cloving-host-unavailable" };
+            const call = { ...subject, name: request.name };
+            const wait = await port.read(call);
+            if (wait?.state !== "waiting")
+                return progress(wait);
+            if (wait.checkOperation !== null)
+                return await settled({ host, port }, call);
+            if (wait.nextCheckAt !== null &&
+                Date.now() < Math.min(wait.nextCheckAt, wait.deadline))
+                return progress(wait);
+            const receipt = await requested({ host, call }, () => port.check(call));
+            return checkReply(receipt, wait) ?? (await settled({ host, port }, call));
+        },
+    };
+}
+function checkReply(receipt, wait) {
+    if (receipt.reason === "command-wait-timeout")
+        return { kind: "timed-out", reason: receipt.reason };
+    if (receipt.reason === "command-wait-run-not-running")
+        return waiting(wait, Date.now() + 1000);
+    if ([
+        "command-wait-check-in-flight",
+        "command-wait-check-not-due",
+        "command-wait-ended",
+    ].includes(receipt.reason ?? ""))
+        return undefined;
+    return refused(receipt);
+}
+function waiting(wait, nextCheckAt = wait.nextCheckAt ?? wait.deadline) {
+    return {
+        kind: "pending",
+        deadline: wait.deadline,
+        nextCheckAt,
+    };
+}