cloving 1.1.0 → 1.3.0

package/dist/src/authority/commands.js

@@ -1,6 +1,7 @@
 import { isTicketStatus } from "../ticket-status.js";
+import { operationScope } from "../operation-identity.js";
 import { isInstant } from "./instants.js";
-import { isBlockedReason } from "../workflow-contracts.js";
+import { isBlockedReason, isPromotionId } from "../workflow-contracts.js";
 import { numberFields, textFields, } from "./transitions.js";
 const identifier = /^[A-Za-z0-9._:/-]{1,128}$/;
 const digest = /^sha256:[0-9a-f]{64}$/;
@@ -24,12 +25,19 @@ 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: [
+            "parentRunId",
+            "chainId",
             "submission",
             "input",
             "resolver",
@@ -37,6 +45,7 @@ const shapes = {
             "capabilities",
         ],
         groups: [
+            ["parentRunId", "chainId"],
             ["submission", "input", "resolver"],
             ["effectLimit", "capabilities"],
         ],
@@ -44,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;
@@ -66,15 +77,24 @@ const shapes = {
     "resume-run": revised,
     "complete-run": {
         required: ["expectedRevision"],
-        optional: ["outcome", "outcomeReason", "ticketStatus", "issueUpdate"],
+        optional: [
+            "outcome",
+            "outcomeReason",
+            "promotionId",
+            "ticketStatus",
+            "issueUpdate",
+        ],
         validators: {
             outcome: (value) => value === "handoff_requested" || value === "blocked",
             outcomeReason: isBlockedReason,
+            promotionId: isPromotionId,
             ticketStatus: isTicketStatus,
             issueUpdate: (value) => value === "failed",
         },
         consistent: (fields) => (fields["outcomeReason"] === undefined ||
-            fields["outcome"] === "blocked") &&
+            fields["outcome"] !== undefined) &&
+            (fields["promotionId"] === undefined ||
+                fields["outcome"] === "handoff_requested") &&
             (fields["ticketStatus"] === undefined ||
                 fields["outcome"] === "handoff_requested") &&
             (fields["issueUpdate"] === undefined ||
@@ -84,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"] },
@@ -137,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",
@@ -147,7 +175,7 @@ export function parseCommand(value) {
         return null;
     const fields = Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
     const { kind, commandId, runId } = fields;
-    if (!knownKind(kind) || !isRecordKey(commandId) || !isRecordKey(runId))
+    if (!knownKind(kind) || !isCommandId(commandId) || !isRecordKey(runId))
         return null;
     if (!completeFields(kind, fields))
         return null;
@@ -237,6 +265,7 @@ export function isCapabilityList(value) {
 }
 const validators = {
     expectedRevision: positive,
+    expectedObservation: whole,
     generation: positive,
     attempt: positive,
     limit: positive,
@@ -261,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);
 }
@@ -269,3 +302,11 @@ const plainRecord = {};
 export function isRecordKey(value) {
     return isIdentifier(value) && !(value in plainRecord);
 }
+export function isCommandId(value) {
+    if (isRecordKey(value))
+        return true;
+    return (typeof value === "string" &&
+        value.startsWith("handoff:") &&
+        printable(value.slice(8)) &&
+        operationScope(value.slice(8)) !== null);
+}

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

@@ -35,6 +35,7 @@ export interface DispatchCheck {
         readonly leaseGeneration?: number;
     };
     readonly now: string;
+    readonly mode?: "retry";
 }
 export type DispatchDecision = "stale" | "withheld" | "refused" | "blocked" | "send";
 export declare function dispatchDecision(read: DispatchRead, check: DispatchCheck): DispatchDecision;

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

@@ -15,13 +15,16 @@ function bound(read, intent) {
         lease.state !== "released",
     ].every(Boolean);
 }
-function sendable(read, now) {
+function sendable(read, check) {
+    const statuses = check.mode === "retry"
+        ? ["dispatch-pending", "recovering", "blocked"]
+        : ["dispatch-pending"];
     return [
         !read.released,
         read.runStatus === "running",
-        read.operation?.status === "dispatch-pending",
+        statuses.includes(read.operation?.status ?? ""),
         read.lease?.state === "held",
-        isAfter(read.lease?.expiresAt ?? "", now),
+        isAfter(read.lease?.expiresAt ?? "", check.now),
     ].every(Boolean);
 }
 function authorized(read) {
@@ -39,7 +42,7 @@ function authorized(read) {
 export function dispatchDecision(read, check) {
     if (!bound(read, check.intent))
         return "stale";
-    if (!sendable(read, check.now))
+    if (!sendable(read, check))
         return "withheld";
     if (!authorized(read))
         return "refused";

package/dist/src/authority/events.js

@@ -1,4 +1,4 @@
-import { isRecordKey } from "./commands.js";
+import { isCommandId, isRecordKey } from "./commands.js";
 import { eventTypes } from "./transitions.js";
 export function parseEvent(value) {
     const fields = record(value);
@@ -11,7 +11,7 @@ export function parseEvent(value) {
         !Number.isSafeInteger(sequence) ||
         eventType === undefined ||
         !isRecordKey(runId) ||
-        !isRecordKey(commandId) ||
+        !isCommandId(commandId) ||
         typeof recordedAt !== "string" ||
         typeof request !== "string" ||
         !payload)

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/handoff-chain.d.ts

@@ -0,0 +1,24 @@
+export interface RunOrigin {
+    readonly parentRunId: string | null;
+    readonly chainId: string;
+}
+export type RunOrigins = Readonly<Record<string, RunOrigin>>;
+export interface RunLinks extends RunOrigin {
+    readonly childRunIds: readonly string[];
+}
+export declare function linksOf(run: {
+    readonly runId: string;
+} & Partial<RunLinks>): RunLinks;
+export declare function runLinks(origins: RunOrigins): Readonly<Record<string, RunLinks>>;
+export declare function childRuns(origins: RunOrigins): Readonly<Record<string, readonly string[]>>;
+export type HandoffChain = {
+    readonly kind: "root";
+} | {
+    readonly kind: "handoff";
+    readonly parentRunId: string;
+    readonly chainId: string;
+} | {
+    readonly kind: "refused";
+    readonly reason: string;
+};
+export declare function handoffChain(commandId: string, origins: RunOrigins): HandoffChain;

package/dist/src/authority/handoff-chain.js

@@ -0,0 +1,46 @@
+import { operationScope } from "../operation-identity.js";
+export function linksOf(run) {
+    return {
+        parentRunId: run.parentRunId ?? null,
+        chainId: run.chainId ?? run.runId,
+        childRunIds: run.childRunIds ?? [],
+    };
+}
+export function runLinks(origins) {
+    const children = childRuns(origins);
+    return Object.fromEntries(Object.entries(origins).map(([runId, origin]) => [
+        runId,
+        {
+            ...origin,
+            childRunIds: children[runId] ?? [],
+        },
+    ]));
+}
+export function childRuns(origins) {
+    const children = {};
+    for (const [runId, origin] of Object.entries(origins)) {
+        if (origin.parentRunId === null)
+            continue;
+        const siblings = children[origin.parentRunId] ?? [];
+        siblings.push(runId);
+        children[origin.parentRunId] = siblings;
+    }
+    return children;
+}
+export function handoffChain(commandId, origins) {
+    if (!commandId.startsWith("handoff:"))
+        return { kind: "root" };
+    const parentRunId = operationScope(commandId.slice(8))?.run;
+    const parent = parentRunId === undefined ? undefined : origins[parentRunId];
+    if (parent === undefined || parentRunId === undefined)
+        return { kind: "refused", reason: "unknown-handoff-parent" };
+    let current = parent;
+    for (let length = 1; current !== undefined; length += 1) {
+        if (length >= 5)
+            return { kind: "refused", reason: "chain-limit" };
+        if (current.parentRunId === null)
+            return { kind: "handoff", parentRunId, chainId: parent.chainId };
+        current = origins[current.parentRunId];
+    }
+    return { kind: "refused", reason: "unknown-handoff-parent" };
+}

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/reconciliation.d.ts

@@ -4,6 +4,7 @@ export interface WorldRun {
     readonly receipt: string;
     readonly status: string;
     readonly outcome?: string;
+    readonly promotionId?: string;
     readonly outcomeReason?: string;
     readonly issueUpdate?: "failed";
     readonly ticketStatus?: "complete" | "partial";

package/dist/src/authority/reconciliation.js

@@ -1,6 +1,6 @@
 import { isTicketStatus } from "../ticket-status.js";
 import { gateContinuation } from "./gate-reduction.js";
-import { isBlockedReason } from "../workflow-contracts.js";
+import { isBlockedReason, isPromotionId } from "../workflow-contracts.js";
 import { continues } from "./gates.js";
 import { startOperation } from "./reduction.js";
 import { terminal, } from "./transitions.js";
@@ -111,19 +111,26 @@ function moved(kind, observed) {
 }
 function completionOutcome(world) {
     const { outcome, outcomeReason } = world;
-    if (outcome !== "handoff_requested" && outcome !== "blocked")
-        return {};
-    if (outcome !== "blocked" || !isBlockedReason(outcomeReason))
+    if (outcome === "blocked")
         return {
             outcome,
-            ...(outcome === "handoff_requested" && world.issueUpdate === "failed"
-                ? { issueUpdate: world.issueUpdate }
-                : {}),
-            ...(outcome === "handoff_requested" && isTicketStatus(world.ticketStatus)
-                ? { ticketStatus: world.ticketStatus }
-                : {}),
+            ...(isBlockedReason(outcomeReason) ? { outcomeReason } : {}),
         };
-    return { outcome, outcomeReason };
+    if (outcome !== "handoff_requested")
+        return {};
+    return {
+        outcome,
+        ...(isBlockedReason(outcomeReason) ? { outcomeReason } : {}),
+        ...(isPromotionId(world.promotionId)
+            ? { promotionId: world.promotionId }
+            : {}),
+        ...(world.issueUpdate === "failed"
+            ? { issueUpdate: world.issueUpdate }
+            : {}),
+        ...(isTicketStatus(world.ticketStatus)
+            ? { ticketStatus: world.ticketStatus }
+            : {}),
+    };
 }
 function noted(observed, evidence) {
     const { run, world, reason } = observed;

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 ["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", "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,14 +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",
@@ -60,9 +67,11 @@ export const textFields = [
     "worker",
     "outcome",
     "outcomeReason",
+    "promotionId",
     "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;