@hasna/skills 0.1.62 → 0.1.64

package/dist/sdk/cancel.d.ts

@@ -0,0 +1,30 @@
+import type { ApiPrincipal, ServerArtifact, ServerRunRecord, SkillsProductStore } from "../server/types.js";
+import type { GovernanceStore, LifecycleReceipt } from "./governance-store.js";
+import type { RunObjectStore } from "./outputs.js";
+export interface CancelOutcome {
+    run: ServerRunRecord;
+    /** The generation the cancellation fenced. */
+    fencedGeneration: number;
+    /** Artifacts moved to the quarantine prefix (or recorded for quarantine). */
+    quarantined: ServerArtifact[];
+    receipt: LifecycleReceipt;
+    /** True when the run was already terminal and cancellation was a no-op. */
+    alreadyTerminal: boolean;
+}
+export interface CancelServiceOptions {
+    store: SkillsProductStore;
+    governanceStore: GovernanceStore;
+    storage?: RunObjectStore;
+}
+export interface CancelService {
+    cancel(principal: ApiPrincipal, runId: string, requestedBy: string): Promise<CancelOutcome>;
+}
+/**
+ * Build the cancel service.
+ *
+ * Requires a store that implements transitionRun (generation fencing). A store
+ * without one cannot cancel safely - an unfenced cancel would let the worker's
+ * late write move a cancelled run back to succeeded - so the service refuses
+ * with FENCING_UNSUPPORTED rather than pretending.
+ */
+export declare function createCancelService(options: CancelServiceOptions): CancelService;

package/dist/sdk/dispatcher.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Dispatcher adapter seam: how admitted runs leave this process.
+ *
+ * The interface is the contract — submit a run, cancel a run. The ECS adapter
+ * is the real implementation (execution/dispatchers/ecs.ts): CAS-claimed
+ * attempts, persisted launch intents, deterministic RunTask clientTokens, and
+ * lost-response reconciliation. The E2B lane is a typed stub pending the
+ * infinity integration.
+ *
+ * submit() takes the EXECUTION-domain admission (`FrozenAdmission`), whose
+ * `runId` (`run_<ts>_<hex>`) is the execution store's own key — NOT the
+ * server run record (`ServerRunRecord.id`, a UUID), which the execution store
+ * cannot resolve and would silently no-admit. Intended wiring: the
+ * POST /api/v1/runs handler creates a server run through `store.createRun`
+ * (billing/audit record, UUID id); the execution lane bridges it to this seam
+ * through `createSubmitRunService` (idempotent admission), which mints or
+ * returns the `FrozenAdmission`; then `dispatcher.submit(admission)` launches
+ * it. The bridge is mandatory — passing a server record here is a type error.
+ */
+import type { FrozenAdmission } from "./execution/types.js";
+import { EcsDispatcher, E2bDispatcher } from "./execution/index.js";
+export { EcsDispatcher, E2bDispatcher };
+export type { EcsDispatcherConfig, EcsDispatcherOptions, EcsRunTaskClient, EcsRunTaskInput, EcsRunTaskResult, EcsTaskState, LaunchOutcome } from "./execution/dispatchers/ecs.js";
+/** Outcome of a dispatch attempt. */
+export interface DispatchResult {
+    accepted: boolean;
+    /** Where the run was dispatched to, when known. */
+    target?: string;
+    /** Human-readable detail, credential-free. */
+    detail?: string;
+}
+/** A dispatcher takes admitted execution runs and puts them in front of an executor. */
+export interface Dispatcher {
+    submit(run: FrozenAdmission): Promise<DispatchResult>;
+    cancel(runId: string): Promise<DispatchResult>;
+}
+/** Raised by adapters whose launch machinery is not implemented yet. */
+export declare class DispatcherNotImplementedError extends Error {
+    constructor(adapter: string, capability: string);
+}

package/dist/sdk/event-sink.d.ts

@@ -0,0 +1,2 @@
+import type { RunEventSink } from "./events.js";
+export declare function defaultEventsSink(): RunEventSink;

package/dist/sdk/events.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Run lifecycle events through @hasna/events — bounded metadata and stable
+ * pointers ONLY.
+ *
+ * The boundary is structural: buildRunLifecycleEvent starts from an allowlist
+ * of fields (run_id, skill, version, status, timestamps, correlation_id,
+ * attempt/lease pointers) and validateRunLifecycleEvent refuses anything else
+ * before it can be emitted - unknown keys, nested payloads, and any value that
+ * matches the credential patterns. Raw logs, artifact payloads, and inputs
+ * cannot reach the event bus by construction, and the negative fixture proves
+ * the guard fires rather than being asserted by prose.
+ */
+import { type EventEnvelope } from "@hasna/events";
+import type { ServerRunRecord } from "../server/types.js";
+export declare const RUN_LIFECYCLE_EVENT_TYPES: readonly ["skills.run.admitted", "skills.run.started", "skills.run.terminal", "skills.run.cancelled"];
+export type RunLifecycleEventType = (typeof RUN_LIFECYCLE_EVENT_TYPES)[number];
+/**
+ * The full allowlist of data fields a run lifecycle event may carry.
+ *
+ * Every field is either a stable pointer or bounded metadata. Anything not in
+ * this list is a payload violation; any value matching the redaction patterns
+ * is a secret leak. Both checks run before emission.
+ */
+export declare const RUN_LIFECYCLE_EVENT_FIELDS: readonly ["run_id", "attempt_id", "lease_generation", "correlation_id", "skill", "version", "status", "at"];
+export interface RunLifecycleEventData {
+    run_id: string;
+    attempt_id: string;
+    lease_generation: number;
+    correlation_id?: string;
+    skill: string;
+    version?: string;
+    status: string;
+    at: string;
+    /**
+     * @hasna/events constrains event data to Record<string, unknown>. The index
+     * signature is required to satisfy it; the RUNTIME allowlist is the guard
+     * that actually bounds the payload (see RUN_LIFECYCLE_EVENT_FIELDS and
+     * validateRunLifecycleEvent) - this type cannot be the fence, only the
+     * shape of the legitimate payload.
+     */
+    [key: string]: unknown;
+}
+/** Build a bounded lifecycle event envelope for a run state. Never carries inputs, logs, or payloads. */
+export declare function buildRunLifecycleEvent(type: RunLifecycleEventType, run: Pick<ServerRunRecord, "id" | "skill" | "status" | "correlationId" | "leaseGeneration" | "createdAt" | "completedAt">, options?: {
+    version?: string;
+    at?: string;
+    source?: string;
+}): EventEnvelope<RunLifecycleEventData>;
+/**
+ * Refuse any event payload that is not bounded metadata + stable pointers.
+ *
+ * Rejects, with EVENT_PAYLOAD_REJECTED:
+ *   - unknown top-level data keys (an input, a log array, an artifact body);
+ *   - non-scalar values outside the allowlist;
+ *   - any value whose text matches the credential patterns.
+ */
+export declare function validateRunLifecycleEvent(event: EventEnvelope<RunLifecycleEventData>): void;
+/** A sink for lifecycle events; swap in a recording sink in tests. */
+export type RunEventSink = (event: EventEnvelope<RunLifecycleEventData>) => Promise<void>;
+export interface RunEventEmitterOptions {
+    /** Emission sink. Defaults to @hasna/events' EventsClient over a JsonEventsStore. */
+    sink?: RunEventSink;
+    versionFor?: (run: Pick<ServerRunRecord, "skill">) => Promise<string | undefined>;
+    /** When false (default), a sink failure is reported but never fails the run transition. */
+    failOpen?: boolean;
+}
+export interface RunEventEmitter {
+    emit(type: RunLifecycleEventType, run: ServerRunRecord): Promise<void>;
+}
+/**
+ * Emit one validated lifecycle event.
+ *
+ * Validation is mandatory and runs before the sink is touched; a payload that
+ * fails validation throws EVEN when failOpen is set - a secret must never be
+ * dropped into a fail-open hole. Sink failures (an unreachable events store)
+ * are reported via the returned boolean / an optional error and do not fail
+ * the run itself, because a run that succeeded is still a run that succeeded.
+ */
+export declare function createRunEventEmitter(options?: RunEventEmitterOptions): RunEventEmitter;

package/dist/sdk/execution/admission.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Idempotent admission: the submitRun service.
+ *
+ * Every input that must not change between attempts is frozen into the
+ * admission record under one stable run_id: tenant, skill id + version,
+ * canonical bundle digest, runtime-image digest, input digest, and the policy
+ * + limits the run executes under. A duplicate submission — same
+ * Idempotency-Key, or the same (tenant, skill, version, bundle digest, input
+ * digest) tuple — returns the existing run instead of minting a second one.
+ */
+import type { ImageProfileRegistry } from "./image-profile.js";
+import type { RunExecutionStore } from "./storage.js";
+import { type FrozenAdmission, type RunLimits, type RunPolicy, type RuntimeName } from "./types.js";
+export interface SubmitRunInput {
+    tenantId: string;
+    skillId: string;
+    skillVersion: string;
+    /** Canonical sha256 of the skill bundle. */
+    bundleDigest: string;
+    input: unknown;
+    idempotencyKey: string;
+    runtime: RuntimeName;
+    /** system_deps declared by the skill manifest. */
+    systemDeps?: string[];
+    policy?: Partial<RunPolicy>;
+    limits?: Partial<RunLimits>;
+}
+export interface SubmitRunResult {
+    run: FrozenAdmission;
+    created: boolean;
+}
+export declare const DEFAULT_RUN_POLICY: RunPolicy;
+export declare const DEFAULT_RUN_LIMITS: RunLimits;
+export interface SubmitRunService {
+    submit(input: SubmitRunInput): Promise<SubmitRunResult>;
+}
+export interface SubmitRunServiceOptions {
+    store: RunExecutionStore;
+    imageProfiles: ImageProfileRegistry;
+    now?: () => Date;
+}
+export declare function createSubmitRunService(options: SubmitRunServiceOptions): SubmitRunService;
+/** Canonical digest of a run input: stable serialization, sha256. */
+export declare function digestInput(input: unknown): string;

package/dist/sdk/execution/dispatchers/e2b.d.ts

@@ -0,0 +1,17 @@
+/**
+ * E2B-lane dispatcher stub.
+ *
+ * Implements the sdk `Dispatcher` interface with submit/cancel typed and
+ * present, but the launch machinery is NOT built: the latency-sensitive E2B
+ * lane is a TODO for the infinity integration (plan P5: "Fargate RunTask
+ * first, E2B second"). Every call fails closed with `accepted: false` — a
+ * run is never reported as dispatched by a lane that cannot dispatch it.
+ */
+import type { DispatchResult, Dispatcher } from "../../dispatcher.js";
+import type { FrozenAdmission } from "../types.js";
+/** Marker so callers and tests can detect the unimplemented lane by type. */
+export declare const E2B_LANE_STATUS: "e2b-lane-todo-infinity";
+export declare class E2bDispatcher implements Dispatcher {
+    submit(_run: FrozenAdmission): Promise<DispatchResult>;
+    cancel(_runId: string): Promise<DispatchResult>;
+}

package/dist/sdk/execution/dispatchers/ecs.d.ts

@@ -0,0 +1,151 @@
+/**
+ * ECS dispatcher adapter.
+ *
+ * Implements the sdk `Dispatcher` interface (submit/cancel) with the launch
+ * machinery the interface seam leaves to this module:
+ *
+ *  1. CAS-claim the next attempt's `attempt_id` + `lease_generation`
+ *     (stale generation rejected),
+ *  2. persist the launch intent (clientToken, startedBy, request digest)
+ *     BEFORE calling ECS,
+ *  3. call RunTask with a deterministic clientToken derived from
+ *     (run_id, attempt_id) and an immutable request digest,
+ *  4. on a lost RunTask response, reconcile the SAME token — list tasks by
+ *     startedBy, describe them — before any new attempt; a new attempt is
+ *     forbidden until the previous launch is proven absent or terminal.
+ *
+ * The AWS SDK is never called from tests: the `EcsRunTaskClient` interface is
+ * the seam, `createAwsEcsClient` is the only place the real SDK is imported,
+ * and every test injects a mock client.
+ *
+ * Nothing here names a concrete cluster, task definition, subnet, or account:
+ * all infrastructure identifiers come from configuration (R4).
+ */
+import type { DispatchResult, Dispatcher } from "../../dispatcher.js";
+import type { RunExecutionStore } from "../storage.js";
+import type { AttemptRecord, FrozenAdmission } from "../types.js";
+import { type RunStateMachine } from "../state-machine.js";
+import { type ReceiptService } from "../receipts.js";
+/** ClientToken bound: ECS RunTask accepts up to 32 ASCII characters. */
+export declare const CLIENT_TOKEN_BYTES = 16;
+export interface EcsTaskState {
+    taskArn: string;
+    lastStatus: string;
+    /** Set when the task reached a terminal status. */
+    stopCode?: string | null;
+    exitCode?: number | null;
+}
+export interface EcsRunTaskInput {
+    cluster: string;
+    taskDefinition: string;
+    containerName: string;
+    clientToken: string;
+    startedBy: string;
+    launchType: "FARGATE";
+    cpu: string;
+    memory: string;
+    subnets: string[];
+    securityGroups: string[];
+    environment: {
+        name: string;
+        value: string;
+    }[];
+}
+export interface EcsRunTaskResult {
+    taskArn: string;
+}
+/** The seam every test mocks; the real implementation lives in createAwsEcsClient. */
+export interface EcsRunTaskClient {
+    runTask(input: EcsRunTaskInput): Promise<EcsRunTaskResult>;
+    /** Task arns launched with a given startedBy token. */
+    listTasksByStartedBy(startedBy: string): Promise<string[]>;
+    describeTasks(taskArns: string[]): Promise<EcsTaskState[]>;
+    stopTask(taskArn: string): Promise<void>;
+}
+export interface EcsDispatcherConfig {
+    cluster: string;
+    taskDefinition: string;
+    containerName: string;
+    subnets: string[];
+    securityGroups: string[];
+    region: string;
+}
+export interface EcsDispatcherOptions {
+    store: RunExecutionStore;
+    stateMachine?: RunStateMachine;
+    receipts?: ReceiptService;
+    /** Claim identity; defaults to "dispatcher". */
+    workerId?: string;
+    now?: () => Date;
+}
+export type LaunchOutcome = {
+    kind: "launched";
+    attemptId: string;
+    taskId: string;
+} | {
+    kind: "already-launched";
+    attemptId: string;
+    taskId: string;
+} | {
+    kind: "previous-terminal";
+    attemptId: string;
+} | {
+    kind: "ambiguous";
+    attemptId: string;
+} | {
+    kind: "launch-failed-absent";
+    attemptId: string;
+} | {
+    kind: "claim-refused";
+    attemptId: string;
+    reason: string;
+} | {
+    kind: "no-admission";
+} | {
+    kind: "run-terminal";
+    status: string;
+};
+/**
+ * Deterministic ECS clientToken derived from (run_id, attempt_id). Same input
+ * always yields the same token, so a retried or reconciled launch is
+ * idempotent from ECS's point of view.
+ */
+export declare function clientTokenFor(runId: string, attemptId: string): string;
+/** startedBy token, the durable handle reconciliation lists tasks by. */
+export declare function startedByFor(runId: string, attemptNumber: number): string;
+/** Immutable digest of the frozen request this attempt launches. */
+export declare function requestDigestFor(admission: FrozenAdmission, attemptId: string): string;
+export declare class EcsDispatcher implements Dispatcher {
+    private readonly config;
+    private readonly client;
+    private readonly store;
+    private readonly stateMachine;
+    private readonly receipts;
+    private readonly workerId;
+    private readonly now;
+    constructor(config: EcsDispatcherConfig, client: EcsRunTaskClient, options: EcsDispatcherOptions);
+    /** sdk Dispatcher surface: submit an ADMITTED run (execution domain) to the launch machinery. */
+    submit(run: FrozenAdmission): Promise<DispatchResult>;
+    /** sdk Dispatcher surface: fence the current generation and stop the task. */
+    cancel(runId: string): Promise<DispatchResult>;
+    /**
+     * Launch the next attempt of a run.
+     *
+     * A previous attempt whose launch outcome is unknown (launching / ambiguous /
+     * launched) is reconciled FIRST. Only when the previous launch is proven
+     * absent or terminal is a new attempt minted and claimed.
+     */
+    launchAttempt(runId: string): Promise<LaunchOutcome>;
+    /** Reconcile an attempt whose launch outcome is unknown. */
+    reconcile(admission: FrozenAdmission, attempt: AttemptRecord): Promise<LaunchOutcome>;
+    /** Resolve the task arn for the current attempt, reconciling if needed. */
+    private resolveTaskArn;
+    private runTaskInput;
+    private writeCancellationReceipt;
+}
+/**
+ * The one place the real AWS SDK is wired in. Returns a client bound to the
+ * configured region; credentials resolve through the standard SDK chain.
+ * Tests never construct this — they inject a mock `EcsRunTaskClient`.
+ */
+export declare function createAwsEcsClient(region: string): EcsRunTaskClient;

package/dist/sdk/execution/image-profile.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Immutable image profiles.
+ *
+ * A run's image is the union of (a) a pinned runtime image — bun, node, or
+ * python3 at an exact version, carrying the supervisor and NO skills corpus;
+ * the bundle is fetched by digest at run time — and (b) an optional prebuilt
+ * dependency layer built at publish time when the skill manifest's
+ * `system_deps` are allowlisted. Nothing is installed at execution time.
+ *
+ * Version pins live in code; image digests and the system_deps allowlist are
+ * deployment configuration, because a digest names a concrete artifact in a
+ * concrete registry. An un-pinned runtime or an unknown system_deps entry
+ * fails closed at admission — a launch never carries a guess.
+ */
+import type { FrozenAdmission, RuntimeName } from "./types.js";
+export type { RuntimeName };
+export interface PinnedRuntime {
+    runtime: RuntimeName;
+    /** Exact pinned runtime version. */
+    version: string;
+    /** Image digest; null until deployment config supplies one. */
+    imageDigest: string | null;
+}
+export interface DependencyLayerRule {
+    /** Canonical system_deps key: sorted, unique, comma-joined. */
+    canonicalKey: string;
+    /** Prebuilt layer tag produced at publish time. */
+    layerTag: string;
+}
+export interface ImageProfileRegistryConfig {
+    runtimes: PinnedRuntime[];
+    /** system_deps allowlist: canonical key -> prebuilt layer tag. */
+    dependencyLayers: Record<string, string>;
+}
+export interface ResolvedImageProfile {
+    runtime: PinnedRuntime;
+    runtimeImageDigest: string;
+    dependencyLayerTag: string | null;
+}
+export type ImageProfileResolutionFailure = {
+    reason: "UNKNOWN_RUNTIME";
+    runtime: string;
+} | {
+    reason: "UNPINNED_RUNTIME";
+    runtime: RuntimeName;
+} | {
+    reason: "UNALLOWED_SYSTEM_DEPS";
+    systemDeps: string[];
+};
+export declare class ImageProfileResolutionError extends Error {
+    readonly failure: ImageProfileResolutionFailure;
+    constructor(failure: ImageProfileResolutionFailure);
+}
+/**
+ * Pinned runtime versions. These match what the package itself is built with
+ * (bun 1.3.14) plus the node and python lines the corpus's runtime contracts
+ * name. Digests are deployment configuration and start null: admission refuses
+ * an unpinned launch.
+ */
+export declare const DEFAULT_IMAGE_PROFILES: ImageProfileRegistryConfig;
+export interface ImageProfileRegistry {
+    resolve(runtime: RuntimeName, systemDeps: string[]): ResolvedImageProfile;
+}
+export declare function createImageProfileRegistry(config?: ImageProfileRegistryConfig): ImageProfileRegistry;
+/** Canonical system_deps key: sorted, unique, comma-joined. */
+export declare function canonicalSystemDepsKey(systemDeps: string[]): string;
+/** Build an allowlist entry from a manifest's declared system_deps. */
+export declare function dependencyLayerRule(layerTag: string, systemDeps: string[]): DependencyLayerRule;
+/** Resolve + freeze the image half of an admission. */
+export declare function resolveImageProfile(registry: ImageProfileRegistry, input: {
+    runtime: RuntimeName;
+    systemDeps: string[];
+}): Pick<FrozenAdmission, "runtime" | "runtimeImageDigest" | "dependencyLayerTag">;

package/dist/sdk/execution/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Cloud-run execution machinery, exported through the sdk surface.
+ *
+ * Idempotent admission, the run state machine (admitted → leased → running →
+ * terminal), the immutable image-profile registry, per-attempt receipts, and
+ * the dispatcher adapters (ECS with atomic-launch reconciliation, E2B stub).
+ */
+export * from "./types.js";
+export * from "./storage.js";
+export * from "./admission.js";
+export * from "./state-machine.js";
+export * from "./image-profile.js";
+export * from "./receipts.js";
+export * from "./dispatchers/ecs.js";
+export * from "./dispatchers/e2b.js";

package/dist/sdk/execution/receipts.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Per-attempt receipts.
+ *
+ * Every attempt gets an immutable receipt: run_id, attempt_id,
+ * lease_generation, launch token (clientToken + startedBy), task id,
+ * timestamps, image + bundle digests, the frozen policy, and — once the
+ * attempt reaches a terminal outcome — exit code and artifact/log pointers.
+ * Receipts are written through the storage adapter; the terminal receipt
+ * finalizes the run row.
+ */
+import type { RunExecutionStore } from "./storage.js";
+import type { AttemptReceipt, AttemptRecord, FrozenAdmission, TerminalRunStatus } from "./types.js";
+export type { AttemptReceipt };
+export interface CreateAttemptReceiptInput {
+    admission: FrozenAdmission;
+    attempt: AttemptRecord;
+    /** ECS task arn, when the launch is confirmed. */
+    taskId: string | null;
+    launchedAt: string;
+    artifactPointers?: string[];
+    logPointers?: string[];
+}
+export interface FinalizeAttemptReceiptInput {
+    runId: string;
+    attemptId: string;
+    status: TerminalRunStatus;
+    exitCode: number | null;
+    completedAt: string;
+    artifactPointers?: string[];
+    logPointers?: string[];
+    costCents?: number | null;
+}
+export interface ReceiptService {
+    /** Persist the launch-time receipt before (or right after) the launch call. */
+    recordLaunch(input: CreateAttemptReceiptInput): Promise<AttemptReceipt>;
+    /** Finalize the attempt's receipt; also finalizes the run row. */
+    finalize(input: FinalizeAttemptReceiptInput): Promise<{
+        receipt: AttemptReceipt | null;
+        runId: string;
+        status: TerminalRunStatus;
+    }>;
+    get(runId: string, attemptId: string): Promise<AttemptReceipt | null>;
+}
+export declare function createReceiptService(store: RunExecutionStore): ReceiptService;

package/dist/sdk/execution/state-machine.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Run state machine: admitted → leased → running → terminal.
+ *
+ * Every transition is recorded through the storage adapter. Claims are CAS on
+ * the attempt's lease_generation; a stale claim is rejected. Retries keep the
+ * run_id and mint a new attempt_id with a fresh lease_generation counter.
+ */
+import type { ClaimAttemptInput, ClaimResult, ExecutionRunStatus, RunExecutionStore } from "./storage.js";
+import type { TerminalRunStatus } from "./types.js";
+export type { ClaimResult };
+/** The only legal edges of the state machine. */
+export declare const LEGAL_TRANSITIONS: Record<ExecutionRunStatus, ExecutionRunStatus[]>;
+export type TransitionFailure = "NO_SUCH_RUN" | "NO_SUCH_ATTEMPT" | "INVALID_TRANSITION" | "ATTEMPT_TERMINAL" | "RUN_TERMINAL" | "RUN_CANCELLED";
+export type TransitionResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: TransitionFailure;
+};
+export interface RunStateMachine {
+    /** CAS-claim an attempt: expectedLeaseGeneration must match. */
+    claim(input: ClaimAttemptInput): Promise<ClaimResult>;
+    /** admitted → leased (claim recorded as a transition). */
+    lease(input: ClaimAttemptInput): Promise<ClaimResult>;
+    /** leased → running. */
+    start(runId: string, attemptId: string): Promise<TransitionResult>;
+    /** running → terminal; finalizes the run row. */
+    terminate(input: {
+        runId: string;
+        attemptId: string;
+        status: TerminalRunStatus;
+    }): Promise<TransitionResult>;
+    /** Cancel a run: fences the current generation and moves it to terminal. */
+    cancel(runId: string): Promise<TransitionResult>;
+    transition(runId: string, from: ExecutionRunStatus, to: ExecutionRunStatus, attemptId?: string | null): Promise<TransitionResult>;
+    getStatus(runId: string): Promise<ExecutionRunStatus | null>;
+}
+export declare function createRunStateMachine(store: RunExecutionStore): RunStateMachine;