@kici-dev/engine 0.1.27 → 0.2.0

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

@@ -24,28 +24,37 @@ export declare const CONTEXTS_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
  *    (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";
     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";
         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";
             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>;
@@ -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";
             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;

package/dist/protocol/messages/execution-status.js

@@ -34,7 +34,15 @@ const ExecutionRunStatus = z.enum([
 	"cancelling",
 	"held"
 ]);
-/** 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).
+*/
 const ExecutionJobStatus = z.enum([
 	"pending",
 	"queued",
@@ -46,7 +54,8 @@ const ExecutionJobStatus = z.enum([
 	"cancelled",
 	"skipped",
 	"timed_out_stale",
-	"drift_dropped"
+	"drift_dropped",
+	"unroutable"
 ]);
 /**
 * The status values a notification subscription may target at the given level.
@@ -111,7 +120,7 @@ const TimeoutReason = z.enum(["job_timeout", "workflow_timeout"]);
 * 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
 *    (context_rules, dynamic_eval, no_agent, matrix_expansion).
 */
@@ -123,7 +132,30 @@ const InitFailureCategory = z.enum([
 	"context_rules",
 	"dynamic_eval",
 	"no_agent",
-	"matrix_expansion"
+	"matrix_expansion",
+	"approval_misconfig",
+	"sandbox_denied",
+	"trust_policy"
+]);
+/**
+* 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.
+*/
+const RunFailureClass = z.enum([
+	"never_started",
+	"timed_out",
+	"dead_orchestrator",
+	"step_failure",
+	"cancelled"
 ]);
 /**
 * `step_type` values for the user-facing cache pseudo-steps that appear in the
@@ -151,6 +183,14 @@ const CacheOutcome = z.enum([
 	"skipped",
 	"error"
 ]);
+/**
+* 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.
+*/
+const DEAD_ORCH_FAILURE_REASON = "Orchestrator disconnected and did not recover";
 /** Structured init-failure signal. Presence on a run/job means "never started". */
 const initFailureSchema = z.object({
 	scope: z.enum(["run", "job"]),
@@ -173,7 +213,15 @@ const TERMINAL_JOB_STATES = /* @__PURE__ */ new Set([
 	ExecutionJobStatus.enum.cancelled,
 	ExecutionJobStatus.enum.skipped,
 	ExecutionJobStatus.enum.timed_out_stale,
-	ExecutionJobStatus.enum.drift_dropped
+	ExecutionJobStatus.enum.drift_dropped,
+	ExecutionJobStatus.enum.unroutable
+]);
+/** Terminal step states that indicate the step is no longer running. */
+const TERMINAL_STEP_STATES = /* @__PURE__ */ new Set([
+	ExecutionStepStatus.enum.success,
+	ExecutionStepStatus.enum.failed,
+	ExecutionStepStatus.enum.skipped,
+	ExecutionStepStatus.enum.cancelled
 ]);
 /** Structured execution status update for Platform metadata tracking. */
 const executionStatusSchema = z.object({
@@ -182,6 +230,13 @@ const executionStatusSchema = z.object({
 	runId: z.string().max(128),
 	workflowName: z.string().max(128),
 	status: ExecutionRunStatus,
+	/**
+	* Routing key of the run's own source. Optional for backward compatibility
+	* with older orchestrators (absent → the Platform falls back to the WS
+	* connection's first routing key). Lets the Platform mirror attribute each
+	* run to its real source even when one orchestrator serves multiple sources.
+	*/
+	routingKey: z.string().max(128).optional(),
 	repoIdentifier: z.string().max(256).optional(),
 	/**
 	* Run-level repo provider (origin host: `github` / `gitlab` / `bitbucket` /
@@ -236,7 +291,9 @@ const executionStatusSchema = z.object({
 	* never executed a single step. Persisted in execution_runs.init_failure
 	* on both orchestrator and Platform sides. Only present when status === 'failed'.
 	*/
-	initFailure: initFailureSchema.optional()
+	initFailure: initFailureSchema.optional(),
+	/** Why a terminal run failed (only present for failed/cancelled runs). */
+	failureClass: RunFailureClass.optional()
 });
 /** Per-step status forwarded from agent to Platform (real-time). */
 const stepStatusForwardSchema = z.object({
@@ -288,45 +345,56 @@ const jobStatusForwardSchema = z.object({
 	initFailure: initFailureSchema.optional()
 });
 /** 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.
+*/
+const stateReplayRunSchema = z.object({
+	runId: z.string().max(128),
+	workflowName: z.string().max(128),
+	status: ExecutionRunStatus,
+	routingKey: z.string().max(128).optional(),
+	repoIdentifier: z.string().max(256).optional(),
+	sha: z.string().max(128).optional(),
+	ref: z.string().max(128).optional(),
+	triggerEvent: z.string().max(128).optional(),
+	commitMessage: z.string().max(STATUS_FREE_TEXT_MAX).optional(),
+	jobCount: z.number(),
+	startedAt: z.number(),
+	completedAt: z.number().optional(),
+	durationMs: z.number().optional(),
+	parentRunId: z.string().max(128).nullable().optional(),
+	originalRunId: z.string().max(128).nullable().optional(),
+	triggeredBy: z.string().max(128).nullable().optional(),
+	triggeredByAgentLabel: z.string().max(128).nullable().optional(),
+	/** Human-readable reason why the run failed (only present for failed runs). */
+	failureReason: z.string().max(STATUS_FREE_TEXT_MAX).optional(),
+	/** Why the run failed (`RunFailureClass`); only present for failed/cancelled runs. */
+	failureClass: RunFailureClass.optional(),
+	jobs: z.array(z.object({
+		jobId: z.string().max(128),
+		jobName: z.string().max(128),
+		status: z.string().max(128),
+		startedAt: z.number().optional(),
+		completedAt: z.number().optional(),
+		durationMs: z.number().optional(),
+		errorMessage: z.string().max(STATUS_FREE_TEXT_MAX).nullable().optional(),
+		agentId: z.string().max(128).nullable().optional(),
+		runsOnLabels: z.array(z.string().max(128)).max(30).optional(),
+		contexts: z.array(z.string().max(128)).max(30).optional()
+	})).max(MAX_JOBS_PER_RUN)
+});
 const stateReplaySchema = z.object({
 	type: z.literal("state.replay"),
 	messageId: z.string().max(128),
-	runs: z.array(z.object({
-		runId: z.string().max(128),
-		workflowName: z.string().max(128),
-		status: ExecutionRunStatus,
-		routingKey: z.string().max(128).optional(),
-		repoIdentifier: z.string().max(256).optional(),
-		sha: z.string().max(128).optional(),
-		ref: z.string().max(128).optional(),
-		triggerEvent: z.string().max(128).optional(),
-		commitMessage: z.string().max(STATUS_FREE_TEXT_MAX).optional(),
-		jobCount: z.number(),
-		startedAt: z.number(),
-		completedAt: z.number().optional(),
-		durationMs: z.number().optional(),
-		parentRunId: z.string().max(128).nullable().optional(),
-		originalRunId: z.string().max(128).nullable().optional(),
-		triggeredBy: z.string().max(128).nullable().optional(),
-		triggeredByAgentLabel: z.string().max(128).nullable().optional(),
-		/** Human-readable reason why the run failed (only present for failed runs). */
-		failureReason: z.string().max(STATUS_FREE_TEXT_MAX).optional(),
-		jobs: z.array(z.object({
-			jobId: z.string().max(128),
-			jobName: z.string().max(128),
-			status: z.string().max(128),
-			startedAt: z.number().optional(),
-			completedAt: z.number().optional(),
-			durationMs: z.number().optional(),
-			errorMessage: z.string().max(STATUS_FREE_TEXT_MAX).nullable().optional(),
-			agentId: z.string().max(128).nullable().optional(),
-			runsOnLabels: z.array(z.string().max(128)).max(30).optional(),
-			contexts: z.array(z.string().max(128)).max(30).optional()
-		})).max(MAX_JOBS_PER_RUN)
-	})).max(500),
+	runs: z.array(stateReplayRunSchema).max(500),
 	timestamp: z.number()
 });
 //#endregion
-export { CONTEXTS_MAX, CacheOutcome, CacheRunEventType, CacheStepType, ExecutionJobStatus, ExecutionRunStatus, ExecutionStepStatus, InitFailureCategory, MAX_JOBS_PER_RUN, REPO_IDENTIFIER_MAX, RUNS_ON_LABELS_MAX, STATE_REPLAY_MAX_RUNS, STATUS_FREE_TEXT_MAX, STATUS_ID_MAX, StepConcurrencyKind, TERMINAL_JOB_STATES, TERMINAL_RUN_STATES, TimeoutReason, executionStatusSchema, initFailureSchema, jobStatusForwardSchema, stateReplaySchema, statusOptionsForLevel, stepStatusForwardSchema };
+export { CONTEXTS_MAX, CacheOutcome, CacheRunEventType, CacheStepType, DEAD_ORCH_FAILURE_REASON, ExecutionJobStatus, ExecutionRunStatus, ExecutionStepStatus, InitFailureCategory, MAX_JOBS_PER_RUN, REPO_IDENTIFIER_MAX, RUNS_ON_LABELS_MAX, RunFailureClass, STATE_REPLAY_MAX_RUNS, STATUS_FREE_TEXT_MAX, STATUS_ID_MAX, StepConcurrencyKind, TERMINAL_JOB_STATES, TERMINAL_RUN_STATES, TERMINAL_STEP_STATES, TimeoutReason, executionStatusSchema, initFailureSchema, jobStatusForwardSchema, stateReplayRunSchema, stateReplaySchema, statusOptionsForLevel, stepStatusForwardSchema };
 
 //# sourceMappingURL=execution-status.js.map