cloving 1.2.0 → 1.3.0

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

@@ -0,0 +1,12 @@
+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 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,90 @@
+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
+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 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/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;

package/dist/src/authority/commands.js

@@ -25,9 +25,14 @@ export const commandEvents = {
     "expire-lease": "lease.expired",
     "report-effect": "effect.reported",
     "record-outcome": "operation.reconciled",
+    "record-schedule-skip": "schedule.skipped",
 };
 const revised = { required: ["expectedRevision"] };
 const shapes = {
+    "record-schedule-skip": {
+        required: ["workflowId", "slot"],
+        validators: { slot: positive },
+    },
     "admit-run": {
         required: ["workflow"],
         optional: [
@@ -48,14 +53,16 @@ const shapes = {
     "mark-started": revised,
     "open-gate": {
         required: ["gateId", "expectedRevision"],
-        optional: ["gateKind", "subject", "prompt", "expiresAt"],
+        optional: ["gateKind", "subject", "prompt", "expiresAt", "waitMode"],
+        validators: { waitMode: (value) => value === "hook" },
         groups: [["gateKind", "subject", "prompt"]],
-        consistent: (fields) => fields["expiresAt"] === undefined || fields["gateKind"] !== undefined,
+        consistent: (fields) => (fields["expiresAt"] === undefined && fields["waitMode"] === undefined) ||
+            fields["gateKind"] !== undefined,
     },
     "register-wait": { required: ["gateId"] },
     "decide-gate": {
         required: ["gateId", "decision", "expectedRevision"],
-        optional: ["generation", "subject", "answer"],
+        optional: ["generation", "subject", "answer", "actor"],
         groups: [["generation", "subject"]],
         consistent: (fields) => {
             const typed = fields["generation"] !== undefined;
@@ -97,7 +104,14 @@ const shapes = {
     "cancel-run": revised,
     "report-observation": {
         required: ["condition", "reason"],
-        optional: ["evidence", "retryAt", "attempt", "limit", "operationId"],
+        optional: [
+            "evidence",
+            "retryAt",
+            "attempt",
+            "limit",
+            "operationId",
+            "expectedObservation",
+        ],
         groups: [["attempt", "limit"]],
     },
     "record-dispatch": { required: ["operationId", "receipt"] },
@@ -150,6 +164,7 @@ const reportedOutcomes = ["completed", "failed", "stopped"];
 const outcomes = [...reportedOutcomes, "accepted", "not-started", "unknown"];
 const conditions = [
     "working",
+    "waiting-run",
     "quota-wait",
     "infrastructure-failure",
     "code-failure",
@@ -250,6 +265,7 @@ export function isCapabilityList(value) {
 }
 const validators = {
     expectedRevision: positive,
+    expectedObservation: whole,
     generation: positive,
     attempt: positive,
     limit: positive,
@@ -274,7 +290,11 @@ const validators = {
     condition: (value) => typeof value === "string" && conditions.includes(value),
     expiresAt: isInstant,
     retryAt: isInstant,
+    actor: isDeviceActor,
 };
+export function isDeviceActor(value) {
+    return (typeof value === "string" && /^device:[A-Za-z0-9_-]{1,64}$/.test(value));
+}
 export function isIdentifier(value) {
     return typeof value === "string" && identifier.test(value);
 }

package/dist/src/authority/gate-reduction.d.ts

@@ -2,6 +2,7 @@ import { type SettledGate } from "./gates.ts";
 import { type Recorded, type Reduction } from "./reduction-state.ts";
 import { type AuthorityState, type EffectIntent } from "./transitions.ts";
 export declare function gateContinuation(gate: SettledGate): EffectIntent;
+export declare function gateDelivery(gate: SettledGate): EffectIntent;
 export declare function opened(state: AuthorityState, recorded: Recorded): Reduction;
 export declare function decided(state: AuthorityState, recorded: Recorded): Reduction;
 export declare function expired(state: AuthorityState, recorded: Recorded): Reduction;

package/dist/src/authority/gate-reduction.js

@@ -1,4 +1,4 @@
-import { continues, decisionRefusal, expiryRefusal, gateKey, openedGate, reusable, settled, } from "./gates.js";
+import { delivers, decisionRefusal, expiryRefusal, gateKey, openedGate, reusable, settled, } from "./gates.js";
 import { applied, identity, invalid, text, } from "./reduction-state.js";
 import { terminal, transition, } from "./transitions.js";
 export function gateContinuation(gate) {
@@ -14,8 +14,23 @@ export function gateContinuation(gate) {
         }),
     };
 }
+export function gateDelivery(gate) {
+    if (gate.wait !== "hook")
+        return gateContinuation(gate);
+    return {
+        kind: "resume-hook",
+        runId: gate.runId,
+        operationId: identity({
+            run: gate.runId,
+            phase: "gate",
+            round: gate.outcome.sequence,
+            operation: "resume-hook",
+            key: gate.gateId,
+        }),
+    };
+}
 function continuations(gate) {
-    return continues(gate) ? [gateContinuation(gate)] : [];
+    return delivers(gate) ? [gateDelivery(gate)] : [];
 }
 export function opened(state, recorded) {
     const { event, run } = recorded;
@@ -98,7 +113,7 @@ export function registered(state, recorded) {
     const gate = gateOf(state, event);
     if (gate === undefined)
         return invalid("unknown-gate");
-    if (gate.wait === "registered")
+    if (gate.wait !== "pending")
         return invalid("wait-already-registered");
     const next = { ...gate, wait: "registered" };
     return applied(state, {

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

@@ -14,7 +14,7 @@ export interface GateState {
     readonly expiresAt: string | null;
     readonly generation: number;
     readonly revision: number;
-    readonly wait: "registered" | "pending";
+    readonly wait: "registered" | "pending" | "hook";
     readonly outcome: GateOutcome | null;
     readonly openedSequence: number;
 }
@@ -45,4 +45,5 @@ export type ContinuingGate = GateState & {
     };
 };
 export declare function continues(gate: GateState): gate is ContinuingGate;
+export declare function delivers(gate: GateState): gate is ContinuingGate;
 export {};

package/dist/src/authority/gates.js

@@ -22,6 +22,7 @@ export function gateKey(runId, gateId) {
 export function openedGate(opening) {
     const { payload } = opening;
     const kind = kinds[payload["gateKind"] ?? ""] ?? "untyped";
+    const wait = kind === "untyped" ? "registered" : "pending";
     return {
         runId: opening.runId,
         gateId: payload["gateId"] ?? "",
@@ -32,7 +33,7 @@ export function openedGate(opening) {
         expiresAt: payload["expiresAt"] ?? null,
         generation: opening.generation,
         revision: 1,
-        wait: kind === "untyped" ? "registered" : "pending",
+        wait: payload["waitMode"] === "hook" ? "hook" : wait,
         outcome: null,
         openedSequence: opening.sequence,
     };
@@ -75,3 +76,6 @@ export function continues(gate) {
         isSettled(gate) &&
         gate.outcome.decision !== null);
 }
+export function delivers(gate) {
+    return (gate.wait !== "pending" && isSettled(gate) && gate.outcome.decision !== null);
+}

package/dist/src/authority/operations.js

@@ -24,7 +24,7 @@ const finalStatuses = [
     "stopped",
     "cancelled",
 ];
-export const runOperations = ["start-run", "continue-run"];
+export const runOperations = ["start-run", "continue-run", "resume-hook"];
 export function namesRunIntent(operationId, runId) {
     const scope = operationScope(operationId);
     return scope?.run === runId && runOperations.includes(scope.operation);

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

@@ -1,6 +1,6 @@
 import { type Reduction } from "./reduction-state.ts";
 import { type AuthorityEvent, type AuthorityState } from "./transitions.ts";
-export { gateContinuation } from "./gate-reduction.ts";
+export { gateContinuation, gateDelivery } from "./gate-reduction.ts";
 export type { Reduction } from "./reduction-state.ts";
 export declare function startOperation(runId: string): string;
 export declare function reduce(state: AuthorityState, event: AuthorityEvent): Reduction;

package/dist/src/authority/reduction.js

@@ -7,7 +7,7 @@ import { decided, expired, opened, registered } from "./gate-reduction.js";
 import { expired as leaseExpired, granted } from "./leases.js";
 import { applied, identity, invalid, text, } from "./reduction-state.js";
 import { transition, } from "./transitions.js";
-export { gateContinuation } from "./gate-reduction.js";
+export { gateContinuation, gateDelivery } from "./gate-reduction.js";
 function moved(type) {
     return (state, recorded) => {
         const result = transition(recorded.run, {
@@ -36,6 +36,10 @@ function closed(type) {
     };
 }
 function observation(state, recorded) {
+    const expected = recorded.event.payload["expectedObservation"];
+    if (expected !== undefined &&
+        expected !== String(recorded.details.observation?.sequence ?? 0))
+        return invalid("stale-observation");
     return applied(state, {
         ...recorded,
         observed: observed(recorded.details, recorded.event),
@@ -75,6 +79,7 @@ function effect(rule) {
     };
 }
 const handlers = {
+    "schedule.skipped": applied,
     "effect.requested": effect(requested),
     "lease.granted": effect(granted),
     "lease.expired": effect(leaseExpired),

package/dist/src/authority/status-input.d.ts

@@ -4,7 +4,7 @@ import type { RunClosure } from "./stop-sequence.ts";
 import type { RunState } from "./transitions.ts";
 export interface OperationSummary {
     readonly operationId: string;
-    readonly kind: "start-run" | "continue-run" | "protected-effect";
+    readonly kind: "start-run" | "continue-run" | "resume-hook" | "protected-effect";
     readonly releasedSequence: number | null;
     readonly outcomes: readonly (string | null)[];
 }

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

@@ -9,6 +9,7 @@ export interface RunView {
     readonly workflow: string;
     readonly state: RunStatus;
     readonly condition: string;
+    readonly awaitedRunId: string | null;
     readonly revision: number;
     readonly latestSequence: number;
     readonly pendingDecisions: readonly string[];

package/dist/src/authority/status.js

@@ -88,8 +88,10 @@ const unavailablePin = assessed("infrastructure-failure", {
     nextAction: "restore-pinned-workflow",
     humanInputCanHelp: true,
 });
-function worldConflict(input) {
+function workflowFailure(input) {
     const code = input.details?.observation?.reason;
+    if (code === "pinned-workflow-unavailable")
+        return unavailablePin;
     if (code !== "world-run-conflict")
         return undefined;
     return assessed("infrastructure-failure", {
@@ -103,7 +105,7 @@ function queued(input) {
         return unknownEffect;
     if (blocked(input.operations))
         return unavailablePin;
-    const conflict = worldConflict(input);
+    const conflict = workflowFailure(input);
     if (conflict !== undefined)
         return conflict;
     if (dispatched(input.operations))
@@ -141,10 +143,13 @@ function running(input) {
         return effect;
     if (blocked(input.operations))
         return unavailablePin;
-    return worldConflict(input) ?? observed(input);
+    return workflowFailure(input) ?? observed(input);
 }
 function observed(input) {
     const observation = input.details?.observation ?? null;
+    const wait = runWaitAssessment(observation);
+    if (wait !== undefined)
+        return wait;
     if (observation !== null &&
         Object.hasOwn(observedActions, observation.condition))
         return observedWork(observation);
@@ -160,7 +165,20 @@ function observed(input) {
         humanInputCanHelp: false,
     });
 }
+function runWaitAssessment(observation) {
+    if (observation?.condition === "waiting-run")
+        return assessed("waiting-run", {
+            code: "awaiting-run",
+            detail: `The run waits for run ${observation.evidence ?? "unknown"}.`,
+            nextAction: "await-run",
+            nextActionAt: observation.retryAt,
+            humanInputCanHelp: false,
+        });
+    return undefined;
+}
 function waiting(input) {
+    if (input.details?.observation?.reason === "pinned-workflow-unavailable")
+        return unavailablePin;
     const pending = input.gates.filter((gate) => gate.outcome === null);
     const question = pending.some((gate) => gate.kind === "question");
     const approval = pending.some((gate) => gate.kind === "approval");
@@ -226,6 +244,7 @@ export function runView(input) {
         workflow: run.workflow,
         state: run.status,
         condition: assessment.condition,
+        awaitedRunId: awaitedRun(assessment, observation),
         revision: run.revision,
         latestSequence: input.latestSequence,
         pendingDecisions: input.gates
@@ -254,3 +273,8 @@ export function runView(input) {
         humanInputCanHelp: assessment.humanInputCanHelp,
     };
 }
+function awaitedRun(assessment, observation) {
+    return assessment.condition === "waiting-run"
+        ? (observation?.evidence ?? null)
+        : null;
+}

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

@@ -11,7 +11,7 @@ export interface RunState {
     readonly gates: readonly string[];
 }
 export interface EffectIntent {
-    readonly kind: "start-run" | "continue-run" | "protected-effect";
+    readonly kind: "start-run" | "continue-run" | "resume-hook" | "protected-effect";
     readonly runId: string;
     readonly operationId: string;
 }
@@ -28,7 +28,7 @@ export interface AuthorityState {
     readonly questions: number;
     readonly effects: EffectState;
 }
-export declare const eventTypes: readonly ["run.created", "run.started", "gate.opened", "gate.wait-registered", "gate.decided", "gate.expired", "run.paused", "run.resumed", "run.completed", "run.failed", "run.cancelled", "run.observed", "step.dispatched", "effect.requested", "lease.granted", "lease.expired", "effect.reported", "operation.reconciled"];
+export declare const eventTypes: readonly ["run.created", "run.started", "gate.opened", "gate.wait-registered", "gate.decided", "gate.expired", "run.paused", "run.resumed", "run.completed", "run.failed", "run.cancelled", "run.observed", "step.dispatched", "effect.requested", "lease.granted", "lease.expired", "effect.reported", "operation.reconciled", "schedule.skipped"];
 export type EventType = (typeof eventTypes)[number];
 export interface AuthorityEvent {
     readonly sequence: number;
@@ -39,8 +39,8 @@ export interface AuthorityEvent {
     readonly request: string;
     readonly payload: Readonly<Record<string, string>>;
 }
-export declare const numberFields: readonly ["expectedRevision", "generation", "attempt", "limit", "effectLimit", "units", "recoveryLimit", "leaseGeneration", "sourceGeneration", "capacity"];
-export declare const textFields: readonly ["parentRunId", "chainId", "workflow", "submission", "input", "resolver", "gateId", "gateKind", "subject", "prompt", "expiresAt", "decision", "answer", "condition", "reason", "evidence", "retryAt", "operationId", "receipt", "capabilities", "capability", "method", "target", "payload", "inputDigest", "resource", "transport", "source", "worker", "outcome", "outcomeReason", "promotionId", "ticketStatus", "issueUpdate", "result"];
+export declare const numberFields: readonly ["expectedRevision", "expectedObservation", "generation", "attempt", "limit", "effectLimit", "units", "recoveryLimit", "leaseGeneration", "sourceGeneration", "capacity", "slot"];
+export declare const textFields: readonly ["parentRunId", "chainId", "workflow", "workflowId", "submission", "input", "resolver", "gateId", "gateKind", "waitMode", "subject", "prompt", "expiresAt", "decision", "answer", "condition", "reason", "evidence", "retryAt", "operationId", "receipt", "capabilities", "capability", "method", "target", "payload", "inputDigest", "resource", "transport", "source", "worker", "outcome", "outcomeReason", "promotionId", "ticketStatus", "issueUpdate", "result", "actor"];
 export type NumberField = (typeof numberFields)[number];
 export type TextField = (typeof textFields)[number];
 export type AuthorityCommand = {
@@ -48,7 +48,7 @@ export type AuthorityCommand = {
     readonly commandId: string;
     readonly runId: string;
 } & Readonly<Partial<Record<NumberField, number>>> & Readonly<Partial<Record<TextField, string>>>;
-export type Move = Exclude<EventType, "run.created" | "step.dispatched" | "gate.wait-registered" | "run.observed" | "effect.requested" | "lease.granted" | "lease.expired" | "effect.reported" | "operation.reconciled">;
+export type Move = Exclude<EventType, "run.created" | "step.dispatched" | "gate.wait-registered" | "run.observed" | "effect.requested" | "lease.granted" | "lease.expired" | "effect.reported" | "operation.reconciled" | "schedule.skipped">;
 export declare const terminal: readonly RunStatus[];
 export type Transition = {
     readonly kind: "moved";

package/dist/src/authority/transitions.js

@@ -17,9 +17,11 @@ export const eventTypes = [
     "lease.expired",
     "effect.reported",
     "operation.reconciled",
+    "schedule.skipped",
 ];
 export const numberFields = [
     "expectedRevision",
+    "expectedObservation",
     "generation",
     "attempt",
     "limit",
@@ -29,16 +31,19 @@ export const numberFields = [
     "leaseGeneration",
     "sourceGeneration",
     "capacity",
+    "slot",
 ];
 export const textFields = [
     "parentRunId",
     "chainId",
     "workflow",
+    "workflowId",
     "submission",
     "input",
     "resolver",
     "gateId",
     "gateKind",
+    "waitMode",
     "subject",
     "prompt",
     "expiresAt",
@@ -66,6 +71,7 @@ export const textFields = [
     "ticketStatus",
     "issueUpdate",
     "result",
+    "actor",
 ];
 export const terminal = [
     "completed",

package/dist/src/broker/actor/authority-delivery.js

@@ -8,6 +8,7 @@ import { pinned } from "./pin-check.js";
 const eligibleStatus = {
     "start-run": "queued",
     "continue-run": "running",
+    "resume-hook": "running",
 };
 function admission(parts, attempt) {
     const { intent, effectId } = attempt;

package/dist/src/broker/actor/authority-queries.d.ts

@@ -1,5 +1,6 @@
 import type { Database } from "solid-objects";
-import type { AuthorityCommand, AuthorityEvent } from "../../authority/transitions.ts";
+import type { ExecutionManifest } from "../../workflow-admission.ts";
+import type { AuthorityCommand, AuthorityEvent, RunState } from "../../authority/transitions.ts";
 import { type SqlConnection } from "../../storage/domain-rows.ts";
 import { type RunLinks, type RunOrigins } from "../../authority/handoff-chain.ts";
 export interface CommandRecord {
@@ -31,7 +32,12 @@ export interface CompletionCursor {
     readonly atOrBefore: number;
     readonly terminal?: boolean;
 }
+export interface RunRecord extends RunState {
+    readonly sequence: number;
+}
 export interface AuthorityQueries {
+    readonly run: (runId: string) => Promise<RunRecord | undefined>;
+    readonly manifest: (runId: string) => Promise<ExecutionManifest | undefined>;
     readonly document: (digest: string) => Promise<string | undefined>;
     readonly receipt: (commandId: string) => Promise<CommandRecord | undefined>;
     readonly eventsAfter: (cursor: EventCursor) => Promise<EventPage>;

package/dist/src/broker/actor/authority-queries.js

@@ -1,9 +1,17 @@
+import { readExecutionManifest } from "../../execution-pin.js";
 import { parseCommand } from "../../authority/commands.js";
 import { documentBody } from "../../storage/decision-rows.js";
-import { integer, optionalText, latestSequence, text, } from "../../storage/domain-rows.js";
-import { storedEvents } from "../authority-restore.js";
+import { integer, optionalText, latestSequence, runRow, text, } from "../../storage/domain-rows.js";
+import { storedEvents, storedRun } from "../authority-restore.js";
 import { documentDigest } from "../decision-restore.js";
 import { runLinks, } from "../../authority/handoff-chain.js";
+async function run(connection, runId) {
+    const row = await connection.get("SELECT run_id, status, revision, workflow, paused_from, gates, sequence FROM runs WHERE run_id = ?", [runId]);
+    if (row === undefined)
+        return undefined;
+    const record = runRow(row);
+    return { ...storedRun(record), sequence: record.sequence };
+}
 async function runOrigins(connection, cursor) {
     const rows = await connection.all("SELECT run_id, json_extract(payload, '$.parentRunId') AS parent_run_id, coalesce(json_extract(payload, '$.chainId'), run_id) AS chain_id FROM events WHERE type = 'run.created' AND sequence > ? AND sequence <= ? ORDER BY sequence", [cursor.after, cursor.through]);
     return Object.fromEntries(rows.map((row) => [
@@ -122,6 +130,13 @@ export function authorityQueries(read) {
         return links;
     };
     return {
+        run: (runId) => read((connection) => run(connection, runId)),
+        manifest: (runId) => read(async (connection) => {
+            const row = await connection.get("SELECT d.manifest FROM runs r JOIN definitions d ON d.pin = r.workflow WHERE r.run_id = ?", [runId]);
+            return row === undefined
+                ? undefined
+                : readExecutionManifest(JSON.parse(text(row, "manifest")));
+        }),
         document: (digest) => read((connection) => documentBody(connection, digest)),
         receipt: (commandId) => read((connection) => receipt(connection, commandId)),
         eventsAfter: (cursor) => read((connection) => eventsAfter(connection, cursor)),