cloving 1.2.0 → 1.4.0

package/dist/src/daemon/claude-worker.js

@@ -1,121 +1,114 @@
-import { join } from "node:path";
-import { ticketStatus } from "../ticket-status.js";
-import { sumPrices } from "../worker-usage.js";
-import { analysisWorker } from "./analysis-worker.js";
-import { analysisMethod } from "./analysis-launch.js";
+import { turnHarness } from "../harness-defaults.js";
+import { attachmentEnvironment } from "./attachments.js";
 import { profileCommand, } from "../turn-profile.js";
 import {} from "./claude-turn.js";
+import { turnOutcome } from "./turn-report.js";
 import { startRetriedTurn } from "./retrying-turn.js";
-import { interrupted, located, operationKey, readRecord as read, replied, reportOf, writeRecord as written, } from "./operation-journal.js";
-import { changes, treeFailure, workTree } from "./work-tree.js";
+import { located, readRecord as read, replied, reportOf, writeRecord as written, } from "./operation-journal.js";
+import { firstTurn, treeFailure, workTree, } from "./work-tree.js";
+import { recordedHarness, interruptedReply, processAlive, uncertainProcess, resumePlan, recordedField, resumableHarness, recoverTurn, turnIntent, } from "./claude-recovery.js";
+import { selectedProfile } from "./worker-profile.js";
 export const claudeLimits = {
     summaryCharacters: 16_000,
     resultBytes: 48_000,
-    stopMilliseconds: 2_000,
+    stopMilliseconds: 15_000,
 };
 const worker = "claude";
-function alive(processId) {
-    if (typeof processId !== "number")
-        return false;
-    try {
-        process.kill(processId, 0);
-        return true;
-    }
-    catch (error) {
-        return Reflect.get(Object(error), "code") === "EPERM";
-    }
+function reconciled(parts, call) {
+    const { intent } = call;
+    const { key } = located(parts.settings.journal, intent.operationId);
+    const pending = parts.reconciling.get(key);
+    if (pending !== undefined)
+        return pending;
+    const reconciliation = reconcileOperation(parts, call).finally(() => {
+        if (parts.reconciling.get(key) === reconciliation)
+            parts.reconciling.delete(key);
+    });
+    parts.reconciling.set(key, reconciliation);
+    return reconciliation;
 }
-async function reconciled(parts, intent) {
+async function reconcileOperation(parts, call) {
+    const { intent, signal } = call;
     const { key, folder } = located(parts.settings.journal, intent.operationId);
     const result = await read(folder, "result.json");
-    if (result !== undefined)
+    if (result !== undefined &&
+        (recordedField(result, "stoppedBy") !== "daemon-shutdown" ||
+            parts.stopping.signal.aborted))
         return replied({ receipt: key, worker }, result);
     if (parts.active.has(key))
         return { kind: "accepted", receipt: key, worker };
     const started = await read(folder, "started.json");
     if (started === undefined)
         return { kind: "absent" };
-    if (alive(Reflect.get(Object(started), "processId")))
+    if (await uncertainProcess(started))
         return { kind: "unknown", evidence: `claude-turn:${key}` };
-    const ending = interrupted("claude-turn-interrupted");
-    await written(folder, { name: "result.json", value: ending });
-    return replied({ receipt: key, worker }, ending);
+    return resumed(parts, { intent, key, folder, started, signal });
 }
-async function resultText(tree, result) {
-    const fields = {
-        ticketStatus: ticketStatus(result.text),
-        summary: result.text.slice(0, claudeLimits.summaryCharacters),
-        ...(await changes(tree)),
-        worktree: tree.path,
-        costUsd: result.costUsd,
-        usage: result.usage,
-        model: result.model,
-        ...(result.attempts === undefined ? {} : { attempts: result.attempts }),
-        estimatedCostUsd: sumPrices((result.attempts ?? []).map((attempt) => attempt.estimatedCostUsd)),
-        sessionId: result.sessionId,
-        turns: result.turns,
-    };
-    const text = JSON.stringify(fields);
-    const excess = Buffer.byteLength(text) - claudeLimits.resultBytes;
-    if (excess <= 0)
-        return { text };
-    const kept = Math.max(0, fields.summary.length - excess);
-    const shortened = JSON.stringify({
-        ...fields,
-        summary: fields.summary.slice(0, kept),
+async function resumed(parts, request) {
+    const { intent, started, key, folder, signal } = request;
+    const aborted = () => signal.aborted;
+    if (!turnIntent(intent))
+        return interruptedReply(request, "claude-turn-interrupted");
+    if (aborted())
+        return failure("claude-start-aborted");
+    const plan = await resumePlan(parts.settings, {
+        folder,
+        started,
+        intent,
+        signal,
     });
-    if (Buffer.byteLength(shortened) <= claudeLimits.resultBytes)
-        return { text: shortened };
-    const metadata = JSON.stringify({
-        ...fields,
-        ticketStatus: undefined,
-        summary: "",
+    if (aborted())
+        return failure("claude-start-aborted");
+    if (typeof plan === "string")
+        return interruptedReply(request, plan);
+    const prompt = await parts.settings.document(intent.payload);
+    if (aborted())
+        return failure("claude-start-aborted");
+    if (prompt === undefined)
+        return interruptedReply(request, "claude-turn-interrupted");
+    await begun(parts, {
+        key,
+        folder,
+        intent,
+        ...plan,
+        signal,
+        prompt,
     });
-    return {
-        reason: "claude-result-too-large",
-        ...(Buffer.byteLength(metadata) <= claudeLimits.resultBytes
-            ? { text: metadata }
-            : {}),
-    };
-}
-async function outcome(running, end) {
-    const endedAt = new Date().toISOString();
-    const { result } = end;
-    const report = result === undefined ? {} : await resultText(running.tree, result);
-    const { text, reason } = report;
-    if (reason === undefined &&
-        text !== undefined &&
-        end.exitCode === 0 &&
-        result?.failed === false)
-        return { outcome: "completed", result: text, endedAt };
-    if (running.stopping.requested)
-        return { outcome: "stopped", endedAt };
-    return {
-        outcome: "failed",
-        reason: reason ?? "claude-turn-failed",
-        ...(text === undefined ? {} : { result: text }),
-        endedAt,
-    };
+    return { kind: "accepted", receipt: key, worker };
 }
 async function concluded(parts, running) {
     const { intent, key } = running;
-    const recorded = await outcome(running, await running.turn.ended);
+    const recorded = await turnOutcome({ ...running, limits: claudeLimits }, await running.turn.ended);
     await written(running.folder, { name: "result.json", value: recorded });
+    if (recorded.stoppedBy === "daemon-shutdown")
+        return;
     await parts.settings.report(reportOf({ intent, commandId: `claude-turn:${key}`, worker }, recorded));
 }
 async function begun(parts, start) {
     const { intent, key, folder, tree, prompt } = start;
+    const { harness } = start;
+    const stopping = { requested: false, controller: new AbortController() };
+    const cancel = () => {
+        stopping.controller.abort();
+    };
+    start.signal.addEventListener("abort", cancel, { once: true });
+    if (start.signal.aborted)
+        cancel();
     const turn = startRetriedTurn({
-        worker: parts.settings.worker ?? "claude",
-        command: profileCommand(parts.settings.command, start.profile),
-        environment: start.profile.env ?? {},
+        ...harness,
+        resultBytes: claudeLimits.resultBytes,
+        command: profileCommand(harness.command, start.profile),
+        environment: await attachmentEnvironment(parts.settings, start),
         turnId: `${intent.runId}-${key}`,
         directory: tree.path,
         folder,
         prompt,
     }, {
         ...parts.settings,
+        ...(start.resume === undefined ? {} : { resume: start.resume }),
+        stopping: stopping.controller,
         metadata: {
+            harness: harness.worker,
             operationId: intent.operationId,
             target: intent.target,
             branch: tree.branch,
@@ -123,8 +116,8 @@ async function begun(parts, start) {
             startCommit: tree.startCommit,
         },
     });
-    const stopping = { requested: false };
     parts.active.set(key, {
+        worker: harness.worker,
         turn,
         stopping,
         concluded: turn
@@ -132,60 +125,13 @@ async function begun(parts, start) {
             .catch(() => undefined)
             .finally(() => parts.active.delete(key)),
     });
-    await turn;
-}
-async function firstTurn(settings, opening) {
-    const { tree, intent } = opening;
-    const { target, runId } = intent;
-    const folder = target.startsWith("branch:")
-        ? join(settings.journal, "runs", operationKey(runId), "targets")
-        : join(settings.journal, "targets");
-    const name = `${operationKey(target)}.json`;
-    const startCommit = Reflect.get(Object(await read(folder, name)), "startCommit");
-    if (typeof startCommit === "string")
-        return { ...tree, startCommit };
-    await written(folder, {
-        name,
-        value: { target, startCommit: tree.startCommit },
+    await turn.finally(() => {
+        start.signal.removeEventListener("abort", cancel);
     });
-    return tree;
-}
-function turnIntent(intent) {
-    return (intent.capability === worker &&
-        (intent.method === "run-turn" ||
-            /^run-turn:[A-Za-z0-9_-]{1,119}$/.test(intent.method ?? "")) &&
-        intent.target !== undefined &&
-        intent.payload !== undefined &&
-        intent.leaseGeneration !== undefined);
 }
 function failure(reason) {
     return { kind: "failed", reason };
 }
-async function runWorkflow(settings, runId) {
-    try {
-        return await settings.workflowId?.(runId);
-    }
-    catch {
-        return undefined;
-    }
-}
-async function selectedProfile(settings, intent) {
-    if (intent.method === "run-turn")
-        return {};
-    if (settings.worker === "codex")
-        return "profile-needs-claude";
-    const name = intent.method.slice("run-turn:".length);
-    const profiles = settings.profiles ?? {};
-    const profile = Object.hasOwn(profiles, name) ? profiles[name] : undefined;
-    if (profile === undefined)
-        return "unknown-profile";
-    if (profile.workflows === undefined)
-        return profile;
-    const workflowId = await runWorkflow(settings, intent.runId);
-    if (workflowId === undefined || !profile.workflows.includes(workflowId))
-        return "profile-not-allowed";
-    return profile;
-}
 async function delivered(parts, call) {
     const { intent, signal } = call;
     const { settings } = parts;
@@ -194,7 +140,7 @@ async function delivered(parts, call) {
         return failure("unsupported-effect");
     if (aborted())
         return failure("claude-start-aborted");
-    const known = await reconciled(parts, intent);
+    const known = await reconciled(parts, call);
     if (known.kind !== "absent")
         return known;
     const profile = await selectedProfile(settings, intent);
@@ -217,55 +163,100 @@ async function delivered(parts, call) {
     const first = await firstTurn(settings, { tree, intent });
     if (aborted())
         return failure("claude-start-aborted");
-    await begun(parts, { ...place, intent, tree: first, prompt, profile });
+    await begun(parts, {
+        ...place,
+        intent,
+        tree: first,
+        prompt,
+        profile,
+        harness: turnHarness(settings, profile),
+        signal,
+    });
     return { receipt: place.key, worker };
 }
 async function halted(parts, active) {
     active.stopping.requested = true;
+    active.stopping.controller.abort();
     const turn = await active.turn.catch(() => undefined);
     turn?.stop(parts.settings.stopMilliseconds ?? claudeLimits.stopMilliseconds);
     await active.concluded;
 }
 async function stopped(parts, intent) {
-    const { key } = located(parts.settings.journal, intent.operationId);
+    const { key, folder } = located(parts.settings.journal, intent.operationId);
     const active = parts.active.get(key);
-    if (active !== undefined)
+    if (active !== undefined) {
+        delete active.stopping.stoppedBy;
         await halted(parts, active);
-    return reconciled(parts, intent);
+    }
+    const result = await read(folder, "result.json");
+    if (result !== undefined &&
+        recordedField(result, "stoppedBy") !== "daemon-shutdown")
+        return replied({ receipt: key, worker }, result);
+    const started = await read(folder, "started.json");
+    if (started === undefined)
+        return { kind: "absent" };
+    if (!resumableHarness(recordedField(started, "harness")))
+        return reconcileOperation(parts, { intent, signal: parts.stopping.signal });
+    if (processAlive(recordedField(started, "processId")))
+        return { kind: "unknown", evidence: `claude-turn:${key}` };
+    if (!turnIntent(intent))
+        return failure("unsupported-effect");
+    const recorded = {
+        outcome: "stopped",
+        endedAt: new Date().toISOString(),
+    };
+    await written(folder, { name: "result.json", value: recorded });
+    await parts.settings.report(reportOf({ intent, commandId: `claude-turn:${key}`, worker }, recorded));
+    return replied({ receipt: key, worker }, recorded);
+}
+function stoppingOperation(parts, intent) {
+    const { key } = located(parts.settings.journal, intent.operationId);
+    const pending = parts.reconciling.get(key);
+    const stop = () => stopped(parts, intent);
+    const stopping = pending === undefined ? stop() : pending.then(stop, stop);
+    const settled = stopping.finally(() => {
+        if (parts.reconciling.get(key) === settled)
+            parts.reconciling.delete(key);
+    });
+    parts.reconciling.set(key, settled);
+    return settled;
 }
 export function claudeWorker(settings) {
     if (settings.command.length === 0)
         throw new Error("invalid-claude-command");
+    turnHarness(settings);
+    for (const profile of Object.values(settings.profiles ?? {}))
+        turnHarness(settings, profile);
     const parts = {
         settings,
         active: new Map(),
+        reconciling: new Map(),
         stopping: new AbortController(),
     };
-    const analysis = analysisWorker(settings);
-    const guarded = async (intent, run) => {
-        if (!turnIntent(intent) ||
-            Object.hasOwn(settings.profiles ?? {}, "analyze-chats") ||
-            (await runWorkflow(settings, intent.runId)) !== "analyze-chats")
-            return failure("analysis-worker-unavailable");
-        return run();
-    };
+    const guarded = (intent, run) => intent.method === "run-turn:analyze-chats"
+        ? Promise.resolve(failure("unsupported-effect"))
+        : run();
     return {
-        deliver: (intent, signal) => intent.method === analysisMethod
-            ? guarded(intent, () => analysis.deliver(intent, signal))
-            : delivered(parts, {
-                intent,
-                signal: AbortSignal.any([signal, parts.stopping.signal]),
-            }),
-        reconcile: (intent, signal) => intent.method === analysisMethod
-            ? guarded(intent, () => analysis.reconcile(intent, signal))
-            : reconciled(parts, intent),
-        stop: (intent, signal) => intent.method === analysisMethod
-            ? guarded(intent, () => analysis.stop(intent, signal))
-            : stopped(parts, intent),
+        recover: (intent) => turnIntent(intent)
+            ? recoverTurn({ ...settings, intent, signal: parts.stopping.signal }, () => reconciled(parts, { intent, signal: parts.stopping.signal }))
+            : Promise.resolve(),
+        harness: (operationId) => recordedHarness(settings.journal, operationId),
+        deliver: (intent, signal) => guarded(intent, () => delivered(parts, {
+            intent,
+            signal: AbortSignal.any([signal, parts.stopping.signal]),
+        })),
+        reconcile: (intent, signal) => guarded(intent, () => reconciled(parts, {
+            intent,
+            signal: AbortSignal.any([signal, parts.stopping.signal]),
+        })),
+        stop: (intent) => guarded(intent, () => stoppingOperation(parts, intent)),
         close: async () => {
             parts.stopping.abort();
-            await analysis.close();
-            await Promise.all([...parts.active.values()].map((active) => halted(parts, active)));
+            await Promise.all([...parts.active.values()].map((active) => {
+                if (resumableHarness(active.worker) && !active.stopping.requested)
+                    active.stopping.stoppedBy = "daemon-shutdown";
+                return halted(parts, active);
+            }));
         },
     };
 }

package/dist/src/daemon/command-journal.d.ts

@@ -0,0 +1,5 @@
+import type { CommandEffects } from "../command-settings.ts";
+export declare function claimCommand(folder: string): Promise<boolean>;
+export declare function commandStarted(folder: string): Promise<boolean>;
+export declare function recordCommandResult(folder: string, value: unknown): Promise<boolean>;
+export declare function commandEffects(journal: string): CommandEffects;

package/dist/src/daemon/command-journal.js

@@ -0,0 +1,50 @@
+import { randomUUID } from "node:crypto";
+import { link, mkdir, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { located, readRecord } from "./operation-journal.js";
+import { record } from "../protocol.js";
+function alreadyExists(error) {
+    if (Reflect.get(Object(error), "code") === "EEXIST")
+        return false;
+    throw error;
+}
+export async function claimCommand(folder) {
+    await mkdir(dirname(folder), { recursive: true, mode: 0o700 });
+    return mkdir(folder, { mode: 0o700 }).then(() => true, alreadyExists);
+}
+export async function commandStarted(folder) {
+    return stat(folder).then(() => true, (error) => {
+        if (Reflect.get(Object(error), "code") === "ENOENT")
+            return false;
+        throw error;
+    });
+}
+export async function recordCommandResult(folder, value) {
+    const staged = join(folder, `${randomUUID()}.staged`);
+    await writeFile(staged, JSON.stringify(value), { mode: 0o600, flag: "wx" });
+    try {
+        return await link(staged, join(folder, "result.json")).then(() => true, alreadyExists);
+    }
+    finally {
+        await rm(staged);
+    }
+}
+export function commandEffects(journal) {
+    const completed = new Map();
+    return (effects) => Promise.all(effects.map(async (effect) => {
+        const { key, folder } = located(journal, effect.operationId);
+        const cached = completed.get(key);
+        if (cached !== undefined)
+            return { ...effect, ...cached };
+        const result = record(await readRecord(folder, "result.json"));
+        const exitCode = result?.["exitCode"];
+        const duration = result?.["durationMilliseconds"];
+        const metadata = {
+            exitCode: typeof exitCode === "number" ? exitCode : null,
+            durationMilliseconds: typeof duration === "number" ? duration : null,
+        };
+        if (result !== undefined)
+            completed.set(key, metadata);
+        return { ...effect, ...metadata };
+    }));
+}

package/dist/src/daemon/command-process.d.ts

@@ -0,0 +1,28 @@
+export interface CommandStart {
+    readonly command: readonly string[];
+    readonly directory: string;
+    readonly folder: string;
+    readonly payload: string;
+    readonly runId: string;
+    readonly operationId: string;
+    readonly seconds: number;
+    readonly deadline?: string;
+}
+export interface CommandEnd {
+    readonly stdout: string;
+    readonly exitCode: number | null;
+    readonly durationMilliseconds: number;
+    readonly reason?: string;
+}
+export interface RunningCommand {
+    readonly ended: Promise<CommandEnd>;
+    readonly stop: () => void;
+}
+export interface CommandClock {
+    readonly now: () => number;
+    readonly timer: (wait: {
+        readonly milliseconds: number;
+        readonly expired: () => void;
+    }) => () => void;
+}
+export declare function startCommand(start: CommandStart, clock?: CommandClock): RunningCommand;

package/dist/src/daemon/command-process.js

@@ -0,0 +1,164 @@
+import { spawn } from "node:child_process";
+import { closeSync, mkdtempSync, openSync, rmSync, writeSync } from "node:fs";
+import { join } from "node:path";
+import { turnEnvironment } from "./claude-turn.js";
+import { commandLimits } from "../command-settings.js";
+import { isInstant } from "../authority/instants.js";
+const commandClock = {
+    now: () => Date.now(),
+    timer: (wait) => {
+        const timer = setTimeout(wait.expired, wait.milliseconds);
+        return () => {
+            clearTimeout(timer);
+        };
+    },
+};
+function boundedOutput(stream, options) {
+    let received = 0;
+    stream.on("data", (chunk) => {
+        const kept = chunk.subarray(0, Math.max(0, options.bytes - received));
+        received += chunk.length;
+        if (kept.length > 0)
+            options.receive(kept);
+        if (received > options.bytes)
+            options.fail("command-output-limit");
+    });
+}
+function stopChild(child) {
+    try {
+        if (child.pid !== undefined)
+            process.kill(-child.pid, "SIGKILL");
+    }
+    catch (error) {
+        const code = Reflect.get(Object(error), "code");
+        if (code !== "ESRCH" && code !== "EPERM")
+            throw error;
+        child.kill("SIGKILL");
+    }
+    child.stdin.destroy();
+    child.stdout.destroy();
+    child.stderr.destroy();
+}
+function spawnCommand(start, configuration) {
+    const [executable = "", ...argumentsList] = start.command;
+    return spawn(executable, argumentsList, {
+        cwd: start.directory,
+        env: {
+            ...turnEnvironment(configuration, { ...start, prompt: start.payload }),
+            CLOVING_RUN_ID: start.runId,
+            CLOVING_OPERATION_ID: start.operationId,
+        },
+        stdio: ["pipe", "pipe", "pipe"],
+        detached: true,
+    });
+}
+function writeStderr(descriptor, chunk) {
+    try {
+        writeSync(descriptor, chunk);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function releaseCommand(resources) {
+    try {
+        if (resources.stderr !== undefined)
+            closeSync(resources.stderr);
+    }
+    finally {
+        rmSync(resources.configuration, { recursive: true, force: true });
+    }
+}
+function prepareCommand(start, clock) {
+    const configuration = mkdtempSync(join(start.folder, "gh-config-"));
+    let stderr;
+    let child;
+    try {
+        stderr = openSync(join(start.folder, "command.stderr.log"), "w", 0o600);
+        const reason = deadlineRefusal(start, clock);
+        if (reason !== undefined)
+            return { reason };
+        child = spawnCommand(start, configuration);
+        return { child, stderr, configuration };
+    }
+    finally {
+        if (child === undefined)
+            releaseCommand({ stderr, configuration });
+    }
+}
+function refusedCommand(reason) {
+    return {
+        ended: Promise.resolve({
+            stdout: "",
+            exitCode: null,
+            durationMilliseconds: 0,
+            reason,
+        }),
+        stop: () => undefined,
+    };
+}
+function deadlineRefusal(start, clock) {
+    if (start.deadline !== undefined && !isInstant(start.deadline))
+        return "invalid-command-deadline";
+    if (start.deadline !== undefined && Date.parse(start.deadline) <= clock.now())
+        return "command-wait-timeout";
+    return undefined;
+}
+export function startCommand(start, clock = commandClock) {
+    let reason = deadlineRefusal(start, clock);
+    if (reason !== undefined)
+        return refusedCommand(reason);
+    const began = performance.now();
+    const prepared = prepareCommand(start, clock);
+    if ("reason" in prepared)
+        return refusedCommand(prepared.reason);
+    const { child, stderr, configuration } = prepared;
+    const stdout = [];
+    const closed = Promise.withResolvers();
+    const fail = (failure = "command-exit") => {
+        reason ??= failure;
+        stopChild(child);
+        closed.resolve(child.exitCode);
+    };
+    boundedOutput(child.stdout, {
+        bytes: commandLimits.stdoutBytes,
+        receive: (chunk) => stdout.push(chunk),
+        fail,
+    });
+    boundedOutput(child.stderr, {
+        bytes: commandLimits.stderrBytes,
+        receive: (chunk) => {
+            if (!writeStderr(stderr, chunk))
+                fail("command-exit");
+        },
+        fail,
+    });
+    const remaining = start.deadline === undefined
+        ? Infinity
+        : Date.parse(start.deadline) - clock.now();
+    const execution = start.seconds * 1000;
+    const cancelTimer = clock.timer({
+        expired: () => {
+            fail(remaining <= execution ? "command-wait-timeout" : "command-timeout");
+        },
+        milliseconds: Math.min(execution, remaining),
+    });
+    child.stdin.on("error", () => undefined).end(start.payload);
+    child.once("error", () => undefined).once("close", closed.resolve);
+    return {
+        ended: closed.promise.then((exitCode) => {
+            cancelTimer();
+            releaseCommand({ stderr, configuration });
+            reason ??= deadlineRefusal(start, clock);
+            reason ??= exitCode === 0 ? undefined : "command-exit";
+            return {
+                stdout: Buffer.concat(stdout).toString("utf8"),
+                exitCode,
+                durationMilliseconds: Math.round(performance.now() - began),
+                ...(reason === undefined ? {} : { reason }),
+            };
+        }),
+        stop: fail,
+    };
+}

package/dist/src/daemon/command-worker.d.ts

@@ -0,0 +1,19 @@
+import type { LocalCommands } from "../command-settings.ts";
+import type { Delivery, DeliveryIntent } from "../broker/actor/delivery-intents.ts";
+import { type WorkerReport } from "./operation-journal.ts";
+import { type CommandClock } from "./command-process.ts";
+export interface CommandWorkerSettings {
+    readonly repository: string;
+    readonly journal: string;
+    readonly commands: LocalCommands;
+    readonly seconds?: number;
+    readonly commandClock?: CommandClock;
+    readonly document: (digest: string) => Promise<string | undefined>;
+    readonly report: (report: WorkerReport) => Promise<unknown>;
+}
+export interface CommandWorker extends Delivery {
+    readonly recover: (intents: readonly DeliveryIntent[]) => Promise<void>;
+    readonly stop: NonNullable<Delivery["stop"]>;
+    readonly close: () => Promise<void>;
+}
+export declare function commandWorker(settings: CommandWorkerSettings): CommandWorker;