cloving 1.2.0 → 1.4.0

package/dist/src/agent-harness-shell.d.ts

@@ -0,0 +1,13 @@
+export declare const shellRunScript = "\nif [ -n \"${ZSH_VERSION-}\" ] && (( ${+aliases[$1]} )); then\n  alias_command=\"${aliases[$1]}\"\n  builtin unalias -- \"$1\"\n  shift\n  eval -- \"$alias_command\"' \"$@\"'\nelif [ -n \"${BASH_VERSION-}\" ] && alias_value=$(builtin alias -- \"$1\" 2>/dev/null); then\n  eval -- \"alias_command=${alias_value#*=}\"\n  builtin unalias -- \"$1\"\n  shift\n  eval -- \"$alias_command\"' \"$@\"'\nelse\n  \"$@\"\nfi\n";
+export declare const shellTurnScript = "\nset +m\nbuiltin unset GH_TOKEN GITHUB_TOKEN GH_ENTERPRISE_TOKEN GITHUB_ENTERPRISE_TOKEN || exit\nbuiltin export GH_CONFIG_DIR=\"$1\" || exit\nshift\n\nif [ -n \"${ZSH_VERSION-}\" ] && (( ${+aliases[$1]} )); then\n  alias_command=\"${aliases[$1]}\"\n  builtin unalias -- \"$1\"\n  shift\n  eval -- \"$alias_command\"' \"$@\"'\nelif [ -n \"${BASH_VERSION-}\" ] && alias_value=$(builtin alias -- \"$1\" 2>/dev/null); then\n  eval -- \"alias_command=${alias_value#*=}\"\n  builtin unalias -- \"$1\"\n  shift\n  eval -- \"$alias_command\"' \"$@\"'\nelse\n  \"$@\"\nfi\n\n";
+export declare const shellDiscoveryScript = "\nset +m\nif [ -z \"${ZSH_VERSION-}\" ] && [ -z \"${BASH_VERSION-}\" ]; then exit 64; fi\nprintf '__CLOVING_HARNESS_START_-1__\\n%s\\n\\n__CLOVING_HARNESS_END_-1__\\n' \"${BASH_VERSION:+bash}\"\nindex=0\nfor name in \"$@\"; do\n  printf '__CLOVING_HARNESS_START_%s__\\n' \"$index\"\n  if [ -n \"${ZSH_VERSION-}\" ]; then\n    kind=$(whence -w -- \"$name\" 2>/dev/null) || kind=\n    printf '%s\\n' \"${kind##*: }\"\n    file=$(whence -p -- \"$name\" 2>/dev/null) || file=\n  else\n    kind=$(builtin type -t -- \"$name\" 2>/dev/null) || kind=\n    printf '%s\\n' \"$kind\"\n    file=$(builtin type -P -- \"$name\" 2>/dev/null) || file=\n  fi\n  case \"$file\" in /*|\"\") ;; *) file=\"$PWD/$file\" ;; esac\n  printf '%s\\n' \"$file\"\n  printf '\\n__CLOVING_HARNESS_END_%s__\\n' \"$index\"\n  index=$((index + 1))\ndone\nexit 0\n";
+export declare const shellProbeScript = "\nset +m\nprintf '__CLOVING_HARNESS_START_0__\\n'\nif [ \"$2\" = file ]; then\n  command -- \"$1\" --version\nelif [ -n \"${ZSH_VERSION-}\" ] && (( ${+aliases[$1]} )); then\n  alias_command=\"${aliases[$1]}\"\n  builtin unalias -- \"$1\"\n  eval -- \"$alias_command\"' --version'\nelif [ -n \"${BASH_VERSION-}\" ] && alias_value=$(builtin alias -- \"$1\" 2>/dev/null); then\n  eval -- \"alias_command=${alias_value#*=}\"\n  builtin unalias -- \"$1\"\n  eval -- \"$alias_command\"' --version'\nelif [ -n \"${ZSH_VERSION-}\" ] || [ -n \"${BASH_VERSION-}\" ]; then\n  \"$1\" --version\nelse\n  exit 64\nfi\nprobe_status=$?\nprintf '\\n__CLOVING_HARNESS_END_0__\\n'\nexit \"$probe_status\"\n";
+export declare function shellBlock(output: string, index: number): string | null;
+export interface ShellEntry {
+    readonly name: string;
+    readonly kind: "file" | "shell";
+    readonly path: string;
+}
+export declare function shellEntries(output: string, names: readonly string[]): ShellEntry[] | null;
+export type ShellMode = "login" | "interactive";
+export declare function shellArguments(mode: ShellMode): string[];

package/dist/src/agent-harness-shell.js

@@ -0,0 +1,93 @@
+export const shellRunScript = `
+if [ -n "\${ZSH_VERSION-}" ] && (( \${+aliases[$1]} )); then
+  alias_command="\${aliases[$1]}"
+  builtin unalias -- "$1"
+  shift
+  eval -- "$alias_command"' "$@"'
+elif [ -n "\${BASH_VERSION-}" ] && alias_value=$(builtin alias -- "$1" 2>/dev/null); then
+  eval -- "alias_command=\${alias_value#*=}"
+  builtin unalias -- "$1"
+  shift
+  eval -- "$alias_command"' "$@"'
+else
+  "$@"
+fi
+`;
+export const shellTurnScript = `
+set +m
+builtin unset GH_TOKEN GITHUB_TOKEN GH_ENTERPRISE_TOKEN GITHUB_ENTERPRISE_TOKEN || exit
+builtin export GH_CONFIG_DIR="$1" || exit
+shift
+${shellRunScript}
+`;
+export const shellDiscoveryScript = `
+set +m
+if [ -z "\${ZSH_VERSION-}" ] && [ -z "\${BASH_VERSION-}" ]; then exit 64; fi
+printf '__CLOVING_HARNESS_START_-1__\\n%s\\n\\n__CLOVING_HARNESS_END_-1__\\n' "\${BASH_VERSION:+bash}"
+index=0
+for name in "$@"; do
+  printf '__CLOVING_HARNESS_START_%s__\\n' "$index"
+  if [ -n "\${ZSH_VERSION-}" ]; then
+    kind=$(whence -w -- "$name" 2>/dev/null) || kind=
+    printf '%s\\n' "\${kind##*: }"
+    file=$(whence -p -- "$name" 2>/dev/null) || file=
+  else
+    kind=$(builtin type -t -- "$name" 2>/dev/null) || kind=
+    printf '%s\\n' "$kind"
+    file=$(builtin type -P -- "$name" 2>/dev/null) || file=
+  fi
+  case "$file" in /*|"") ;; *) file="$PWD/$file" ;; esac
+  printf '%s\\n' "$file"
+  printf '\\n__CLOVING_HARNESS_END_%s__\\n' "$index"
+  index=$((index + 1))
+done
+exit 0
+`;
+export const shellProbeScript = `
+set +m
+printf '__CLOVING_HARNESS_START_0__\\n'
+if [ "$2" = file ]; then
+  command -- "$1" --version
+elif [ -n "\${ZSH_VERSION-}" ] && (( \${+aliases[$1]} )); then
+  alias_command="\${aliases[$1]}"
+  builtin unalias -- "$1"
+  eval -- "$alias_command"' --version'
+elif [ -n "\${BASH_VERSION-}" ] && alias_value=$(builtin alias -- "$1" 2>/dev/null); then
+  eval -- "alias_command=\${alias_value#*=}"
+  builtin unalias -- "$1"
+  eval -- "$alias_command"' --version'
+elif [ -n "\${ZSH_VERSION-}" ] || [ -n "\${BASH_VERSION-}" ]; then
+  "$1" --version
+else
+  exit 64
+fi
+probe_status=$?
+printf '\\n__CLOVING_HARNESS_END_0__\\n'
+exit "$probe_status"
+`;
+export function shellBlock(output, index) {
+    const start = `__CLOVING_HARNESS_START_${String(index)}__\n`;
+    const end = `\n__CLOVING_HARNESS_END_${String(index)}__\n`;
+    const began = output.indexOf(start);
+    if (began < 0)
+        return null;
+    const finished = output.indexOf(end, began + start.length);
+    return finished < 0 ? null : output.slice(began + start.length, finished);
+}
+export function shellEntries(output, names) {
+    const blocks = names.map((_, index) => shellBlock(output, index));
+    if (blocks.some((block) => block === null))
+        return null;
+    return names.flatMap((name, index) => {
+        const [kind, path] = (blocks[index] ?? "").split("\n");
+        const entries = [];
+        if (path)
+            entries.push({ name, kind: "file", path });
+        if (kind === "function" || kind === "alias")
+            entries.push({ name, kind: "shell", path: name });
+        return entries;
+    });
+}
+export function shellArguments(mode) {
+    return [...(mode === "login" ? ["-l"] : []), "-i", "+m", "-c"];
+}

package/dist/src/agent-harness-versions.d.ts

@@ -0,0 +1,8 @@
+export interface KnownHarness {
+    readonly name: string;
+    readonly versionOption: string;
+    readonly versionPattern: string;
+}
+export declare const knownHarnesses: readonly KnownHarness[];
+export declare function harnessDefinition(name: string): KnownHarness;
+export declare function harnessVersion(output: string, pattern: string): string | null;

package/dist/src/agent-harness-versions.js

@@ -0,0 +1,49 @@
+const semanticVersion = String.raw `\d+\.\d+\.\d+(?:[-+][\w.+-]+)?`;
+const fallbackVersion = String.raw `\d+\.\d+`;
+export const knownHarnesses = [
+    {
+        name: "claude",
+        versionOption: "--version",
+        versionPattern: `^${semanticVersion} \\(Claude Code\\)$`,
+    },
+    {
+        name: "codex",
+        versionOption: "--version",
+        versionPattern: `^codex-cli ${semanticVersion}$`,
+    },
+    {
+        name: "gemini",
+        versionOption: "--version",
+        versionPattern: `^${semanticVersion}$`,
+    },
+    {
+        name: "opencode",
+        versionOption: "--version",
+        versionPattern: `^(?:opencode v)?${semanticVersion}$`,
+    },
+    {
+        name: "grok",
+        versionOption: "--version",
+        versionPattern: `^${semanticVersion}$`,
+    },
+    {
+        name: "cursor-agent",
+        versionOption: "--version",
+        versionPattern: String.raw `^\d{4}\.\d{2}\.\d{2}-[\w.-]+$`,
+    },
+    { name: "pi", versionOption: "--version", versionPattern: fallbackVersion },
+    { name: "amp", versionOption: "--version", versionPattern: fallbackVersion },
+];
+export function harnessDefinition(name) {
+    return (knownHarnesses.find((entry) => entry.name === name) ?? {
+        name,
+        versionOption: "--version",
+        versionPattern: fallbackVersion,
+    });
+}
+export function harnessVersion(output, pattern) {
+    const line = output.split(/\r?\n/, 1)[0] ?? "";
+    if (/\b(?:error|unavailable|not found)\b/i.test(line))
+        return null;
+    return new RegExp(pattern).test(line) ? line : null;
+}

package/dist/src/agent-harnesses.d.ts

@@ -0,0 +1,4 @@
+import { type HarnessOptions } from "./cli/harness-probes.ts";
+export type { HarnessEntry, HarnessDiscovery, HarnessOptions, } from "./cli/harness-probes.ts";
+export declare function discoverHarnesses(options?: HarnessOptions): Promise<import("./cli/harness-probes.ts").HarnessDiscovery>;
+export declare function probeHarness(target: string, options?: HarnessOptions): Promise<import("./cli/harness-probes.ts").HarnessDiscovery>;

package/dist/src/agent-harnesses.js

@@ -0,0 +1,13 @@
+import { spawn } from "node:child_process";
+import { createProbeRunner } from "./cli/probe-command.js";
+import { discoverHarnesses as discover, probeHarness as probe, } from "./cli/harness-probes.js";
+const runner = createProbeRunner({
+    spawn: (input) => spawn(input.executable, input.arguments, input.options),
+    kill: (identifier, signal) => process.kill(identifier, signal),
+});
+export function discoverHarnesses(options = {}) {
+    return discover({ ...options, probe: runner });
+}
+export function probeHarness(target, options = {}) {
+    return probe(target, { ...options, probe: runner });
+}

package/dist/src/authority/command-wait-checks.d.ts

@@ -0,0 +1,8 @@
+import { type CommandWaitState } from "./command-waits.ts";
+import { type Handler } from "./reduction-state.ts";
+export declare function commandWaitCheckId(wait: CommandWaitState): string;
+export declare function commandWaitCheckRefusal(wait: CommandWaitState | undefined, check: {
+    readonly runStatus: string;
+    readonly recordedAt: string;
+}): string | undefined;
+export declare const checkedCommandWait: Handler;

package/dist/src/authority/command-wait-checks.js

@@ -0,0 +1,88 @@
+import { instantMilliseconds, isInstant } from "./instants.js";
+import { commandWaitKey } from "./command-waits.js";
+import { withOperation } from "./operations.js";
+import { applied, invalid, identity } from "./reduction-state.js";
+export function commandWaitCheckId(wait) {
+    return identity({
+        run: wait.runId,
+        phase: "command-wait",
+        operation: wait.name,
+        round: wait.checkCount + 1,
+    });
+}
+export function commandWaitCheckRefusal(wait, check) {
+    if (!isInstant(check.recordedAt))
+        return "invalid-recorded-time";
+    if (wait === undefined)
+        return "unknown-command-wait";
+    const now = instantMilliseconds(check.recordedAt);
+    if (now >= wait.deadline)
+        return "command-wait-timeout";
+    if (check.runStatus !== "running")
+        return "command-wait-run-not-running";
+    if (wait.state !== "waiting")
+        return "command-wait-ended";
+    if (wait.checkOperation !== null)
+        return "command-wait-check-in-flight";
+    if (wait.nextCheckAt === null || now < wait.nextCheckAt)
+        return "command-wait-check-not-due";
+    return undefined;
+}
+function operation(wait, check) {
+    return {
+        runId: wait.runId,
+        operationId: commandWaitCheckId(wait),
+        capability: "command",
+        method: `run:${wait.command}`,
+        target: wait.command,
+        payload: wait.inputDigest,
+        inputDigest: check.inputDigest,
+        units: 1,
+        recoveryLimit: 1,
+        leaseKey: commandWaitCheckId(wait),
+        status: "waiting",
+        reason: "ready",
+        attempts: 0,
+        receipt: null,
+        worker: null,
+        result: null,
+        requestedSequence: check.sequence,
+        waitSequence: check.sequence,
+        settledSequence: null,
+    };
+}
+export const checkedCommandWait = (state, recorded) => {
+    const { event, run } = recorded;
+    const waits = state.commandWaits ?? {};
+    const key = commandWaitKey(event.runId, event.payload["waitName"] ?? "");
+    const wait = waits[key];
+    const reason = commandWaitCheckRefusal(wait, {
+        runStatus: run.status,
+        recordedAt: event.recordedAt,
+    });
+    if (reason !== undefined || wait === undefined)
+        return invalid(reason ?? "unknown-command-wait");
+    const check = operation(wait, {
+        sequence: event.sequence,
+        inputDigest: event.payload["inputDigest"] ?? "",
+    });
+    if (state.effects.operations[check.operationId] !== undefined)
+        return invalid("command-wait-operation-conflict");
+    return applied(state, {
+        ...recorded,
+        commandWaits: {
+            ...waits,
+            [key]: {
+                ...wait,
+                checkCount: wait.checkCount + 1,
+                checkOperation: check.operationId,
+            },
+        },
+        effects: withOperation(state.effects, check),
+        disposition: {
+            operationId: check.operationId,
+            disposition: "admitted",
+            reason: null,
+        },
+    });
+};

package/dist/src/authority/command-wait-results.d.ts

@@ -0,0 +1,15 @@
+import { type CommandWaitsState } from "./command-waits.ts";
+import type { AuthorityState } from "./transitions.ts";
+import { type EffectChange, type Operation } from "./operations.ts";
+import type { AuthorityEvent } from "./transitions.ts";
+export declare function settledCommandWaits(waits: CommandWaitsState, check: {
+    readonly event: AuthorityEvent;
+    readonly operation: Operation | undefined;
+}): CommandWaitsState;
+export declare function waitEffectTime(waits: CommandWaitsState, event: AuthorityEvent): boolean;
+export declare function waitEffectChange(state: AuthorityState, settlement: {
+    readonly event: AuthorityEvent;
+    readonly result: EffectChange;
+}): {
+    readonly commandWaits?: CommandWaitsState;
+};

package/dist/src/authority/command-wait-results.js

@@ -0,0 +1,73 @@
+import { instantMilliseconds, isInstant } from "./instants.js";
+import { timedOut, } from "./command-waits.js";
+import { isFinal } from "./operations.js";
+function output(text) {
+    try {
+        const value = JSON.parse(text ?? "");
+        if (value === null || typeof value !== "object" || Array.isArray(value))
+            return { kind: "failed", reason: "command-wait-invalid-output" };
+        const ready = Reflect.get(value, "ready");
+        if (ready === false)
+            return { kind: "pending" };
+        if (ready === true)
+            return {
+                kind: "ready",
+                value: JSON.stringify(Reflect.get(value, "value") ?? null),
+            };
+        return { kind: "failed", reason: "command-wait-invalid-output" };
+    }
+    catch {
+        return { kind: "failed", reason: "command-wait-invalid-output" };
+    }
+}
+function settled(wait, check) {
+    const { event, operation } = check;
+    const now = instantMilliseconds(event.recordedAt);
+    const recorded = { ...wait, checkOperation: null, lastCheckSettledAt: now };
+    if (now >= wait.deadline)
+        return timedOut(recorded);
+    const result = operation.status === "completed"
+        ? output(event.payload["commandOutput"])
+        : { kind: "failed", reason: operation.reason ?? "command-interrupted" };
+    if (result.kind === "pending")
+        return { ...recorded, nextCheckAt: now + wait.pollEverySeconds * 1000 };
+    return {
+        ...recorded,
+        state: result.kind === "ready" ? "completed" : "failed",
+        settledAt: now,
+        nextCheckAt: null,
+        result: result.kind === "ready" ? result.value : null,
+        reason: result.kind === "failed" ? result.reason : null,
+    };
+}
+export function settledCommandWaits(waits, check) {
+    const { event, operation } = check;
+    if (operation === undefined ||
+        !isFinal(operation) ||
+        !isInstant(event.recordedAt))
+        return waits;
+    return Object.fromEntries(Object.entries(waits).map(([key, wait]) => [
+        key,
+        wait.runId === event.runId &&
+            wait.checkOperation === operation.operationId &&
+            wait.state === "waiting"
+            ? settled(wait, { event, operation })
+            : wait,
+    ]));
+}
+export function waitEffectTime(waits, event) {
+    const check = Object.values(waits).some((wait) => wait.runId === event.runId &&
+        wait.checkOperation === event.payload["operationId"]);
+    return !check || isInstant(event.recordedAt);
+}
+export function waitEffectChange(state, settlement) {
+    if (state.commandWaits === undefined ||
+        settlement.result.disposition?.disposition !== "applied")
+        return {};
+    return {
+        commandWaits: settledCommandWaits(state.commandWaits, {
+            event: settlement.event,
+            operation: settlement.result.effects.operations[settlement.event.payload["operationId"] ?? ""],
+        }),
+    };
+}

package/dist/src/authority/command-wait-view.d.ts

@@ -0,0 +1,21 @@
+import { type CommandWaitState, type CommandWaitsState } from "./command-waits.ts";
+import type { CommandWaits } from "../workflow-declaration.ts";
+export interface CommandWaitView<Time = string> {
+    readonly name: string;
+    readonly command: string;
+    readonly state: string;
+    readonly maximumWaitSeconds: number;
+    readonly startedAt: Time | null;
+    readonly deadline: Time | null;
+    readonly nextCheckAt: Time | null;
+    readonly checkCount: number;
+    readonly remainingSeconds: number;
+    readonly reason: string | null;
+}
+export declare function commandWaitView(wait: CommandWaitState, now: number): CommandWaitView<number>;
+export declare function commandWaitViews(input: {
+    readonly runId: string;
+    readonly declarations: CommandWaits;
+    readonly waits: CommandWaitsState;
+    readonly now: number;
+}): readonly CommandWaitView<number>[];

package/dist/src/authority/command-wait-view.js

@@ -0,0 +1,34 @@
+import { commandWaitKey, } from "./command-waits.js";
+export function commandWaitView(wait, now) {
+    return {
+        name: wait.name,
+        command: wait.command,
+        state: wait.state,
+        maximumWaitSeconds: wait.maximumWaitSeconds,
+        startedAt: wait.startedAt,
+        deadline: wait.deadline,
+        nextCheckAt: wait.nextCheckAt,
+        checkCount: wait.checkCount,
+        remainingSeconds: Math.max(0, Math.ceil((wait.deadline - (wait.settledAt ?? now)) / 1000)),
+        reason: wait.reason,
+    };
+}
+export function commandWaitViews(input) {
+    return Object.entries(input.declarations).map(([name, declaration]) => {
+        const wait = input.waits[commandWaitKey(input.runId, name)];
+        return wait === undefined
+            ? {
+                name,
+                command: declaration.command,
+                state: "not-started",
+                maximumWaitSeconds: declaration.maximumWaitSeconds,
+                startedAt: null,
+                deadline: null,
+                nextCheckAt: null,
+                checkCount: 0,
+                remainingSeconds: declaration.maximumWaitSeconds,
+                reason: null,
+            }
+            : commandWaitView(wait, input.now);
+    });
+}

package/dist/src/authority/command-waits.d.ts

@@ -0,0 +1,39 @@
+interface WaitEvent {
+    readonly type: string;
+    readonly runId: string;
+    readonly recordedAt: string;
+    readonly payload: Readonly<Record<string, string>>;
+}
+export interface CommandWaitState {
+    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: "waiting" | "timed-out" | "cancelled" | "completed" | "failed";
+    readonly checkCount: number;
+    readonly checkOperation: string | null;
+    readonly lastCheckSettledAt: number | null;
+    readonly result: string | null;
+    readonly settledAt: number | null;
+    readonly reason: string | null;
+}
+export type CommandWaitsState = Readonly<Record<string, CommandWaitState>>;
+export declare function endedCommandWaitCheck(waits: CommandWaitsState, operationId: string): boolean;
+export declare function commandWaitKey(runId: string, name: string): string;
+type WaitChange = {
+    readonly kind: "updated";
+    readonly waits: CommandWaitsState;
+} | {
+    readonly kind: "invalid";
+    readonly reason: string;
+};
+export declare function timedOut(wait: CommandWaitState): CommandWaitState;
+export declare function validCommandWaitTime(waits: CommandWaitsState, event: WaitEvent): boolean;
+export declare function closedCommandWaits(waits: CommandWaitsState, event: WaitEvent): CommandWaitsState;
+export declare function commandWaitsAfter(waits: CommandWaitsState, event: WaitEvent): WaitChange;
+export {};

package/dist/src/authority/command-waits.js

@@ -0,0 +1,97 @@
+import { isInstant, instantMilliseconds } from "./instants.js";
+export function endedCommandWaitCheck(waits, operationId) {
+    return Object.values(waits).some((wait) => wait.state !== "waiting" && wait.checkOperation === operationId);
+}
+export function commandWaitKey(runId, name) {
+    return JSON.stringify([runId, name]);
+}
+function openedCommandWait(event) {
+    const startedAt = instantMilliseconds(event.recordedAt);
+    const maximumWaitSeconds = Number(event.payload["maximumWaitSeconds"]);
+    return {
+        runId: event.runId,
+        name: event.payload["waitName"] ?? "",
+        command: event.payload["target"] ?? "",
+        inputDigest: event.payload["payload"] ?? "",
+        maximumWaitSeconds,
+        pollEverySeconds: Number(event.payload["pollEverySeconds"]),
+        startedAt,
+        deadline: startedAt + maximumWaitSeconds * 1000,
+        nextCheckAt: startedAt,
+        state: "waiting",
+        checkCount: 0,
+        checkOperation: null,
+        lastCheckSettledAt: null,
+        result: null,
+        settledAt: null,
+        reason: null,
+    };
+}
+export function timedOut(wait) {
+    return {
+        ...wait,
+        state: "timed-out",
+        settledAt: wait.deadline,
+        nextCheckAt: null,
+        reason: "command-wait-timeout",
+    };
+}
+export function validCommandWaitTime(waits, event) {
+    if (!["run.completed", "run.failed", "run.cancelled"].includes(event.type))
+        return true;
+    return Object.values(waits).every((wait) => wait.runId !== event.runId ||
+        wait.state !== "waiting" ||
+        (isInstant(event.recordedAt) &&
+            instantMilliseconds(event.recordedAt) >= wait.startedAt));
+}
+export function closedCommandWaits(waits, event) {
+    if (!["run.completed", "run.failed", "run.cancelled"].includes(event.type))
+        return waits;
+    return Object.fromEntries(Object.entries(waits).map(([key, wait]) => {
+        if (wait.runId !== event.runId || wait.state !== "waiting")
+            return [key, wait];
+        if (instantMilliseconds(event.recordedAt) >= wait.deadline)
+            return [key, timedOut(wait)];
+        return [
+            key,
+            {
+                ...wait,
+                state: "cancelled",
+                nextCheckAt: null,
+                settledAt: instantMilliseconds(event.recordedAt),
+                reason: "command-wait-run-ended",
+            },
+        ];
+    }));
+}
+function opened(waits, event) {
+    const key = commandWaitKey(event.runId, event.payload["waitName"] ?? "");
+    const previous = waits[key];
+    const candidate = openedCommandWait(event);
+    if (previous !== undefined && previous.inputDigest !== candidate.inputDigest)
+        return { kind: "invalid", reason: "command-wait-input-mismatch" };
+    const wait = previous ?? candidate;
+    const expired = wait.state === "waiting" &&
+        instantMilliseconds(event.recordedAt) >= wait.deadline;
+    return {
+        kind: "updated",
+        waits: { ...waits, [key]: expired ? timedOut(wait) : wait },
+    };
+}
+export function commandWaitsAfter(waits, event) {
+    if (event.type.startsWith("command-wait.") && !isInstant(event.recordedAt))
+        return { kind: "invalid", reason: "invalid-recorded-time" };
+    if (event.type === "command-wait.opened")
+        return opened(waits, event);
+    if (event.type !== "command-wait.expired")
+        return { kind: "updated", waits: closedCommandWaits(waits, event) };
+    const key = commandWaitKey(event.runId, event.payload["waitName"] ?? "");
+    const previous = waits[key];
+    if (previous === undefined)
+        return { kind: "invalid", reason: "unknown-command-wait" };
+    if (previous.state !== "waiting")
+        return { kind: "updated", waits };
+    if (instantMilliseconds(event.recordedAt) < previous.deadline)
+        return { kind: "invalid", reason: "command-wait-not-expired" };
+    return { kind: "updated", waits: { ...waits, [key]: timedOut(previous) } };
+}

package/dist/src/authority/commands.d.ts

@@ -3,6 +3,7 @@ export declare const commandEvents: Readonly<Record<string, EventType>>;
 export declare function parseCommand(value: unknown): AuthorityCommand | null;
 export declare const recoveryBound = 10;
 export declare function isCapabilityList(value: unknown): value is string;
+export declare function isDeviceActor(value: unknown): value is string;
 export declare function isIdentifier(value: unknown): value is string;
 export declare function isRecordKey(value: unknown): value is string;
 export declare function isCommandId(value: unknown): value is string;