cloving 1.3.0 → 1.5.0

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

@@ -1,4 +1,5 @@
-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\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 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;

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

@@ -1,8 +1,4 @@
-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
+export const shellRunScript = `
 if [ -n "\${ZSH_VERSION-}" ] && (( \${+aliases[$1]} )); then
   alias_command="\${aliases[$1]}"
   builtin unalias -- "$1"
@@ -17,6 +13,13 @@ 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

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.js

@@ -8,6 +8,9 @@ const digest = /^sha256:[0-9a-f]{64}$/;
 const operation = /^[\x20-\x7e]{1,512}$/;
 export const commandEvents = {
     "admit-run": "run.created",
+    "open-command-wait": "command-wait.opened",
+    "check-command-wait": "command-wait.checked",
+    "expire-command-wait": "command-wait.expired",
     "mark-started": "run.started",
     "open-gate": "gate.opened",
     "register-wait": "gate.wait-registered",
@@ -29,6 +32,19 @@ export const commandEvents = {
 };
 const revised = { required: ["expectedRevision"] };
 const shapes = {
+    "expire-command-wait": { required: ["waitName"] },
+    "check-command-wait": { required: ["waitName", "inputDigest"] },
+    "open-command-wait": {
+        required: [
+            "waitName",
+            "target",
+            "payload",
+            "maximumWaitSeconds",
+            "pollEverySeconds",
+        ],
+        consistent: (fields) => Number(fields["pollEverySeconds"]) <=
+            Number(fields["maximumWaitSeconds"]),
+    },
     "record-schedule-skip": {
         required: ["workflowId", "slot"],
         validators: { slot: positive },
@@ -141,7 +157,7 @@ const shapes = {
             "worker",
             "outcome",
         ],
-        optional: ["result", "reason", "evidence"],
+        optional: ["result", "reason", "evidence", "commandOutput"],
         consistent: (fields) => reportedOutcomes.includes(String(fields["outcome"])) &&
             (fields["outcome"] === "failed" ||
                 (fields["result"] !== undefined) ===
@@ -157,6 +173,7 @@ const shapes = {
             "result",
             "reason",
             "evidence",
+            "commandOutput",
         ],
     },
 };
@@ -264,6 +281,10 @@ export function isCapabilityList(value) {
         JSON.stringify(list) === value);
 }
 const validators = {
+    commandOutput: (value) => typeof value === "string",
+    waitName: (value) => typeof value === "string" && /^[A-Za-z0-9-]{1,64}$/.test(value),
+    maximumWaitSeconds: (value) => whole(value) && value >= 60 && value <= 2_592_000,
+    pollEverySeconds: (value) => whole(value) && value >= 60 && value <= 86_400,
     expectedRevision: positive,
     expectedObservation: whole,
     generation: positive,

package/dist/src/authority/dispatch-decision.d.ts

@@ -1,4 +1,9 @@
+import type { CommandWaitState } from "./command-waits.ts";
 export interface DispatchRead {
+    readonly commandWait?: {
+        readonly wait: CommandWaitState;
+        readonly declared: boolean;
+    };
     readonly attempt: {
         readonly outcome: string | null;
         readonly inputDigest: string;
@@ -12,6 +17,9 @@ export interface DispatchRead {
         readonly status: string;
         readonly capability: string;
         readonly units: number;
+        readonly method?: string;
+        readonly target?: string;
+        readonly payload?: string;
     } | undefined;
     readonly budget: {
         readonly limit: number;

package/dist/src/authority/dispatch-decision.js

@@ -1,3 +1,5 @@
+import { operationPhase } from "../operation-identity.js";
+import { instantMilliseconds } from "./instants.js";
 import { authorizeEffect } from "../effect-authorization.js";
 import { isAfter } from "./instants.js";
 function bound(read, intent) {
@@ -39,12 +41,35 @@ function authorized(read) {
     });
     return result.kind === "authorized";
 }
+function authorizedWait(read, check) {
+    const { commandWait, operation } = read;
+    if (commandWait === undefined || operation === undefined)
+        return false;
+    const { wait, declared } = commandWait;
+    const now = instantMilliseconds(check.now);
+    return [
+        declared,
+        wait.state === "waiting",
+        wait.checkOperation === check.intent.operationId,
+        wait.nextCheckAt !== null && now >= wait.nextCheckAt,
+        now < wait.deadline,
+        read.budget?.capabilities.includes("command"),
+        operation.capability === "command",
+        operation.units === 1,
+        operation.method === `run:${wait.command}`,
+        operation.target === wait.command,
+        operation.payload === wait.inputDigest,
+    ].every(Boolean);
+}
 export function dispatchDecision(read, check) {
     if (!bound(read, check.intent))
         return "stale";
     if (!sendable(read, check))
         return "withheld";
-    if (!authorized(read))
+    const allowed = operationPhase(check.intent.operationId) === "command-wait"
+        ? authorizedWait(read, check)
+        : authorized(read);
+    if (!allowed)
         return "refused";
     return read.pinned ? "send" : "blocked";
 }

package/dist/src/authority/effect-requests.js

@@ -1,4 +1,4 @@
-import { operationScope } from "../operation-identity.js";
+import { operationScope, operationPhase } from "../operation-identity.js";
 import { authorization } from "./budgets.js";
 import { current, ownedLease } from "./leases.js";
 import { cancelledOperation, count, field, rejected, runOperations, withOperation, } from "./operations.js";
@@ -18,7 +18,8 @@ function refusal(context) {
     if (!admittingStatuses.includes(runStatus))
         return "run-not-running";
     const scope = operationScope(field(event, "operationId"));
-    if (scope?.run !== event.runId)
+    if (scope?.run !== event.runId ||
+        operationPhase(field(event, "operationId")) === "command-wait")
         return "operation-scope-mismatch";
     if (runOperations.includes(scope.operation))
         return "operation-scope-mismatch";
@@ -62,7 +63,9 @@ function requestedOperation(event, outcome) {
 function withoutWaits(operations, event) {
     return Object.fromEntries(Object.entries(operations).map(([operationId, operation]) => [
         operationId,
-        operation.runId === event.runId && operation.status === "waiting"
+        operation.runId === event.runId &&
+            operation.status === "waiting" &&
+            operationPhase(operation.operationId) !== "command-wait"
             ? cancelledOperation(operation, {
                 reason: "budget-exhausted",
                 sequence: event.sequence,

package/dist/src/authority/effect-results.js

@@ -1,3 +1,4 @@
+import { operationPhase } from "../operation-identity.js";
 import { current, ownedLease } from "./leases.js";
 import { cancelledOperation, count, field, isFinal, isHolding, namesRunIntent, rejected, withOperation, } from "./operations.js";
 const terminalStatuses = ["completed", "failed", "cancelled"];
@@ -135,8 +136,9 @@ function statedReason(event) {
 }
 function notStarted(effects, subject) {
     const { operation, event, runStatus } = subject;
-    const exhausted = (effects.budgets[operation.runId]?.exhaustedSequence ?? null) !== null ||
-        field(event, "reason") === "budget-exhausted";
+    const exhausted = field(event, "reason") === "budget-exhausted" ||
+        (operationPhase(operation.operationId) !== "command-wait" &&
+            (effects.budgets[operation.runId]?.exhaustedSequence ?? null) !== null);
     const ended = terminalStatuses.includes(runStatus);
     const waiting = {
         ...operation,

package/dist/src/authority/history-state.d.ts

@@ -1,11 +1,13 @@
 import type { AuthorityState } from "./transitions.ts";
 export declare class HistoryState {
     private state;
+    private readonly commandWaits;
     private readonly runs;
     private readonly commands;
     private readonly details;
     private readonly gates;
     private readonly budgets;
+    private readonly runWaits;
     private readonly runGates;
     private readonly intents;
     private readonly pending;

package/dist/src/authority/history-state.js

@@ -6,11 +6,13 @@ function entry(values, key) {
 }
 export class HistoryState {
     state = emptyAuthority;
+    commandWaits = {};
     runs = {};
     commands = {};
     details = {};
     gates = {};
     budgets = {};
+    runWaits = new Map();
     runGates = new Map();
     intents = new Map();
     pending = new Set();
@@ -20,6 +22,9 @@ export class HistoryState {
             return this.state;
         return {
             ...this.state,
+            ...(this.runWaits.has(event.runId)
+                ? { commandWaits: this.runWaits.get(event.runId) ?? {} }
+                : {}),
             runs: entry(this.runs, event.runId),
             commands: entry(this.commands, event.commandId),
             details: entry(this.details, event.runId),
@@ -32,6 +37,10 @@ export class HistoryState {
         };
     }
     record(state, runId) {
+        const { commandWaits, ...baseState } = state;
+        Object.assign(this.commandWaits, commandWaits);
+        if (commandWaits !== undefined)
+            this.runWaits.set(runId, commandWaits);
         Object.assign(this.runs, state.runs);
         Object.assign(this.commands, state.commands);
         Object.assign(this.details, state.details);
@@ -45,11 +54,14 @@ export class HistoryState {
         for (const intent of remaining)
             this.pending.add(intent);
         this.intents.set(runId, state.intents);
-        this.state = state;
+        this.state = baseState;
     }
     finish() {
         return {
             ...this.state,
+            ...(Object.keys(this.commandWaits).length === 0
+                ? {}
+                : { commandWaits: this.commandWaits }),
             runs: this.runs,
             commands: this.commands,
             details: this.details,

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

@@ -1,3 +1,4 @@
 export declare function isInstant(value: unknown): value is string;
 export declare function notBefore(value: string, bound: string): boolean;
 export declare function isAfter(value: string, bound: string): boolean;
+export declare function instantMilliseconds(value: string): number;