@kici-dev/engine 0.1.26 → 0.2.0

package/dist/protocol/messages/deployment-identity.d.ts

@@ -1,38 +1,65 @@
 import { z } from 'zod';
 /** How the orchestrator process itself was deployed (not how it runs agents). */
 export declare const DeploymentModeSchema: z.ZodEnum<{
-    unknown: "unknown";
-    systemd: "systemd";
+    compose: "compose";
     launchd: "launchd";
+    systemd: "systemd";
+    unknown: "unknown";
     windows: "windows";
-    compose: "compose";
 }>;
 export type DeploymentMode = z.infer<typeof DeploymentModeSchema>;
 /** Container runtime that launched a `compose`-mode orchestrator. */
 export declare const DeploymentContainerRuntimeSchema: z.ZodEnum<{
-    podman: "podman";
     docker: "docker";
+    podman: "podman";
 }>;
 export type DeploymentContainerRuntime = z.infer<typeof DeploymentContainerRuntimeSchema>;
 /**
  * The orchestrator's self-reported deployment shape, used to build the correct
- * kici-admin invocation in the dashboard diagnostics page. Container fields are
+ * kici-admin invocation in the dashboard Infrastructure page. Container fields are
  * populated only for the `compose` mode; a hand-run orchestrator reports
- * `mode: 'unknown'` with no container fields.
+ * `mode: 'unknown'` with no container fields. `adminInvocation` is the pinned
+ * `<node> <kici-admin>` invocation for posix bare-metal (`systemd` / `launchd`),
+ * set by the orchestrator from its own `process.execPath` so a copied command
+ * runs under the unit's pinned runtime rather than whatever `node` the
+ * operator's shell resolves. The orchestrator locates the shim on disk and omits
+ * the field when it cannot, so a reader may always fall back to a PATH-resolved
+ * bare `kici-admin`. It is a live-host runtime path, carried only on the
+ * in-memory identity (never persisted).
+ *
+ * The value is a shell command, not a pair of raw paths: either half is
+ * single-quoted (POSIX `'\''` escaping) when its path holds whitespace or another
+ * shell metacharacter, so it can be pasted as-is. A reader that only displays it
+ * needs no special handling; a reader that wants the shim path back out has to
+ * split it as shell words rather than on the last space.
+ *
+ * `adminPath` is the Windows counterpart and is set only for `mode: 'windows'`:
+ * the absolute path of the `kici-admin.cmd` launcher, when the orchestrator can
+ * locate it. Unlike `adminInvocation` it is a RAW path and never a command —
+ * nothing about it is quoted or escaped. That is deliberate: cmd.exe runs a
+ * double-quoted path in command position while PowerShell merely *prints* it
+ * (it needs the `&` call operator), so the same path has to be written two
+ * different ways and only the reader knows which shell it is rendering for. A
+ * producer that pre-quoted would take that choice away. It is a live-host
+ * runtime path, carried only on the in-memory identity (never persisted), and
+ * omitted when the launcher cannot be located so a reader falls back to a
+ * PATH-resolved bare `kici-admin.cmd`.
  */
 export declare const DeploymentIdentitySchema: z.ZodObject<{
     mode: z.ZodEnum<{
-        unknown: "unknown";
-        systemd: "systemd";
+        compose: "compose";
         launchd: "launchd";
+        systemd: "systemd";
+        unknown: "unknown";
         windows: "windows";
-        compose: "compose";
     }>;
     containerName: z.ZodOptional<z.ZodString>;
     containerRuntime: z.ZodOptional<z.ZodEnum<{
-        podman: "podman";
         docker: "docker";
+        podman: "podman";
     }>>;
+    adminInvocation: z.ZodOptional<z.ZodString>;
+    adminPath: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type DeploymentIdentity = z.infer<typeof DeploymentIdentitySchema>;
 //# sourceMappingURL=deployment-identity.d.ts.map

package/dist/protocol/messages/deployment-identity.js

@@ -13,14 +13,41 @@ const DeploymentModeSchema = z.enum([
 const DeploymentContainerRuntimeSchema = z.enum(["podman", "docker"]);
 /**
 * The orchestrator's self-reported deployment shape, used to build the correct
-* kici-admin invocation in the dashboard diagnostics page. Container fields are
+* kici-admin invocation in the dashboard Infrastructure page. Container fields are
 * populated only for the `compose` mode; a hand-run orchestrator reports
-* `mode: 'unknown'` with no container fields.
+* `mode: 'unknown'` with no container fields. `adminInvocation` is the pinned
+* `<node> <kici-admin>` invocation for posix bare-metal (`systemd` / `launchd`),
+* set by the orchestrator from its own `process.execPath` so a copied command
+* runs under the unit's pinned runtime rather than whatever `node` the
+* operator's shell resolves. The orchestrator locates the shim on disk and omits
+* the field when it cannot, so a reader may always fall back to a PATH-resolved
+* bare `kici-admin`. It is a live-host runtime path, carried only on the
+* in-memory identity (never persisted).
+*
+* The value is a shell command, not a pair of raw paths: either half is
+* single-quoted (POSIX `'\''` escaping) when its path holds whitespace or another
+* shell metacharacter, so it can be pasted as-is. A reader that only displays it
+* needs no special handling; a reader that wants the shim path back out has to
+* split it as shell words rather than on the last space.
+*
+* `adminPath` is the Windows counterpart and is set only for `mode: 'windows'`:
+* the absolute path of the `kici-admin.cmd` launcher, when the orchestrator can
+* locate it. Unlike `adminInvocation` it is a RAW path and never a command —
+* nothing about it is quoted or escaped. That is deliberate: cmd.exe runs a
+* double-quoted path in command position while PowerShell merely *prints* it
+* (it needs the `&` call operator), so the same path has to be written two
+* different ways and only the reader knows which shell it is rendering for. A
+* producer that pre-quoted would take that choice away. It is a live-host
+* runtime path, carried only on the in-memory identity (never persisted), and
+* omitted when the launcher cannot be located so a reader falls back to a
+* PATH-resolved bare `kici-admin.cmd`.
 */
 const DeploymentIdentitySchema = z.object({
 	mode: DeploymentModeSchema,
 	containerName: z.string().min(1).optional(),
-	containerRuntime: DeploymentContainerRuntimeSchema.optional()
+	containerRuntime: DeploymentContainerRuntimeSchema.optional(),
+	adminInvocation: z.string().min(1).optional(),
+	adminPath: z.string().min(1).optional()
 });
 //#endregion
 export { DeploymentContainerRuntimeSchema, DeploymentIdentitySchema, DeploymentModeSchema };

package/dist/protocol/messages/event-log.d.ts

@@ -16,12 +16,12 @@ import { z } from 'zod';
  *   the message.
  */
 export declare const EventLogStatus: z.ZodEnum<{
-    failed: "failed";
-    received: "received";
-    processed: "processed";
     duplicate: "duplicate";
-    lockfile_missing: "lockfile_missing";
+    failed: "failed";
     lockfile_corrupt: "lockfile_corrupt";
+    lockfile_missing: "lockfile_missing";
+    processed: "processed";
+    received: "received";
 }>;
 export type EventLogStatus = z.infer<typeof EventLogStatus>;
 /**
@@ -46,8 +46,8 @@ export type PayloadOmittedReason = z.infer<typeof PayloadOmittedReason>;
  * - `direct` — Direct HTTP ingress (independent / hybrid mode).
  */
 export declare const EventLogSource: z.ZodEnum<{
-    relay: "relay";
     direct: "direct";
+    relay: "relay";
 }>;
 export type EventLogSource = z.infer<typeof EventLogSource>;
 //# sourceMappingURL=event-log.d.ts.map

package/dist/protocol/messages/execution-status.d.ts

@@ -11,8 +11,8 @@ export declare const STATE_REPLAY_MAX_RUNS = 500;
 export declare const MAX_JOBS_PER_RUN = 1000;
 /** Max number of `runsOn` / `secretsAccessed` label entries on a job/step. */
 export declare const RUNS_ON_LABELS_MAX = 30;
-/** Max number of bound deployment-environment names on a job. */
-export declare const ENVIRONMENTS_MAX = 30;
+/** Max number of bound context names on a job. */
+export declare const CONTEXTS_MAX = 30;
 /**
  * Status values for execution runs (execution_runs table).
  *
@@ -24,28 +24,37 @@ export declare const ENVIRONMENTS_MAX = 30;
  * transitions to `cancelled`.
  */
 export declare const ExecutionRunStatus: z.ZodEnum<{
-    success: "success";
-    pending: "pending";
-    running: "running";
-    failed: "failed";
     cancelled: "cancelled";
     cancelling: "cancelling";
+    failed: "failed";
     held: "held";
+    pending: "pending";
+    running: "running";
+    success: "success";
 }>;
 export type ExecutionRunStatus = z.infer<typeof ExecutionRunStatus>;
-/** Status values for execution jobs (execution_jobs table + job.status protocol messages). */
+/**
+ * Status values for execution jobs (execution_jobs table + job.status protocol messages).
+ *
+ * `unroutable` = the job's `runsOn` matched no agent for the whole queue
+ * window, so it never ran. Distinct from `failed` (a failed job ran and has
+ * logs to read; an unroutable one has a fleet/label problem to fix), from
+ * `skipped` (a condition deliberately excluded it) and from `timed_out_stale`
+ * (capacity existed but never freed up).
+ */
 export declare const ExecutionJobStatus: z.ZodEnum<{
-    skipped: "skipped";
-    success: "success";
-    pending: "pending";
-    running: "running";
-    failed: "failed";
     cancelled: "cancelled";
     cancelling: "cancelling";
+    drift_dropped: "drift_dropped";
+    failed: "failed";
+    pending: "pending";
     queued: "queued";
     recovering: "recovering";
+    running: "running";
+    skipped: "skipped";
+    success: "success";
     timed_out_stale: "timed_out_stale";
-    drift_dropped: "drift_dropped";
+    unroutable: "unroutable";
 }>;
 export type ExecutionJobStatus = z.infer<typeof ExecutionJobStatus>;
 /**
@@ -65,12 +74,12 @@ export declare function statusOptionsForLevel(level: 'run' | 'job'): readonly st
  *  - `cancelled` — a parallel-group sibling aborted by fail-fast (NOT a failure).
  */
 export declare const ExecutionStepStatus: z.ZodEnum<{
-    skipped: "skipped";
-    success: "success";
+    cancelled: "cancelled";
+    failed: "failed";
     pending: "pending";
     running: "running";
-    failed: "failed";
-    cancelled: "cancelled";
+    skipped: "skipped";
+    success: "success";
 }>;
 export type ExecutionStepStatus = z.infer<typeof ExecutionStepStatus>;
 /**
@@ -83,9 +92,9 @@ export type ExecutionStepStatus = z.infer<typeof ExecutionStepStatus>;
  *                       only for the dashboard band aggregate, not persisted per step.
  */
 export declare const StepConcurrencyKind: z.ZodEnum<{
-    sequential: "sequential";
     "parallel-child": "parallel-child";
     "parallel-group": "parallel-group";
+    sequential: "sequential";
 }>;
 export type StepConcurrencyKind = z.infer<typeof StepConcurrencyKind>;
 /**
@@ -115,21 +124,45 @@ export type TimeoutReason = z.infer<typeof TimeoutReason>;
  * Scope is carried separately on `initFailureSchema.scope`:
  *  - `run`-scoped categories fail the whole run before any job runs
  *    (secret_resolution, install_secrets, lock_resolution,
- *    build_coordination).
+ *    build_coordination, approval_misconfig, sandbox_denied, trust_policy).
  *  - `job`-scoped categories fail one job and leave siblings alone
- *    (environment_rules, dynamic_eval, no_agent, matrix_expansion).
+ *    (context_rules, dynamic_eval, no_agent, matrix_expansion).
  */
 export declare const InitFailureCategory: z.ZodEnum<{
-    secret_resolution: "secret_resolution";
-    install_secrets: "install_secrets";
-    lock_resolution: "lock_resolution";
+    approval_misconfig: "approval_misconfig";
     build_coordination: "build_coordination";
-    environment_rules: "environment_rules";
+    context_rules: "context_rules";
     dynamic_eval: "dynamic_eval";
-    no_agent: "no_agent";
+    install_secrets: "install_secrets";
+    lock_resolution: "lock_resolution";
     matrix_expansion: "matrix_expansion";
+    no_agent: "no_agent";
+    sandbox_denied: "sandbox_denied";
+    secret_resolution: "secret_resolution";
+    trust_policy: "trust_policy";
 }>;
 export type InitFailureCategory = z.infer<typeof InitFailureCategory>;
+/**
+ * Why a terminal run failed (only meaningful for failed/cancelled runs):
+ *  - never_started     — init failure (no_agent/secret/lock/build); no step ran.
+ *  - timed_out         — a job timed out (never dispatched, or agent went silent).
+ *  - dead_orchestrator — the Platform failed the run because its orchestrator died.
+ *  - step_failure      — a job actually ran and failed.
+ *  - cancelled         — the run was cancelled.
+ *
+ * Derived at run completion from the terminal job statuses, because
+ * `timed_out`/`step_failure` both collapse to run-status `failed` — the status
+ * alone can't carry it. `never_started` is stamped by the init-failure paths and
+ * `dead_orchestrator` is stamped Platform-side by the dead-orchestrator detector.
+ */
+export declare const RunFailureClass: z.ZodEnum<{
+    cancelled: "cancelled";
+    dead_orchestrator: "dead_orchestrator";
+    never_started: "never_started";
+    step_failure: "step_failure";
+    timed_out: "timed_out";
+}>;
+export type RunFailureClass = z.infer<typeof RunFailureClass>;
 /**
  * `step_type` values for the user-facing cache pseudo-steps that appear in the
  * run timeline. Mirrors the `hook:*` pseudo-step `step_type` convention: each
@@ -158,13 +191,21 @@ export type CacheRunEventType = z.infer<typeof CacheRunEventType>;
  *  - `error`   — the restore/save failed (pack/extract/transport error).
  */
 export declare const CacheOutcome: z.ZodEnum<{
-    skipped: "skipped";
     error: "error";
     hit: "hit";
     miss: "miss";
     saved: "saved";
+    skipped: "skipped";
 }>;
 export type CacheOutcome = z.infer<typeof CacheOutcome>;
+/**
+ * Failure reason the Platform records on a run it fails because that run's
+ * orchestrator disconnected and did not reconnect within the stale threshold.
+ * Written by the Platform stale-detector into `execution_runs.failure_reason`
+ * and matched by the dashboard to render the "stale / offline" run badge. A
+ * shared constant so the writer (Platform) and reader (dashboard) never drift.
+ */
+export declare const DEAD_ORCH_FAILURE_REASON = "Orchestrator disconnected and did not recover";
 /** Structured init-failure signal. Presence on a run/job means "never started". */
 export declare const initFailureSchema: z.ZodObject<{
     scope: z.ZodEnum<{
@@ -172,14 +213,17 @@ export declare const initFailureSchema: z.ZodObject<{
         run: "run";
     }>;
     category: z.ZodEnum<{
-        secret_resolution: "secret_resolution";
-        install_secrets: "install_secrets";
-        lock_resolution: "lock_resolution";
+        approval_misconfig: "approval_misconfig";
         build_coordination: "build_coordination";
-        environment_rules: "environment_rules";
+        context_rules: "context_rules";
         dynamic_eval: "dynamic_eval";
-        no_agent: "no_agent";
+        install_secrets: "install_secrets";
+        lock_resolution: "lock_resolution";
         matrix_expansion: "matrix_expansion";
+        no_agent: "no_agent";
+        sandbox_denied: "sandbox_denied";
+        secret_resolution: "secret_resolution";
+        trust_policy: "trust_policy";
     }>;
     message: z.ZodString;
     jobName: z.ZodOptional<z.ZodString>;
@@ -189,6 +233,20 @@ export type InitFailure = z.infer<typeof initFailureSchema>;
 export declare const TERMINAL_RUN_STATES: ReadonlySet<string>;
 /** Terminal job states that indicate the job is no longer running. */
 export declare const TERMINAL_JOB_STATES: ReadonlySet<string>;
+/**
+ * The type-level counterpart of `TERMINAL_JOB_STATES`.
+ *
+ * Written as `Exclude<>` of the non-terminal statuses, never `Extract<>` of the
+ * terminal ones. That direction is load-bearing: `Extract<ExecutionJobStatus,
+ * 'success' | …>` does not widen when a value is added to the enum, so an
+ * exhaustive switch over it keeps compiling and its `never` default arm is
+ * inert. `Exclude<>` does widen, so a new status becomes a compile error at
+ * every switch that claims to be total over the terminal set — which is the
+ * only reason to write such a switch.
+ */
+export type TerminalJobStatus = Exclude<ExecutionJobStatus, 'pending' | 'queued' | 'running' | 'recovering' | 'cancelling'>;
+/** Terminal step states that indicate the step is no longer running. */
+export declare const TERMINAL_STEP_STATES: ReadonlySet<string>;
 /** Structured execution status update for Platform metadata tracking. */
 export declare const executionStatusSchema: z.ZodObject<{
     type: z.ZodLiteral<"execution.status">;
@@ -196,14 +254,15 @@ export declare const executionStatusSchema: z.ZodObject<{
     runId: z.ZodString;
     workflowName: z.ZodString;
     status: z.ZodEnum<{
-        success: "success";
-        pending: "pending";
-        running: "running";
-        failed: "failed";
         cancelled: "cancelled";
         cancelling: "cancelling";
+        failed: "failed";
         held: "held";
+        pending: "pending";
+        running: "running";
+        success: "success";
     }>;
+    routingKey: z.ZodOptional<z.ZodString>;
     repoIdentifier: z.ZodOptional<z.ZodString>;
     repoProvider: z.ZodOptional<z.ZodString>;
     localWorkingTree: z.ZodOptional<z.ZodBoolean>;
@@ -231,18 +290,28 @@ export declare const executionStatusSchema: z.ZodObject<{
             run: "run";
         }>;
         category: z.ZodEnum<{
-            secret_resolution: "secret_resolution";
-            install_secrets: "install_secrets";
-            lock_resolution: "lock_resolution";
+            approval_misconfig: "approval_misconfig";
             build_coordination: "build_coordination";
-            environment_rules: "environment_rules";
+            context_rules: "context_rules";
             dynamic_eval: "dynamic_eval";
-            no_agent: "no_agent";
+            install_secrets: "install_secrets";
+            lock_resolution: "lock_resolution";
             matrix_expansion: "matrix_expansion";
+            no_agent: "no_agent";
+            sandbox_denied: "sandbox_denied";
+            secret_resolution: "secret_resolution";
+            trust_policy: "trust_policy";
         }>;
         message: z.ZodString;
         jobName: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    failureClass: z.ZodOptional<z.ZodEnum<{
+        cancelled: "cancelled";
+        dead_orchestrator: "dead_orchestrator";
+        never_started: "never_started";
+        step_failure: "step_failure";
+        timed_out: "timed_out";
+    }>>;
 }, z.core.$strip>;
 /** Per-step status forwarded from agent to Platform (real-time). */
 export declare const stepStatusForwardSchema: z.ZodObject<{
@@ -254,20 +323,20 @@ export declare const stepStatusForwardSchema: z.ZodObject<{
     stepIndex: z.ZodNumber;
     stepName: z.ZodString;
     state: z.ZodEnum<{
-        skipped: "skipped";
-        success: "success";
+        cancelled: "cancelled";
+        failed: "failed";
         pending: "pending";
         running: "running";
-        failed: "failed";
-        cancelled: "cancelled";
+        skipped: "skipped";
+        success: "success";
     }>;
     timestamp: z.ZodNumber;
     data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     secretsAccessed: z.ZodOptional<z.ZodArray<z.ZodString>>;
     concurrencyKind: z.ZodOptional<z.ZodEnum<{
-        sequential: "sequential";
         "parallel-child": "parallel-child";
         "parallel-group": "parallel-group";
+        sequential: "sequential";
     }>>;
     groupId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -279,17 +348,18 @@ export declare const jobStatusForwardSchema: z.ZodObject<{
     jobId: z.ZodString;
     jobName: z.ZodString;
     status: z.ZodEnum<{
-        skipped: "skipped";
-        success: "success";
-        pending: "pending";
-        running: "running";
-        failed: "failed";
         cancelled: "cancelled";
         cancelling: "cancelling";
+        drift_dropped: "drift_dropped";
+        failed: "failed";
+        pending: "pending";
         queued: "queued";
         recovering: "recovering";
+        running: "running";
+        skipped: "skipped";
+        success: "success";
         timed_out_stale: "timed_out_stale";
-        drift_dropped: "drift_dropped";
+        unroutable: "unroutable";
     }>;
     matrixValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     startedAt: z.ZodOptional<z.ZodNumber>;
@@ -299,7 +369,7 @@ export declare const jobStatusForwardSchema: z.ZodObject<{
     agentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     orchestratorId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     runsOnLabels: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    environments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    contexts: z.ZodOptional<z.ZodArray<z.ZodString>>;
     logBytes: z.ZodOptional<z.ZodNumber>;
     timestamp: z.ZodNumber;
     initFailure: z.ZodOptional<z.ZodObject<{
@@ -308,20 +378,79 @@ export declare const jobStatusForwardSchema: z.ZodObject<{
             run: "run";
         }>;
         category: z.ZodEnum<{
-            secret_resolution: "secret_resolution";
-            install_secrets: "install_secrets";
-            lock_resolution: "lock_resolution";
+            approval_misconfig: "approval_misconfig";
             build_coordination: "build_coordination";
-            environment_rules: "environment_rules";
+            context_rules: "context_rules";
             dynamic_eval: "dynamic_eval";
-            no_agent: "no_agent";
+            install_secrets: "install_secrets";
+            lock_resolution: "lock_resolution";
             matrix_expansion: "matrix_expansion";
+            no_agent: "no_agent";
+            sandbox_denied: "sandbox_denied";
+            secret_resolution: "secret_resolution";
+            trust_policy: "trust_policy";
         }>;
         message: z.ZodString;
         jobName: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 /** State replay sent on orchestrator reconnection -- full snapshot of active runs and jobs. */
+/**
+ * A single run's full mirror-projection shape, as carried in `state.replay`.
+ *
+ * Carried by the orchestrator-reconnect `state.replay` push and consumed by the
+ * Platform's shared `upsertRunMirror` mirror-projection helper. Extracting it as
+ * a named schema keeps a single source of truth for any future reconciliation
+ * path that projects the same per-run shape.
+ */
+export declare const stateReplayRunSchema: z.ZodObject<{
+    runId: z.ZodString;
+    workflowName: z.ZodString;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        cancelling: "cancelling";
+        failed: "failed";
+        held: "held";
+        pending: "pending";
+        running: "running";
+        success: "success";
+    }>;
+    routingKey: z.ZodOptional<z.ZodString>;
+    repoIdentifier: z.ZodOptional<z.ZodString>;
+    sha: z.ZodOptional<z.ZodString>;
+    ref: z.ZodOptional<z.ZodString>;
+    triggerEvent: z.ZodOptional<z.ZodString>;
+    commitMessage: z.ZodOptional<z.ZodString>;
+    jobCount: z.ZodNumber;
+    startedAt: z.ZodNumber;
+    completedAt: z.ZodOptional<z.ZodNumber>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    parentRunId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    originalRunId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    triggeredBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    triggeredByAgentLabel: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    failureReason: z.ZodOptional<z.ZodString>;
+    failureClass: z.ZodOptional<z.ZodEnum<{
+        cancelled: "cancelled";
+        dead_orchestrator: "dead_orchestrator";
+        never_started: "never_started";
+        step_failure: "step_failure";
+        timed_out: "timed_out";
+    }>>;
+    jobs: z.ZodArray<z.ZodObject<{
+        jobId: z.ZodString;
+        jobName: z.ZodString;
+        status: z.ZodString;
+        startedAt: z.ZodOptional<z.ZodNumber>;
+        completedAt: z.ZodOptional<z.ZodNumber>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        errorMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        agentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        runsOnLabels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        contexts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StateReplayRun = z.infer<typeof stateReplayRunSchema>;
 export declare const stateReplaySchema: z.ZodObject<{
     type: z.ZodLiteral<"state.replay">;
     messageId: z.ZodString;
@@ -329,13 +458,13 @@ export declare const stateReplaySchema: z.ZodObject<{
         runId: z.ZodString;
         workflowName: z.ZodString;
         status: z.ZodEnum<{
-            success: "success";
-            pending: "pending";
-            running: "running";
-            failed: "failed";
             cancelled: "cancelled";
             cancelling: "cancelling";
+            failed: "failed";
             held: "held";
+            pending: "pending";
+            running: "running";
+            success: "success";
         }>;
         routingKey: z.ZodOptional<z.ZodString>;
         repoIdentifier: z.ZodOptional<z.ZodString>;
@@ -352,6 +481,13 @@ export declare const stateReplaySchema: z.ZodObject<{
         triggeredBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         triggeredByAgentLabel: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         failureReason: z.ZodOptional<z.ZodString>;
+        failureClass: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            dead_orchestrator: "dead_orchestrator";
+            never_started: "never_started";
+            step_failure: "step_failure";
+            timed_out: "timed_out";
+        }>>;
         jobs: z.ZodArray<z.ZodObject<{
             jobId: z.ZodString;
             jobName: z.ZodString;
@@ -362,7 +498,7 @@ export declare const stateReplaySchema: z.ZodObject<{
             errorMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             agentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             runsOnLabels: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            environments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            contexts: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     timestamp: z.ZodNumber;