cloving 1.2.0 → 1.4.0

package/dist/src/daemon/workflow-schedules.d.ts

@@ -0,0 +1,30 @@
+import type { WorkerPort } from "../service/worker-port.ts";
+import type { DeclaredWorkflow } from "../workflow-declaration.ts";
+import type { SchedulePort } from "../schedule-progress.ts";
+interface ScheduleSettings {
+    readonly directory: string;
+    readonly runtimeDirectory: string;
+    readonly declarations?: readonly DeclaredWorkflow[];
+    readonly scheduleClock?: () => number;
+    readonly scheduleObservationClock?: () => number;
+    readonly submit: WorkerPort["submit"];
+}
+export declare function scheduledDeclarations(settings: {
+    readonly declarations?: readonly DeclaredWorkflow[];
+    readonly schedules?: unknown;
+}, limits?: {
+    readonly repository: string;
+    readonly documentBytes: number;
+}): {
+    readonly kind: "configured";
+    readonly declarations: readonly DeclaredWorkflow[];
+} | {
+    readonly kind: "refused";
+    readonly reason: string;
+    readonly detail: string;
+};
+export declare function workflowSchedules(settings: ScheduleSettings): Promise<{
+    readonly stop: () => Promise<void>;
+    readonly request: SchedulePort;
+}>;
+export {};

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

@@ -0,0 +1,238 @@
+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 { 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 {
+        const declarations = settings.declarations ?? [];
+        const configured = configuredSchedules(declarations, settings.schedules === undefined ? {} : settings.schedules);
+        if (limits !== undefined &&
+            Object.entries(configured).some(([workflowId, schedule]) => Buffer.byteLength(JSON.stringify(declaredInput(limits.repository, {
+                commandId: commandId(workflowId, 1),
+                submission: schedule.input,
+            }))) > limits.documentBytes))
+            throw new Error("invalid-schedule-input");
+        return {
+            kind: "configured",
+            declarations: declarations.map((entry) => {
+                const schedule = Object.hasOwn(configured, entry.workflowId)
+                    ? configured[entry.workflowId]
+                    : undefined;
+                return schedule === undefined ? entry : { ...entry, schedule };
+            }),
+        };
+    }
+    catch (error) {
+        return {
+            kind: "refused",
+            reason: "schedule-rejected",
+            detail: String(error),
+        };
+    }
+}
+function commandId(workflowId, slot) {
+    return `schedule:${workflowId}:${String(slot)}`;
+}
+async function request(settings, request) {
+    const interrupted = Promise.withResolvers();
+    const interrupt = () => {
+        interrupted.resolve(undefined);
+    };
+    settings.signal.addEventListener("abort", interrupt, { once: true });
+    try {
+        settings.signal.throwIfAborted();
+        return await mutate(settings.runtimeDirectory, {
+            request,
+            signal: interrupted.promise,
+        });
+    }
+    finally {
+        settings.signal.removeEventListener("abort", interrupt);
+    }
+}
+async function pending(settings, entry) {
+    settings.signal.throwIfAborted();
+    const { workflowId, progress } = 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({
+            kind: "record-schedule-skip",
+            commandId: `skip:${identity}`,
+            runId: planned.runId,
+            workflowId,
+            slot: progress.lastSlot,
+        });
+        if (receipt.kind !== "accepted" && receipt.kind !== "duplicate")
+            throw new Error("schedule-skip-not-recorded");
+        return rest;
+    }
+    const reply = await request(settings, {
+        operation: "run",
+        parameters: {
+            workflowId,
+            source: "declared",
+            submission: planned.input,
+            commandId: identity,
+        },
+    });
+    if (reply.kind === "error")
+        throw new Error(reply.error.code);
+    return { ...rest, activeCommandId: identity };
+}
+async function scheduledRunStatus(settings, runId) {
+    const reply = await request(settings, {
+        operation: "status",
+        parameters: { runId },
+    });
+    if (reply.kind === "error")
+        throw new Error(reply.error.code);
+    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 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
+        : 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 ?? [])
+        await advance({ ...settings, journal, now }, declaration);
+}
+async function initialized(settings) {
+    const journal = await scheduleJournal(join(settings.directory, "state"));
+    const now = (settings.scheduleClock ?? Date.now)();
+    for (const declaration of settings.declarations ?? []) {
+        const { workflowId, schedule } = declaration;
+        if (schedule === undefined)
+            continue;
+        const prior = journal.entries.get(workflowId);
+        if (prior?.everySeconds === schedule.everySeconds)
+            continue;
+        journal.entries.set(workflowId, {
+            ...(prior ?? {
+                lastSlot: 0,
+                state: "active",
+                failuresInRow: 0,
+                failedRunIds: [],
+            }),
+            everySeconds: schedule.everySeconds,
+            nextAt: now + schedule.everySeconds * 1000,
+        });
+    }
+    if (settings.declarations?.some((entry) => entry.schedule !== undefined))
+        await journal.save();
+    return journal;
+}
+export async function workflowSchedules(settings) {
+    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 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/decision-wait.d.ts

@@ -0,0 +1 @@
+export declare function decisionToken(runId: string, gateId: string): string;

package/dist/src/decision-wait.js

@@ -0,0 +1,3 @@
+export function decisionToken(runId, gateId) {
+    return `cloving-decision/v1/${encodeURIComponent(runId)}/${encodeURIComponent(gateId)}`;
+}

package/dist/src/delivery-backoff.d.ts

@@ -0,0 +1 @@
+export declare const deliveryBackoffMilliseconds: readonly [0, 60000, 300000, 900000, 3600000];

package/dist/src/delivery-backoff.js

@@ -0,0 +1,3 @@
+export const deliveryBackoffMilliseconds = [
+    0, 60_000, 300_000, 900_000, 3_600_000,
+];

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

@@ -0,0 +1,22 @@
+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", "no-workflow", "runtime-directory", "service", "ticket-command", "next-command", "check-command", "queue-interval", "private-texts"];
+export type DoctorCode = (typeof doctorCodes)[number];
+export interface DoctorObservation {
+    readonly result: "ok" | "fail" | "skip";
+    readonly detail: string;
+}
+export interface DoctorCheck extends DoctorObservation {
+    readonly code: DoctorCode;
+    readonly required: boolean;
+    readonly fix: string;
+}
+export declare const doctorFixes: Readonly<Record<DoctorCode, string>>;
+export declare function doctorExitCode(checks: readonly DoctorCheck[]): number;
+export interface DoctorWorkflow {
+    readonly queue?: boolean;
+    readonly scope: "project" | "user";
+    readonly workflowId: string;
+    readonly capabilities: readonly string[];
+    readonly input?: SubmissionContract;
+}
+export declare function requiredDoctorCodes(workflows: readonly DoctorWorkflow[]): readonly DoctorCode[];

package/dist/src/doctor-report.js

@@ -0,0 +1,63 @@
+import { hasTicketField } from "./submission.js";
+export const doctorCodes = [
+    "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",
+];
+export const doctorFixes = {
+    "git-repository": "Change to the repository, or run: git init",
+    "node-version": "Install a supported Node version: nvm install 26 && nvm use 26",
+    harnesses: "Install a harness: npm install -g @anthropic-ai/claude-code",
+    "default-harness": "Install a harness: npm install -g @anthropic-ai/claude-code; select it: CLOVING_WORKER=claude cloving doctor; clear command overrides: unset CLOVING_CLAUDE_COMMAND CLOVING_CODEX_COMMAND; edit private harness.command if configured; for another harness: cloving config set harness.turn '[...]'",
+    "gh-login": "Log in with the configured GitHub command: gh auth login",
+    "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",
+    "next-command": "Set tickets.nextCommand to an executable list: ${EDITOR:-vi} .cloving/config.json",
+    "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`,
+};
+export function doctorExitCode(checks) {
+    return checks.some((check) => check.required && check.result !== "ok")
+        ? 1
+        : 0;
+}
+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");
+    }
+    if (workflows.some((workflow) => workflow.queue === true)) {
+        codes.add("next-command");
+        codes.add("queue-interval");
+    }
+    if (workflows.some((workflow) => hasTicketField(workflow.input)))
+        codes.add("ticket-command");
+    return [...codes];
+}

package/dist/src/execution-pin.d.ts

@@ -1,8 +1,13 @@
 import type { AdmissionResult, ExecutionManifest } from "./workflow-admission.ts";
+import { type CommandWaits } from "./workflow-declaration.ts";
 export declare function executionCapabilities(manifest: ExecutionManifest): string;
 export declare function pinnedIdentity(manifest: ExecutionManifest): string;
 export declare function resumePinned(pinned: ExecutionManifest, available: ExecutionManifest): AdmissionResult;
 export declare function readExecutionManifest(value: unknown): ExecutionManifest;
 export declare function declaredManifest(manifest: ExecutionManifest, declaration: {
     readonly handoffs?: readonly string[];
+    readonly commands?: readonly string[];
+    readonly commandWaits?: CommandWaits;
+    readonly bundleDigest?: string | undefined;
+    readonly queue?: boolean;
 }): ExecutionManifest;

package/dist/src/execution-pin.js

@@ -1,10 +1,21 @@
-import { isWorkflowHandoffs } from "./workflow-declaration.js";
+import { isCommandWaits, isWorkflowNames, } from "./workflow-declaration.js";
 const canonical = {
+    queue: (manifest) => JSON.stringify(manifest.queue === true),
     name: (manifest) => JSON.stringify(manifest.name),
     workflowId: (manifest) => JSON.stringify(manifest.workflowId),
     steps: (manifest) => JSON.stringify([...manifest.steps].sort()),
     capabilities: (manifest) => JSON.stringify([...manifest.capabilities].sort()),
     handoffs: (manifest) => JSON.stringify([...(manifest.handoffs ?? [])].sort()),
+    commands: (manifest) => JSON.stringify([...(manifest.commands ?? [])].sort()),
+    commandWaits: (manifest) => JSON.stringify(Object.entries(manifest.commandWaits ?? {})
+        .sort(([first], [second]) => first < second ? -1 : Number(first > second))
+        .map(([name, wait]) => [
+        name,
+        wait.command,
+        wait.maximumWaitSeconds,
+        wait.pollEverySeconds,
+    ])),
+    bundleDigest: (manifest) => JSON.stringify(manifest.bundleDigest),
     artifacts: (manifest) => JSON.stringify(Object.keys(manifest.artifacts)
         .sort()
         .map((name) => [name, manifest.artifacts[name]])),
@@ -30,10 +41,25 @@ export function pinnedIdentity(manifest) {
     const identity = fields.map((field) => canonical[field](manifest));
     if (manifest.handoffs?.length)
         identity.push(canonical.handoffs(manifest));
+    if (manifest.commands?.length)
+        identity.push(JSON.stringify(["commands", canonical.commands(manifest)]));
+    if (Object.keys(manifest.commandWaits ?? {}).length > 0)
+        identity.push(JSON.stringify(["commandWaits", canonical.commandWaits(manifest)]));
+    if (manifest.bundleDigest !== undefined)
+        identity.push(canonical.bundleDigest(manifest));
+    if (manifest.queue === true)
+        identity.push(JSON.stringify(["queue", true]));
     return JSON.stringify(identity);
 }
 export function resumePinned(pinned, available) {
-    const changed = [...fields, "handoffs"].find((field) => canonical[field](pinned) !== canonical[field](available));
+    const changed = [
+        ...fields,
+        "handoffs",
+        "commands",
+        "commandWaits",
+        "bundleDigest",
+        "queue",
+    ].find((field) => canonical[field](pinned) !== canonical[field](available));
     if (changed !== undefined)
         return {
             kind: "rejected",
@@ -46,14 +72,23 @@ export function readExecutionManifest(value) {
     const fields = record(value);
     const toolchain = record(fields["toolchain"]);
     const handoffs = fields["handoffs"];
-    if (Object.hasOwn(fields, "handoffs") && !isWorkflowHandoffs(handoffs))
+    const commands = fields["commands"];
+    if (Object.hasOwn(fields, "handoffs") && !isWorkflowNames(handoffs))
         throw new Error("invalid-handoffs");
+    if (Object.hasOwn(fields, "commands") && !isWorkflowNames(commands))
+        throw new Error("invalid-commands");
     return {
         name: text(fields["name"]),
         workflowId: text(fields["workflowId"]),
         steps: texts(fields["steps"]),
         capabilities: texts(fields["capabilities"]),
-        ...(isWorkflowHandoffs(handoffs) ? { handoffs: [...handoffs] } : {}),
+        ...queueMetadata(fields),
+        ...(isWorkflowNames(handoffs) ? { handoffs: [...handoffs] } : {}),
+        ...(isWorkflowNames(commands) ? { commands: [...commands] } : {}),
+        ...readCommandWaits(fields),
+        ...(Object.hasOwn(fields, "bundleDigest")
+            ? { bundleDigest: text(fields["bundleDigest"]) }
+            : {}),
         artifacts: textRecord(fields["artifacts"]),
         resources: textRecord(fields["resources"]),
         toolchain: {
@@ -65,12 +100,35 @@ export function readExecutionManifest(value) {
         },
     };
 }
+function readCommandWaits(fields) {
+    if (!Object.hasOwn(fields, "commandWaits"))
+        return {};
+    const commandWaits = fields["commandWaits"];
+    if (!isCommandWaits(commandWaits, {
+        capabilities: texts(fields["capabilities"]),
+        commands: texts(fields["commands"]),
+    }))
+        throw new Error("invalid-command-waits");
+    return {
+        commandWaits: Object.fromEntries(Object.entries(commandWaits).map(([name, wait]) => [name, { ...wait }])),
+    };
+}
 export function declaredManifest(manifest, declaration) {
     return readExecutionManifest({
         ...manifest,
+        ...(declaration.queue === undefined ? {} : { queue: declaration.queue }),
+        ...(declaration.commands === undefined
+            ? {}
+            : { commands: declaration.commands }),
+        ...(declaration.commandWaits === undefined
+            ? {}
+            : { commandWaits: declaration.commandWaits }),
         ...(declaration.handoffs === undefined
             ? {}
             : { handoffs: declaration.handoffs }),
+        ...(declaration.bundleDigest === undefined
+            ? {}
+            : { bundleDigest: declaration.bundleDigest }),
     });
 }
 function record(value) {
@@ -87,3 +145,8 @@ function texts(value) {
 function textRecord(value) {
     return Object.fromEntries(Object.entries(record(value)).map(([key, item]) => [key, text(item)]));
 }
+function queueMetadata(fields) {
+    if (Object.hasOwn(fields, "queue") && typeof fields["queue"] !== "boolean")
+        throw new Error("invalid-queue");
+    return fields["queue"] === true ? { queue: true } : {};
+}