@h-rig/contracts 0.0.6-alpha.0

package/dist/src/engine.js

@@ -0,0 +1,2278 @@
+// @bun
+// packages/contracts/src/engine.ts
+import { Schema as Schema13 } from "effect";
+
+// packages/contracts/src/baseSchemas.ts
+import { Schema } from "effect";
+var TrimmedString = Schema.Trim;
+var TrimmedNonEmptyString = TrimmedString.check(Schema.isNonEmpty());
+var NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+var PositiveInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1));
+var IsoDateTime = Schema.String;
+var makeEntityId = (brand) => TrimmedNonEmptyString.pipe(Schema.brand(brand));
+var ThreadId = makeEntityId("ThreadId");
+var ProjectId = makeEntityId("ProjectId");
+var WorkspaceId = makeEntityId("WorkspaceId");
+var GraphId = makeEntityId("GraphId");
+var TaskId = makeEntityId("TaskId");
+var RunId = makeEntityId("RunId");
+var EngineRuntimeId = makeEntityId("EngineRuntimeId");
+var ConversationId = makeEntityId("ConversationId");
+var ActionId = makeEntityId("ActionId");
+var ArtifactId = makeEntityId("ArtifactId");
+var WorktreeId = makeEntityId("WorktreeId");
+var ValidationResultId = makeEntityId("ValidationResultId");
+var ReviewResultId = makeEntityId("ReviewResultId");
+var CommandId = makeEntityId("CommandId");
+var EventId = makeEntityId("EventId");
+var MessageId = makeEntityId("MessageId");
+var TurnId = makeEntityId("TurnId");
+var ProviderItemId = makeEntityId("ProviderItemId");
+var RuntimeSessionId = makeEntityId("RuntimeSessionId");
+var RuntimeItemId = makeEntityId("RuntimeItemId");
+var RuntimeRequestId = makeEntityId("RuntimeRequestId");
+var RuntimeTaskId = makeEntityId("RuntimeTaskId");
+var ApprovalRequestId = makeEntityId("ApprovalRequestId");
+var CheckpointRef = makeEntityId("CheckpointRef");
+var RemoteEndpointId = makeEntityId("RemoteEndpointId");
+
+// packages/contracts/src/conversation.ts
+import { Schema as Schema2 } from "effect";
+var EngineMessageRole = Schema2.Literals(["user", "assistant", "system"]);
+var EngineMessageState = Schema2.Literals([
+  "streaming",
+  "completed",
+  "interrupted",
+  "errored"
+]);
+var ConversationSummary = Schema2.Struct({
+  id: ConversationId,
+  runId: RunId,
+  title: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var EngineMessage = Schema2.Struct({
+  id: MessageId,
+  conversationId: ConversationId,
+  role: EngineMessageRole,
+  text: Schema2.String,
+  attachments: Schema2.Array(Schema2.Unknown),
+  state: EngineMessageState,
+  createdAt: IsoDateTime,
+  completedAt: Schema2.NullOr(IsoDateTime)
+});
+var EngineAction = Schema2.Struct({
+  id: ActionId,
+  runId: RunId,
+  messageId: Schema2.NullOr(MessageId),
+  actionType: TrimmedNonEmptyString,
+  title: TrimmedNonEmptyString,
+  detail: Schema2.NullOr(Schema2.String),
+  state: TrimmedNonEmptyString,
+  payload: Schema2.Unknown,
+  startedAt: IsoDateTime,
+  completedAt: Schema2.NullOr(IsoDateTime)
+});
+var EngineLogTone = Schema2.Literals(["thinking", "tool", "info", "error"]);
+var EngineRunLog = Schema2.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  title: TrimmedNonEmptyString,
+  detail: Schema2.NullOr(Schema2.String),
+  tone: EngineLogTone,
+  status: Schema2.NullOr(TrimmedNonEmptyString),
+  payload: Schema2.Unknown,
+  createdAt: IsoDateTime
+});
+
+// packages/contracts/src/graph.ts
+import { Schema as Schema3 } from "effect";
+var TaskStatus = Schema3.Literals([
+  "draft",
+  "open",
+  "ready",
+  "queued",
+  "running",
+  "in_progress",
+  "under_review",
+  "blocked",
+  "unknown",
+  "completed",
+  "failed",
+  "cancelled",
+  "closed"
+]);
+var GraphSummary = Schema3.Struct({
+  id: GraphId,
+  workspaceId: WorkspaceId,
+  title: TrimmedNonEmptyString,
+  description: Schema3.NullOr(Schema3.String),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var TaskSummary = Schema3.Struct({
+  id: TaskId,
+  workspaceId: WorkspaceId,
+  graphId: Schema3.NullOr(GraphId),
+  externalId: Schema3.NullOr(TrimmedNonEmptyString),
+  title: TrimmedNonEmptyString,
+  description: Schema3.String,
+  status: TaskStatus,
+  priority: Schema3.NullOr(PositiveInt),
+  role: Schema3.NullOr(TrimmedNonEmptyString),
+  scope: Schema3.Array(TrimmedNonEmptyString),
+  validationKeys: Schema3.Array(TrimmedNonEmptyString),
+  sourceIssueId: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  dependencies: Schema3.optional(Schema3.Array(TrimmedNonEmptyString)),
+  parentChildDeps: Schema3.optional(Schema3.Array(TrimmedNonEmptyString)),
+  metadata: Schema3.Unknown,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var QueueEntry = Schema3.Struct({
+  taskId: TaskId,
+  score: NonNegativeInt,
+  unblockCount: NonNegativeInt,
+  position: NonNegativeInt
+});
+
+// packages/contracts/src/policy.ts
+import { Schema as Schema4 } from "effect";
+var PolicyDecision = Schema4.Literals(["allow", "warn", "block"]);
+var PolicyMode = Schema4.Literals(["off", "observe", "enforce"]);
+var PolicyDecisionSummary = Schema4.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  actionId: Schema4.NullOr(ActionId),
+  decision: PolicyDecision,
+  mode: PolicyMode,
+  matchedRules: Schema4.Array(TrimmedNonEmptyString),
+  reason: Schema4.String,
+  createdAt: IsoDateTime
+});
+
+// packages/contracts/src/artifact.ts
+import { Schema as Schema5 } from "effect";
+var ArtifactSummary = Schema5.Struct({
+  id: ArtifactId,
+  runId: RunId,
+  taskId: Schema5.NullOr(TaskId),
+  kind: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  path: Schema5.NullOr(TrimmedNonEmptyString),
+  url: Schema5.NullOr(TrimmedNonEmptyString),
+  metadata: Schema5.Record(Schema5.String, Schema5.Unknown),
+  createdAt: IsoDateTime
+});
+
+// packages/contracts/src/orchestration.ts
+import { Option, Schema as Schema7, SchemaIssue, Struct } from "effect";
+
+// packages/contracts/src/model.ts
+import { Schema as Schema6 } from "effect";
+var CODEX_REASONING_EFFORT_OPTIONS = ["xhigh", "high", "medium", "low"];
+var CodexModelOptions = Schema6.Struct({
+  reasoningEffort: Schema6.optional(Schema6.Literals(CODEX_REASONING_EFFORT_OPTIONS)),
+  fastMode: Schema6.optional(Schema6.Boolean)
+});
+var ClaudeModelOptions = Schema6.Struct({});
+var ProviderModelOptions = Schema6.Struct({
+  codex: Schema6.optional(CodexModelOptions),
+  claude: Schema6.optional(ClaudeModelOptions)
+});
+
+// packages/contracts/src/orchestration.ts
+var ProviderKind = Schema7.Literals(["codex", "claude"]);
+var ProviderApprovalPolicy = Schema7.Literals([
+  "untrusted",
+  "on-failure",
+  "on-request",
+  "never"
+]);
+var ProviderSandboxMode = Schema7.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var ProviderServiceTier = Schema7.Literals(["fast", "flex"]);
+var RuntimeMode = Schema7.Literals(["approval-required", "full-access"]);
+var DEFAULT_RUNTIME_MODE = "full-access";
+var ProviderInteractionMode = Schema7.Literals(["default", "plan"]);
+var DEFAULT_PROVIDER_INTERACTION_MODE = "default";
+var ProviderRequestKind = Schema7.Literals(["command", "file-read", "file-change"]);
+var AssistantDeliveryMode = Schema7.Literals(["buffered", "streaming"]);
+var ProviderApprovalDecision = Schema7.Literals([
+  "accept",
+  "acceptForSession",
+  "decline",
+  "cancel"
+]);
+var ProviderUserInputAnswers = Schema7.Record(Schema7.String, Schema7.Unknown);
+var PROVIDER_SEND_TURN_MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+var PROVIDER_SEND_TURN_MAX_IMAGE_DATA_URL_CHARS = 14000000;
+var CHAT_ATTACHMENT_ID_MAX_CHARS = 128;
+var ChatAttachmentId = TrimmedNonEmptyString.check(Schema7.isMaxLength(CHAT_ATTACHMENT_ID_MAX_CHARS), Schema7.isPattern(/^[a-z0-9_-]+$/i));
+var ChatImageAttachment = Schema7.Struct({
+  type: Schema7.Literal("image"),
+  id: ChatAttachmentId,
+  name: TrimmedNonEmptyString.check(Schema7.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema7.isMaxLength(100), Schema7.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema7.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES))
+});
+var UploadChatImageAttachment = Schema7.Struct({
+  type: Schema7.Literal("image"),
+  name: TrimmedNonEmptyString.check(Schema7.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema7.isMaxLength(100), Schema7.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema7.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES)),
+  dataUrl: TrimmedNonEmptyString.check(Schema7.isMaxLength(PROVIDER_SEND_TURN_MAX_IMAGE_DATA_URL_CHARS))
+});
+var ChatAttachment = Schema7.Union([ChatImageAttachment]);
+var UploadChatAttachment = Schema7.Union([UploadChatImageAttachment]);
+var ProjectScriptIcon = Schema7.Literals([
+  "play",
+  "test",
+  "lint",
+  "configure",
+  "build",
+  "debug"
+]);
+var ProjectScript = Schema7.Struct({
+  id: TrimmedNonEmptyString,
+  name: TrimmedNonEmptyString,
+  command: TrimmedNonEmptyString,
+  icon: ProjectScriptIcon,
+  runOnWorktreeCreate: Schema7.Boolean
+});
+var OrchestrationProject = Schema7.Struct({
+  id: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema7.NullOr(TrimmedNonEmptyString),
+  scripts: Schema7.Array(ProjectScript),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  deletedAt: Schema7.NullOr(IsoDateTime)
+});
+var OrchestrationMessageRole = Schema7.Literals(["user", "assistant", "system"]);
+var OrchestrationMessage = Schema7.Struct({
+  id: MessageId,
+  role: OrchestrationMessageRole,
+  text: Schema7.String,
+  attachments: Schema7.optional(Schema7.Array(ChatAttachment)),
+  turnId: Schema7.NullOr(TurnId),
+  streaming: Schema7.Boolean,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var OrchestrationProposedPlanId = TrimmedNonEmptyString;
+var OrchestrationProposedPlan = Schema7.Struct({
+  id: OrchestrationProposedPlanId,
+  turnId: Schema7.NullOr(TurnId),
+  planMarkdown: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var OrchestrationSessionStatus = Schema7.Literals([
+  "idle",
+  "starting",
+  "running",
+  "ready",
+  "interrupted",
+  "stopped",
+  "error"
+]);
+var OrchestrationSession = Schema7.Struct({
+  threadId: ThreadId,
+  status: OrchestrationSessionStatus,
+  providerName: Schema7.NullOr(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  activeTurnId: Schema7.NullOr(TurnId),
+  lastError: Schema7.NullOr(TrimmedNonEmptyString),
+  updatedAt: IsoDateTime
+});
+var OrchestrationCheckpointFile = Schema7.Struct({
+  path: TrimmedNonEmptyString,
+  kind: TrimmedNonEmptyString,
+  additions: NonNegativeInt,
+  deletions: NonNegativeInt
+});
+var OrchestrationCheckpointStatus = Schema7.Literals(["ready", "missing", "error"]);
+var OrchestrationCheckpointSummary = Schema7.Struct({
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema7.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema7.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var OrchestrationThreadActivityTone = Schema7.Literals([
+  "info",
+  "tool",
+  "approval",
+  "error"
+]);
+var OrchestrationThreadActivity = Schema7.Struct({
+  id: EventId,
+  tone: OrchestrationThreadActivityTone,
+  kind: TrimmedNonEmptyString,
+  summary: TrimmedNonEmptyString,
+  payload: Schema7.Unknown,
+  turnId: Schema7.NullOr(TurnId),
+  sequence: Schema7.optional(NonNegativeInt),
+  createdAt: IsoDateTime
+});
+var OrchestrationLatestTurnState = Schema7.Literals([
+  "running",
+  "interrupted",
+  "completed",
+  "error"
+]);
+var OrchestrationLatestTurn = Schema7.Struct({
+  turnId: TurnId,
+  state: OrchestrationLatestTurnState,
+  requestedAt: IsoDateTime,
+  startedAt: Schema7.NullOr(IsoDateTime),
+  completedAt: Schema7.NullOr(IsoDateTime),
+  assistantMessageId: Schema7.NullOr(MessageId)
+});
+var OrchestrationThread = Schema7.Struct({
+  id: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema7.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema7.NullOr(TrimmedNonEmptyString),
+  latestTurn: Schema7.NullOr(OrchestrationLatestTurn),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  deletedAt: Schema7.NullOr(IsoDateTime),
+  messages: Schema7.Array(OrchestrationMessage),
+  proposedPlans: Schema7.Array(OrchestrationProposedPlan).pipe(Schema7.withDecodingDefault(() => [])),
+  activities: Schema7.Array(OrchestrationThreadActivity),
+  checkpoints: Schema7.Array(OrchestrationCheckpointSummary),
+  session: Schema7.NullOr(OrchestrationSession)
+});
+var OrchestrationReadModel = Schema7.Struct({
+  snapshotSequence: NonNegativeInt,
+  projects: Schema7.Array(OrchestrationProject),
+  threads: Schema7.Array(OrchestrationThread),
+  updatedAt: IsoDateTime
+});
+var ProjectCreateCommand = Schema7.Struct({
+  type: Schema7.Literal("project.create"),
+  commandId: CommandId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema7.optional(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var ProjectMetaUpdateCommand = Schema7.Struct({
+  type: Schema7.Literal("project.meta.update"),
+  commandId: CommandId,
+  projectId: ProjectId,
+  title: Schema7.optional(TrimmedNonEmptyString),
+  workspaceRoot: Schema7.optional(TrimmedNonEmptyString),
+  defaultModel: Schema7.optional(TrimmedNonEmptyString),
+  scripts: Schema7.optional(Schema7.Array(ProjectScript))
+});
+var ProjectDeleteCommand = Schema7.Struct({
+  type: Schema7.Literal("project.delete"),
+  commandId: CommandId,
+  projectId: ProjectId
+});
+var ThreadCreateCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.create"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema7.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema7.NullOr(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var ThreadDeleteCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.delete"),
+  commandId: CommandId,
+  threadId: ThreadId
+});
+var ThreadMetaUpdateCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.meta.update"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  title: Schema7.optional(TrimmedNonEmptyString),
+  model: Schema7.optional(TrimmedNonEmptyString),
+  branch: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  worktreePath: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString))
+});
+var ThreadRuntimeModeSetCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.runtime-mode.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  runtimeMode: RuntimeMode,
+  createdAt: IsoDateTime
+});
+var ThreadInteractionModeSetCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.interaction-mode.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  interactionMode: ProviderInteractionMode,
+  createdAt: IsoDateTime
+});
+var ThreadTurnStartCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.turn.start"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  message: Schema7.Struct({
+    messageId: MessageId,
+    role: Schema7.Literal("user"),
+    text: Schema7.String,
+    attachments: Schema7.Array(ChatAttachment)
+  }),
+  provider: Schema7.optional(ProviderKind),
+  model: Schema7.optional(TrimmedNonEmptyString),
+  serviceTier: Schema7.optional(Schema7.NullOr(ProviderServiceTier)),
+  modelOptions: Schema7.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema7.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  createdAt: IsoDateTime
+});
+var ClientThreadTurnStartCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.turn.start"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  message: Schema7.Struct({
+    messageId: MessageId,
+    role: Schema7.Literal("user"),
+    text: Schema7.String,
+    attachments: Schema7.Array(UploadChatAttachment)
+  }),
+  provider: Schema7.optional(ProviderKind),
+  model: Schema7.optional(TrimmedNonEmptyString),
+  serviceTier: Schema7.optional(Schema7.NullOr(ProviderServiceTier)),
+  modelOptions: Schema7.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema7.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  createdAt: IsoDateTime
+});
+var ThreadTurnInterruptCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.turn.interrupt"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnId: Schema7.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadApprovalRespondCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.approval.respond"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision,
+  createdAt: IsoDateTime
+});
+var ThreadUserInputRespondCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.user-input.respond"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers,
+  createdAt: IsoDateTime
+});
+var ThreadCheckpointRevertCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.checkpoint.revert"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadSessionStopCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.session.stop"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  createdAt: IsoDateTime
+});
+var DispatchableClientOrchestrationCommand = Schema7.Union([
+  ProjectCreateCommand,
+  ProjectMetaUpdateCommand,
+  ProjectDeleteCommand,
+  ThreadCreateCommand,
+  ThreadDeleteCommand,
+  ThreadMetaUpdateCommand,
+  ThreadRuntimeModeSetCommand,
+  ThreadInteractionModeSetCommand,
+  ThreadTurnStartCommand,
+  ThreadTurnInterruptCommand,
+  ThreadApprovalRespondCommand,
+  ThreadUserInputRespondCommand,
+  ThreadCheckpointRevertCommand,
+  ThreadSessionStopCommand
+]);
+var ClientOrchestrationCommand = Schema7.Union([
+  ProjectCreateCommand,
+  ProjectMetaUpdateCommand,
+  ProjectDeleteCommand,
+  ThreadCreateCommand,
+  ThreadDeleteCommand,
+  ThreadMetaUpdateCommand,
+  ThreadRuntimeModeSetCommand,
+  ThreadInteractionModeSetCommand,
+  ClientThreadTurnStartCommand,
+  ThreadTurnInterruptCommand,
+  ThreadApprovalRespondCommand,
+  ThreadUserInputRespondCommand,
+  ThreadCheckpointRevertCommand,
+  ThreadSessionStopCommand
+]);
+var ThreadSessionSetCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.session.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  session: OrchestrationSession,
+  createdAt: IsoDateTime
+});
+var ThreadMessageAssistantDeltaCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.message.assistant.delta"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  messageId: MessageId,
+  delta: Schema7.String,
+  turnId: Schema7.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadMessageAssistantCompleteCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.message.assistant.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  messageId: MessageId,
+  turnId: Schema7.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadProposedPlanUpsertCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.proposed-plan.upsert"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  proposedPlan: OrchestrationProposedPlan,
+  createdAt: IsoDateTime
+});
+var ThreadTurnDiffCompleteCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.turn.diff.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnId: TurnId,
+  completedAt: IsoDateTime,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema7.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema7.optional(MessageId),
+  checkpointTurnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadActivityAppendCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.activity.append"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  activity: OrchestrationThreadActivity,
+  createdAt: IsoDateTime
+});
+var ThreadRevertCompleteCommand = Schema7.Struct({
+  type: Schema7.Literal("thread.revert.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var InternalOrchestrationCommand = Schema7.Union([
+  ThreadSessionSetCommand,
+  ThreadMessageAssistantDeltaCommand,
+  ThreadMessageAssistantCompleteCommand,
+  ThreadProposedPlanUpsertCommand,
+  ThreadTurnDiffCompleteCommand,
+  ThreadActivityAppendCommand,
+  ThreadRevertCompleteCommand
+]);
+var OrchestrationCommand = Schema7.Union([
+  DispatchableClientOrchestrationCommand,
+  InternalOrchestrationCommand
+]);
+var OrchestrationEventType = Schema7.Literals([
+  "project.created",
+  "project.meta-updated",
+  "project.deleted",
+  "thread.created",
+  "thread.deleted",
+  "thread.meta-updated",
+  "thread.runtime-mode-set",
+  "thread.interaction-mode-set",
+  "thread.message-sent",
+  "thread.turn-start-requested",
+  "thread.turn-interrupt-requested",
+  "thread.approval-response-requested",
+  "thread.user-input-response-requested",
+  "thread.checkpoint-revert-requested",
+  "thread.reverted",
+  "thread.session-stop-requested",
+  "thread.session-set",
+  "thread.proposed-plan-upserted",
+  "thread.turn-diff-completed",
+  "thread.activity-appended"
+]);
+var OrchestrationAggregateKind = Schema7.Literals(["project", "thread"]);
+var OrchestrationActorKind = Schema7.Literals(["client", "server", "provider"]);
+var ProjectCreatedPayload = Schema7.Struct({
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema7.NullOr(TrimmedNonEmptyString),
+  scripts: Schema7.Array(ProjectScript),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ProjectMetaUpdatedPayload = Schema7.Struct({
+  projectId: ProjectId,
+  title: Schema7.optional(TrimmedNonEmptyString),
+  workspaceRoot: Schema7.optional(TrimmedNonEmptyString),
+  defaultModel: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  scripts: Schema7.optional(Schema7.Array(ProjectScript)),
+  updatedAt: IsoDateTime
+});
+var ProjectDeletedPayload = Schema7.Struct({
+  projectId: ProjectId,
+  deletedAt: IsoDateTime
+});
+var ThreadCreatedPayload = Schema7.Struct({
+  threadId: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema7.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema7.NullOr(TrimmedNonEmptyString),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ThreadDeletedPayload = Schema7.Struct({
+  threadId: ThreadId,
+  deletedAt: IsoDateTime
+});
+var ThreadMetaUpdatedPayload = Schema7.Struct({
+  threadId: ThreadId,
+  title: Schema7.optional(TrimmedNonEmptyString),
+  model: Schema7.optional(TrimmedNonEmptyString),
+  branch: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  worktreePath: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  updatedAt: IsoDateTime
+});
+var ThreadRuntimeModeSetPayload = Schema7.Struct({
+  threadId: ThreadId,
+  runtimeMode: RuntimeMode,
+  updatedAt: IsoDateTime
+});
+var ThreadInteractionModeSetPayload = Schema7.Struct({
+  threadId: ThreadId,
+  interactionMode: ProviderInteractionMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  updatedAt: IsoDateTime
+});
+var ThreadMessageSentPayload = Schema7.Struct({
+  threadId: ThreadId,
+  messageId: MessageId,
+  role: OrchestrationMessageRole,
+  text: Schema7.String,
+  attachments: Schema7.optional(Schema7.Array(ChatAttachment)),
+  turnId: Schema7.NullOr(TurnId),
+  streaming: Schema7.Boolean,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ThreadTurnStartRequestedPayload = Schema7.Struct({
+  threadId: ThreadId,
+  messageId: MessageId,
+  provider: Schema7.optional(ProviderKind),
+  model: Schema7.optional(TrimmedNonEmptyString),
+  serviceTier: Schema7.optional(Schema7.NullOr(ProviderServiceTier)),
+  modelOptions: Schema7.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema7.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  createdAt: IsoDateTime
+});
+var ThreadTurnInterruptRequestedPayload = Schema7.Struct({
+  threadId: ThreadId,
+  turnId: Schema7.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadApprovalResponseRequestedPayload = Schema7.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision,
+  createdAt: IsoDateTime
+});
+var ThreadUserInputResponseRequestedPayload = Schema7.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers,
+  createdAt: IsoDateTime
+});
+var ThreadCheckpointRevertRequestedPayload = Schema7.Struct({
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadRevertedPayload = Schema7.Struct({
+  threadId: ThreadId,
+  turnCount: NonNegativeInt
+});
+var ThreadSessionStopRequestedPayload = Schema7.Struct({
+  threadId: ThreadId,
+  createdAt: IsoDateTime
+});
+var ThreadSessionSetPayload = Schema7.Struct({
+  threadId: ThreadId,
+  session: OrchestrationSession
+});
+var ThreadProposedPlanUpsertedPayload = Schema7.Struct({
+  threadId: ThreadId,
+  proposedPlan: OrchestrationProposedPlan
+});
+var ThreadTurnDiffCompletedPayload = Schema7.Struct({
+  threadId: ThreadId,
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema7.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema7.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var ThreadActivityAppendedPayload = Schema7.Struct({
+  threadId: ThreadId,
+  activity: OrchestrationThreadActivity
+});
+var OrchestrationEventMetadata = Schema7.Struct({
+  providerTurnId: Schema7.optional(TrimmedNonEmptyString),
+  providerItemId: Schema7.optional(ProviderItemId),
+  adapterKey: Schema7.optional(TrimmedNonEmptyString),
+  requestId: Schema7.optional(ApprovalRequestId),
+  ingestedAt: Schema7.optional(IsoDateTime)
+});
+var EventBaseFields = {
+  sequence: NonNegativeInt,
+  eventId: EventId,
+  aggregateKind: OrchestrationAggregateKind,
+  aggregateId: Schema7.Union([ProjectId, ThreadId]),
+  occurredAt: IsoDateTime,
+  commandId: Schema7.NullOr(CommandId),
+  causationEventId: Schema7.NullOr(EventId),
+  correlationId: Schema7.NullOr(CommandId),
+  metadata: OrchestrationEventMetadata
+};
+var PersistedEventBaseFields = {
+  sequence: NonNegativeInt,
+  eventId: EventId,
+  aggregateKind: OrchestrationAggregateKind,
+  streamId: Schema7.Union([ProjectId, ThreadId]),
+  streamVersion: NonNegativeInt,
+  occurredAt: IsoDateTime,
+  commandId: Schema7.NullOr(CommandId),
+  causationEventId: Schema7.NullOr(EventId),
+  correlationId: Schema7.NullOr(CommandId),
+  actorKind: OrchestrationActorKind,
+  metadata: OrchestrationEventMetadata
+};
+var OrchestrationEvent = Schema7.Union([
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("project.created"),
+    payload: ProjectCreatedPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("project.meta-updated"),
+    payload: ProjectMetaUpdatedPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("project.deleted"),
+    payload: ProjectDeletedPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("thread.created"),
+    payload: ThreadCreatedPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("thread.deleted"),
+    payload: ThreadDeletedPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("thread.meta-updated"),
+    payload: ThreadMetaUpdatedPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("thread.runtime-mode-set"),
+    payload: ThreadRuntimeModeSetPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("thread.interaction-mode-set"),
+    payload: ThreadInteractionModeSetPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("thread.message-sent"),
+    payload: ThreadMessageSentPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("thread.turn-start-requested"),
+    payload: ThreadTurnStartRequestedPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("thread.turn-interrupt-requested"),
+    payload: ThreadTurnInterruptRequestedPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("thread.approval-response-requested"),
+    payload: ThreadApprovalResponseRequestedPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("thread.user-input-response-requested"),
+    payload: ThreadUserInputResponseRequestedPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("thread.checkpoint-revert-requested"),
+    payload: ThreadCheckpointRevertRequestedPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("thread.reverted"),
+    payload: ThreadRevertedPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("thread.session-stop-requested"),
+    payload: ThreadSessionStopRequestedPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("thread.session-set"),
+    payload: ThreadSessionSetPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("thread.proposed-plan-upserted"),
+    payload: ThreadProposedPlanUpsertedPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("thread.turn-diff-completed"),
+    payload: ThreadTurnDiffCompletedPayload
+  }),
+  Schema7.Struct({
+    ...EventBaseFields,
+    type: Schema7.Literal("thread.activity-appended"),
+    payload: ThreadActivityAppendedPayload
+  })
+]);
+var OrchestrationPersistedEvent = Schema7.Union([
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("project.created"),
+    payload: ProjectCreatedPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("project.meta-updated"),
+    payload: ProjectMetaUpdatedPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("project.deleted"),
+    payload: ProjectDeletedPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("thread.created"),
+    payload: ThreadCreatedPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("thread.deleted"),
+    payload: ThreadDeletedPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("thread.meta-updated"),
+    payload: ThreadMetaUpdatedPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("thread.runtime-mode-set"),
+    payload: ThreadRuntimeModeSetPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("thread.interaction-mode-set"),
+    payload: ThreadInteractionModeSetPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("thread.message-sent"),
+    payload: ThreadMessageSentPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("thread.turn-start-requested"),
+    payload: ThreadTurnStartRequestedPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("thread.turn-interrupt-requested"),
+    payload: ThreadTurnInterruptRequestedPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("thread.approval-response-requested"),
+    payload: ThreadApprovalResponseRequestedPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("thread.user-input-response-requested"),
+    payload: ThreadUserInputResponseRequestedPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("thread.checkpoint-revert-requested"),
+    payload: ThreadCheckpointRevertRequestedPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("thread.reverted"),
+    payload: ThreadRevertedPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("thread.session-stop-requested"),
+    payload: ThreadSessionStopRequestedPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("thread.session-set"),
+    payload: ThreadSessionSetPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("thread.proposed-plan-upserted"),
+    payload: ThreadProposedPlanUpsertedPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("thread.turn-diff-completed"),
+    payload: ThreadTurnDiffCompletedPayload
+  }),
+  Schema7.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema7.Literal("thread.activity-appended"),
+    payload: ThreadActivityAppendedPayload
+  })
+]);
+var OrchestrationCommandReceiptStatus = Schema7.Literals(["accepted", "rejected"]);
+var TurnCountRange = Schema7.Struct({
+  fromTurnCount: NonNegativeInt,
+  toTurnCount: NonNegativeInt
+}).check(Schema7.makeFilter((input) => input.fromTurnCount <= input.toTurnCount || new SchemaIssue.InvalidValue(Option.some(input.fromTurnCount), {
+  message: "fromTurnCount must be less than or equal to toTurnCount"
+}), { identifier: "OrchestrationTurnDiffRange" }));
+var ThreadTurnDiff = TurnCountRange.mapFields(Struct.assign({
+  threadId: ThreadId,
+  diff: Schema7.String
+}), { unsafePreserveChecks: true });
+var ProviderSessionRuntimeStatus = Schema7.Literals([
+  "starting",
+  "running",
+  "stopped",
+  "error"
+]);
+var ProjectionThreadTurnStatus = Schema7.Literals([
+  "running",
+  "completed",
+  "interrupted",
+  "error"
+]);
+var ProjectionCheckpointRow = Schema7.Struct({
+  threadId: ThreadId,
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema7.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema7.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var ProjectionPendingApprovalStatus = Schema7.Literals(["pending", "resolved"]);
+var ProjectionPendingApprovalDecision = Schema7.NullOr(ProviderApprovalDecision);
+var DispatchResult = Schema7.Struct({
+  sequence: NonNegativeInt
+});
+var OrchestrationGetSnapshotInput = Schema7.Struct({});
+var OrchestrationGetTurnDiffInput = TurnCountRange.mapFields(Struct.assign({ threadId: ThreadId }), { unsafePreserveChecks: true });
+var OrchestrationGetFullThreadDiffInput = Schema7.Struct({
+  threadId: ThreadId,
+  toTurnCount: NonNegativeInt
+});
+var OrchestrationReplayEventsInput = Schema7.Struct({
+  fromSequenceExclusive: NonNegativeInt
+});
+var OrchestrationReplayEventsResult = Schema7.Array(OrchestrationEvent);
+
+// packages/contracts/src/review.ts
+import { Schema as Schema8 } from "effect";
+var ReviewMode = Schema8.Literals(["off", "advisory", "required"]);
+var ReviewStatus = Schema8.Literals(["pending", "running", "approved", "rejected", "error"]);
+var ReviewSummary = Schema8.Struct({
+  id: ReviewResultId,
+  runId: RunId,
+  taskId: Schema8.NullOr(TaskId),
+  provider: TrimmedNonEmptyString,
+  mode: ReviewMode,
+  status: ReviewStatus,
+  summary: Schema8.NullOr(Schema8.String),
+  output: Schema8.Unknown,
+  createdAt: IsoDateTime,
+  completedAt: Schema8.NullOr(IsoDateTime)
+});
+
+// packages/contracts/src/runtime.ts
+import { Schema as Schema9 } from "effect";
+var RunKind = Schema9.Literals(["adhoc", "task", "batch", "validation", "review"]);
+var RunMode = Schema9.Literals(["interactive", "autonomous", "supervised"]);
+var RunStatus = Schema9.Literals([
+  "created",
+  "queued",
+  "preparing",
+  "running",
+  "waiting-approval",
+  "waiting-user-input",
+  "validating",
+  "reviewing",
+  "completed",
+  "failed",
+  "cancelled",
+  "paused"
+]);
+var EngineSandboxMode = Schema9.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var IsolationMode = Schema9.Literals(["none", "env", "worktree"]);
+var RuntimeStatus = Schema9.Literals([
+  "prepared",
+  "starting",
+  "running",
+  "interrupted",
+  "exited",
+  "failed",
+  "destroyed"
+]);
+var RunExecutionTarget = Schema9.Literals(["local", "remote"]);
+var RunSummary = Schema9.Struct({
+  id: RunId,
+  workspaceId: WorkspaceId,
+  taskId: Schema9.NullOr(TaskId),
+  title: TrimmedNonEmptyString,
+  runKind: RunKind,
+  mode: RunMode,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  status: RunStatus,
+  runtimeAdapter: TrimmedNonEmptyString,
+  model: Schema9.NullOr(TrimmedNonEmptyString),
+  initialPrompt: Schema9.NullOr(Schema9.String),
+  executionTarget: Schema9.optional(RunExecutionTarget),
+  remoteHostId: Schema9.optional(Schema9.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseId: Schema9.optional(Schema9.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseClaimedAt: Schema9.optional(Schema9.NullOr(IsoDateTime)),
+  activeRuntimeId: Schema9.NullOr(EngineRuntimeId),
+  latestMessageId: Schema9.NullOr(TrimmedNonEmptyString),
+  pendingApprovalCount: NonNegativeInt,
+  pendingUserInputCount: NonNegativeInt,
+  branch: Schema9.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema9.NullOr(TrimmedNonEmptyString),
+  errorText: Schema9.NullOr(Schema9.String),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  startedAt: Schema9.NullOr(IsoDateTime),
+  completedAt: Schema9.NullOr(IsoDateTime)
+});
+var RuntimeSummary = Schema9.Struct({
+  id: EngineRuntimeId,
+  workspaceId: WorkspaceId,
+  runId: RunId,
+  adapterKind: TrimmedNonEmptyString,
+  executionTarget: Schema9.optional(RunExecutionTarget),
+  remoteHostId: Schema9.optional(Schema9.NullOr(TrimmedNonEmptyString)),
+  status: RuntimeStatus,
+  sandboxMode: EngineSandboxMode,
+  isolationMode: IsolationMode,
+  workspaceDir: Schema9.NullOr(TrimmedNonEmptyString),
+  homeDir: Schema9.NullOr(TrimmedNonEmptyString),
+  tmpDir: Schema9.NullOr(TrimmedNonEmptyString),
+  cacheDir: Schema9.NullOr(TrimmedNonEmptyString),
+  logsDir: Schema9.NullOr(TrimmedNonEmptyString),
+  stateDir: Schema9.NullOr(TrimmedNonEmptyString),
+  sessionDir: Schema9.NullOr(TrimmedNonEmptyString),
+  sessionLogPath: Schema9.NullOr(TrimmedNonEmptyString),
+  pid: Schema9.NullOr(NonNegativeInt),
+  startedAt: Schema9.NullOr(IsoDateTime),
+  updatedAt: IsoDateTime,
+  exitedAt: Schema9.NullOr(IsoDateTime)
+});
+var ApprovalStatus = Schema9.Literals(["pending", "resolved"]);
+var ApprovalSummary = Schema9.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  actionId: Schema9.NullOr(TrimmedNonEmptyString),
+  requestKind: TrimmedNonEmptyString,
+  status: ApprovalStatus,
+  payload: Schema9.Unknown,
+  createdAt: IsoDateTime,
+  resolvedAt: Schema9.NullOr(IsoDateTime)
+});
+var UserInputRequestSummary = Schema9.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  status: ApprovalStatus,
+  payload: Schema9.Unknown,
+  createdAt: IsoDateTime,
+  resolvedAt: Schema9.NullOr(IsoDateTime)
+});
+var WorktreeSummary = Schema9.Struct({
+  id: WorktreeId,
+  workspaceId: WorkspaceId,
+  runId: RunId,
+  taskId: Schema9.NullOr(TaskId),
+  branchName: TrimmedNonEmptyString,
+  path: TrimmedNonEmptyString,
+  status: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  cleanedAt: Schema9.NullOr(IsoDateTime)
+});
+
+// packages/contracts/src/validation.ts
+import { Schema as Schema10 } from "effect";
+var ValidationStatus = Schema10.Literals([
+  "pending",
+  "running",
+  "passed",
+  "failed",
+  "skipped"
+]);
+var ValidationSummary = Schema10.Struct({
+  id: ValidationResultId,
+  runId: RunId,
+  taskId: Schema10.NullOr(TaskId),
+  validatorKey: TrimmedNonEmptyString,
+  status: ValidationStatus,
+  output: Schema10.Unknown,
+  startedAt: IsoDateTime,
+  completedAt: Schema10.NullOr(IsoDateTime)
+});
+
+// packages/contracts/src/remote.ts
+import { Schema as Schema12 } from "effect";
+
+// packages/contracts/src/workspace.ts
+import { Schema as Schema11 } from "effect";
+var WorkspaceSourceKind = Schema11.Literals(["native", "rig-import", "manual", "remote"]);
+var WorkspaceTopologyStatus = Schema11.Literals(["empty", "ready", "degraded"]);
+var WorkspaceRemoteFleetStatus = Schema11.Literals(["empty", "ready", "degraded"]);
+var WorkspaceServiceFabricStatus = Schema11.Literals([
+  "empty",
+  "booting",
+  "ready",
+  "degraded",
+  "stopped"
+]);
+var WorkspaceRemoteHostStatus = Schema11.Literals([
+  "registering",
+  "ready",
+  "busy",
+  "degraded",
+  "draining",
+  "offline",
+  "quarantined"
+]);
+var WorkspaceTopologyServiceSummary = Schema11.Struct({
+  name: TrimmedNonEmptyString,
+  relativeRootPath: TrimmedNonEmptyString,
+  runtime: TrimmedNonEmptyString,
+  port: Schema11.NullOr(Schema11.Number),
+  healthcheck: Schema11.NullOr(TrimmedNonEmptyString),
+  sourceOfTruth: Schema11.Struct({
+    code: Schema11.NullOr(TrimmedNonEmptyString),
+    tests: Schema11.NullOr(TrimmedNonEmptyString),
+    infra: Schema11.NullOr(TrimmedNonEmptyString),
+    deploy: Schema11.NullOr(TrimmedNonEmptyString),
+    dependencies: Schema11.NullOr(TrimmedNonEmptyString)
+  }),
+  splitReadyChecklist: Schema11.Array(TrimmedNonEmptyString)
+});
+var WorkspaceTopologySummary = Schema11.Struct({
+  compiledAt: IsoDateTime,
+  status: WorkspaceTopologyStatus,
+  manifestCount: Schema11.Number,
+  serviceCount: Schema11.Number,
+  services: Schema11.Array(WorkspaceTopologyServiceSummary),
+  warnings: Schema11.Array(Schema11.String)
+});
+var WorkspaceRemoteHostSummary = Schema11.Struct({
+  id: TrimmedNonEmptyString,
+  name: TrimmedNonEmptyString,
+  baseUrl: TrimmedNonEmptyString,
+  workspacePath: Schema11.NullOr(TrimmedNonEmptyString),
+  transport: TrimmedNonEmptyString,
+  hostname: Schema11.NullOr(TrimmedNonEmptyString),
+  region: Schema11.NullOr(TrimmedNonEmptyString),
+  labels: Schema11.Array(TrimmedNonEmptyString),
+  capabilities: Schema11.Array(TrimmedNonEmptyString),
+  runtimeAdapters: Schema11.Array(TrimmedNonEmptyString),
+  status: WorkspaceRemoteHostStatus,
+  currentLeaseCount: Schema11.Number,
+  lastHeartbeatAt: Schema11.NullOr(IsoDateTime),
+  registeredAt: IsoDateTime,
+  manifestPath: TrimmedNonEmptyString
+});
+var WorkspaceRemoteFleetSummary = Schema11.Struct({
+  updatedAt: IsoDateTime,
+  status: WorkspaceRemoteFleetStatus,
+  manifestCount: Schema11.Number,
+  hostCount: Schema11.Number,
+  onlineHostCount: Schema11.Number,
+  hosts: Schema11.Array(WorkspaceRemoteHostSummary),
+  warnings: Schema11.Array(Schema11.String)
+});
+var WorkspaceServiceFabricServiceSummary = Schema11.Struct({
+  name: TrimmedNonEmptyString,
+  relativeRootPath: TrimmedNonEmptyString,
+  mode: Schema11.Literals(["stub", "process"]),
+  port: Schema11.Number,
+  healthcheck: TrimmedNonEmptyString,
+  routePrefix: Schema11.NullOr(TrimmedNonEmptyString),
+  status: Schema11.Literals(["planned", "booting", "healthy", "degraded", "failed", "stopped"]),
+  pid: Schema11.NullOr(Schema11.Number),
+  logPath: Schema11.NullOr(TrimmedNonEmptyString)
+});
+var WorkspaceServiceFabricSummary = Schema11.Struct({
+  updatedAt: IsoDateTime,
+  status: WorkspaceServiceFabricStatus,
+  serviceCount: Schema11.Number,
+  healthyServiceCount: Schema11.Number,
+  stateDir: TrimmedNonEmptyString,
+  services: Schema11.Array(WorkspaceServiceFabricServiceSummary),
+  warnings: Schema11.Array(Schema11.String)
+});
+var WorkspaceSummary = Schema11.Struct({
+  id: WorkspaceId,
+  title: TrimmedNonEmptyString,
+  rootPath: TrimmedNonEmptyString,
+  sourceKind: WorkspaceSourceKind,
+  defaultRuntimeAdapter: Schema11.optional(TrimmedNonEmptyString),
+  defaultProvider: Schema11.optional(ProviderKind),
+  defaultModel: Schema11.NullOr(TrimmedNonEmptyString),
+  topology: Schema11.optional(WorkspaceTopologySummary),
+  remoteFleet: Schema11.optional(WorkspaceRemoteFleetSummary),
+  serviceFabric: Schema11.optional(WorkspaceServiceFabricSummary),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+
+// packages/contracts/src/remote.ts
+var RemoteEndpoint = Schema12.Struct({
+  id: RemoteEndpointId,
+  alias: TrimmedNonEmptyString,
+  host: TrimmedNonEmptyString,
+  port: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1)).check(Schema12.isLessThanOrEqualTo(65535)),
+  token: Schema12.String,
+  tokenConfigured: Schema12.optional(Schema12.Boolean),
+  autoConnect: Schema12.optional(Schema12.Boolean),
+  addedAt: IsoDateTime,
+  lastConnectedAt: Schema12.NullOr(IsoDateTime)
+});
+var RemoteConnectionStatus = Schema12.Literals([
+  "disconnected",
+  "connecting",
+  "authenticating",
+  "connected",
+  "reconnecting",
+  "error"
+]);
+var RemoteConnectionSummary = Schema12.Struct({
+  endpointId: RemoteEndpointId,
+  status: RemoteConnectionStatus,
+  error: Schema12.NullOr(Schema12.String),
+  connectedAt: Schema12.NullOr(IsoDateTime),
+  tokenExpiresAt: Schema12.NullOr(IsoDateTime),
+  latencyMs: Schema12.NullOr(Schema12.Number),
+  subscribedEvents: Schema12.Array(Schema12.String)
+});
+var RemoteConnectionStatusChanged = Schema12.Struct({
+  endpointId: Schema12.String,
+  endpointAlias: Schema12.String,
+  status: RemoteConnectionStatus,
+  previousStatus: RemoteConnectionStatus,
+  error: Schema12.NullOr(Schema12.String),
+  connectedAt: Schema12.NullOr(Schema12.String),
+  latencyMs: Schema12.NullOr(Schema12.Number),
+  timestamp: Schema12.String
+});
+var EnrichedRemoteEvent = Schema12.Struct({
+  endpointId: Schema12.String,
+  endpointAlias: Schema12.String,
+  receivedAt: Schema12.String,
+  originalTimestamp: Schema12.optional(Schema12.NullOr(Schema12.String)),
+  event: Schema12.Unknown
+});
+var RemoteOrchestratorState = Schema12.Struct({
+  activeTaskId: Schema12.NullOr(Schema12.String),
+  activeIteration: Schema12.NullOr(Schema12.Number),
+  maxIterations: Schema12.Number,
+  isPaused: Schema12.Boolean,
+  isRunning: Schema12.Boolean,
+  totalCompleted: NonNegativeInt,
+  totalFailed: NonNegativeInt,
+  lastActivity: Schema12.NullOr(IsoDateTime)
+});
+var RemoteOrchestrationSummary = Schema12.Struct({
+  orchestrationId: TrimmedNonEmptyString,
+  endpointId: RemoteEndpointId,
+  status: Schema12.Literals(["running", "paused", "stopped", "completed"]),
+  totalTasks: NonNegativeInt,
+  totalGroups: NonNegativeInt,
+  maxParallelism: NonNegativeInt,
+  startedAt: IsoDateTime
+});
+var RemoteIterationOutput = Schema12.Struct({
+  taskId: Schema12.optional(Schema12.String),
+  iteration: Schema12.optional(Schema12.Number),
+  output: Schema12.optional(Schema12.String),
+  startedAt: Schema12.optional(IsoDateTime),
+  endedAt: Schema12.optional(IsoDateTime),
+  durationMs: Schema12.optional(Schema12.Number),
+  isRunning: Schema12.optional(Schema12.Boolean)
+});
+var RemoteRunnerRegisterInput = Schema12.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  name: TrimmedNonEmptyString,
+  baseUrl: TrimmedNonEmptyString,
+  workspacePath: Schema12.optional(TrimmedNonEmptyString),
+  transport: Schema12.optional(TrimmedNonEmptyString),
+  hostname: Schema12.optional(TrimmedNonEmptyString),
+  region: Schema12.optional(TrimmedNonEmptyString),
+  labels: Schema12.optional(Schema12.Array(TrimmedNonEmptyString)),
+  capabilities: Schema12.optional(Schema12.Array(TrimmedNonEmptyString)),
+  runtimeAdapters: Schema12.optional(Schema12.Array(TrimmedNonEmptyString)),
+  status: Schema12.optional(WorkspaceRemoteHostStatus),
+  currentLeaseCount: Schema12.optional(Schema12.Number)
+});
+var RemoteRunnerHeartbeatInput = Schema12.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  status: WorkspaceRemoteHostStatus,
+  currentLeaseCount: Schema12.optional(Schema12.Number),
+  observedAt: Schema12.optional(IsoDateTime)
+});
+var RemoteRunnerLifecycleResult = Schema12.Struct({
+  ok: Schema12.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime,
+  heartbeatIntervalMs: Schema12.Number
+});
+var RemoteRunClaimInput = Schema12.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runtimeAdapters: Schema12.optional(Schema12.Array(TrimmedNonEmptyString))
+});
+var RemoteRunLeaseSummary = Schema12.Struct({
+  leaseId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  workspaceId: WorkspaceId,
+  title: TrimmedNonEmptyString,
+  runtimeAdapter: TrimmedNonEmptyString,
+  model: Schema12.NullOr(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  executionTarget: RunExecutionTarget,
+  remoteHostId: Schema12.NullOr(TrimmedNonEmptyString),
+  claimedAt: IsoDateTime
+});
+var RemoteRunConversationEntry = Schema12.Struct({
+  role: Schema12.Literals(["user", "assistant", "system"]),
+  text: Schema12.String,
+  createdAt: IsoDateTime
+});
+var RemoteRunExecutionBundle = Schema12.Struct({
+  workspaceId: WorkspaceId,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  workspacePath: Schema12.NullOr(TrimmedNonEmptyString),
+  runtimeAdapter: TrimmedNonEmptyString,
+  model: Schema12.NullOr(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  prompt: Schema12.String,
+  conversation: Schema12.Array(RemoteRunConversationEntry),
+  taskId: Schema12.NullOr(TrimmedNonEmptyString),
+  taskTitle: Schema12.NullOr(TrimmedNonEmptyString)
+});
+var RemoteRunClaimResult = Schema12.Struct({
+  ok: Schema12.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime,
+  lease: Schema12.NullOr(RemoteRunLeaseSummary),
+  bundle: Schema12.NullOr(RemoteRunExecutionBundle)
+});
+var RemoteRunReleaseInput = Schema12.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  status: Schema12.optional(WorkspaceRemoteHostStatus)
+});
+var RemoteRunReleaseResult = Schema12.Struct({
+  ok: Schema12.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime
+});
+var RemoteRunStartInput = Schema12.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString
+});
+var RemoteRunStartResult = Schema12.Struct({
+  ok: Schema12.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  runtimeId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime
+});
+var RemoteRunLogInput = Schema12.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  title: TrimmedNonEmptyString,
+  detail: Schema12.optional(Schema12.String),
+  tone: Schema12.optional(EngineLogTone),
+  status: Schema12.optional(TrimmedNonEmptyString),
+  payload: Schema12.optional(Schema12.Unknown)
+});
+var RemoteRunMessageInput = Schema12.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  messageId: Schema12.optional(TrimmedNonEmptyString),
+  text: Schema12.String,
+  state: Schema12.optional(Schema12.Literals(["streaming", "completed"]))
+});
+var RemoteRunMutationResult = Schema12.Struct({
+  ok: Schema12.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime
+});
+var RemoteRunCompleteInput = Schema12.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString
+});
+var RemoteRunFailInput = Schema12.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  errorText: Schema12.optional(Schema12.String)
+});
+var RemoteRunArtifactInput = Schema12.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  kind: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  filename: TrimmedNonEmptyString,
+  contentType: TrimmedNonEmptyString,
+  contentBase64: TrimmedNonEmptyString
+});
+var RemoteRunArtifactResult = Schema12.Struct({
+  ok: Schema12.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime,
+  artifactPath: TrimmedNonEmptyString
+});
+var RemoteRunArtifactSummary = Schema12.Struct({
+  workspaceId: WorkspaceId,
+  runId: TrimmedNonEmptyString,
+  hostId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  kind: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  filename: TrimmedNonEmptyString,
+  contentType: TrimmedNonEmptyString,
+  uploadedAt: IsoDateTime,
+  byteSize: Schema12.Number,
+  artifactPath: TrimmedNonEmptyString,
+  downloadPath: TrimmedNonEmptyString
+});
+var RemoteRunArtifactsResult = Schema12.Struct({
+  workspaceId: WorkspaceId,
+  runId: TrimmedNonEmptyString,
+  artifacts: Schema12.Array(RemoteRunArtifactSummary)
+});
+
+// packages/contracts/src/engine.ts
+var EngineEvent = Schema13.Struct({
+  id: EventId,
+  sequence: NonNegativeInt,
+  createdAt: IsoDateTime,
+  type: TrimmedNonEmptyString,
+  aggregateId: TrimmedNonEmptyString,
+  payload: Schema13.Unknown
+});
+var EngineReadModel = Schema13.Struct({
+  snapshotSequence: NonNegativeInt,
+  workspaces: Schema13.Array(WorkspaceSummary),
+  graphs: Schema13.Array(GraphSummary),
+  tasks: Schema13.Array(TaskSummary),
+  runs: Schema13.Array(RunSummary),
+  runtimes: Schema13.Array(RuntimeSummary),
+  conversations: Schema13.Array(ConversationSummary),
+  messages: Schema13.Array(EngineMessage),
+  actions: Schema13.Array(EngineAction),
+  logs: Schema13.Array(EngineRunLog),
+  approvals: Schema13.Array(ApprovalSummary),
+  userInputs: Schema13.optional(Schema13.Array(UserInputRequestSummary)),
+  validations: Schema13.Array(ValidationSummary),
+  reviews: Schema13.Array(ReviewSummary),
+  artifacts: Schema13.Array(ArtifactSummary),
+  policyDecisions: Schema13.Array(PolicyDecisionSummary),
+  queue: Schema13.Array(QueueEntry),
+  worktrees: Schema13.Array(WorktreeSummary),
+  remoteEndpoints: Schema13.Array(RemoteEndpoint),
+  remoteConnections: Schema13.Array(RemoteConnectionSummary),
+  remoteOrchestrations: Schema13.Array(RemoteOrchestrationSummary),
+  updatedAt: IsoDateTime
+});
+var RuntimeAdapterKind = Schema13.Literals(["codex", "claude-code", "pi"]);
+var WorkspaceRegisterCommand = Schema13.Struct({
+  type: Schema13.Literal("workspace.register"),
+  commandId: CommandId,
+  workspaceId: WorkspaceId,
+  title: TrimmedNonEmptyString,
+  rootPath: TrimmedNonEmptyString,
+  defaultModel: Schema13.optional(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var WorkspaceImportRigCommand = Schema13.Struct({
+  type: Schema13.Literal("workspace.importRig"),
+  commandId: CommandId,
+  workspaceId: WorkspaceId,
+  rootPath: TrimmedNonEmptyString,
+  title: Schema13.optional(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var RunCreateAdhocCommand = Schema13.Struct({
+  type: Schema13.Literal("run.createAdhoc"),
+  commandId: CommandId,
+  runId: RunId,
+  workspaceId: WorkspaceId,
+  title: TrimmedNonEmptyString,
+  runtimeAdapter: Schema13.optional(RuntimeAdapterKind),
+  model: Schema13.optional(TrimmedNonEmptyString),
+  executionTarget: Schema13.optional(RunExecutionTarget),
+  remoteHostId: Schema13.optional(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode.pipe(Schema13.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema13.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  initialPrompt: Schema13.optional(Schema13.String),
+  createdAt: IsoDateTime
+});
+var RunCreateForTaskCommand = Schema13.Struct({
+  type: Schema13.Literal("run.createForTask"),
+  commandId: CommandId,
+  runId: RunId,
+  workspaceId: WorkspaceId,
+  taskId: TaskId,
+  runtimeAdapter: Schema13.optional(RuntimeAdapterKind),
+  model: Schema13.optional(TrimmedNonEmptyString),
+  executionTarget: Schema13.optional(RunExecutionTarget),
+  remoteHostId: Schema13.optional(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode.pipe(Schema13.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema13.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  createdAt: IsoDateTime
+});
+var RunSubmitUserMessageCommand = Schema13.Struct({
+  type: Schema13.Literal("run.submitUserMessage"),
+  commandId: CommandId,
+  runId: RunId,
+  messageId: MessageId,
+  text: Schema13.String,
+  attachments: Schema13.optional(Schema13.Array(Schema13.Unknown)),
+  createdAt: IsoDateTime
+});
+var RunInterruptCommand = Schema13.Struct({
+  type: Schema13.Literal("run.interrupt"),
+  commandId: CommandId,
+  runId: RunId,
+  createdAt: IsoDateTime
+});
+var RunStopCommand = Schema13.Struct({
+  type: Schema13.Literal("run.stop"),
+  commandId: CommandId,
+  runId: RunId,
+  createdAt: IsoDateTime
+});
+var RunSetRuntimeModeCommand = Schema13.Struct({
+  type: Schema13.Literal("run.setRuntimeMode"),
+  commandId: CommandId,
+  runId: RunId,
+  runtimeMode: RuntimeMode,
+  createdAt: IsoDateTime
+});
+var RunSetInteractionModeCommand = Schema13.Struct({
+  type: Schema13.Literal("run.setInteractionMode"),
+  commandId: CommandId,
+  runId: RunId,
+  interactionMode: ProviderInteractionMode,
+  createdAt: IsoDateTime
+});
+var RunRespondApprovalCommand = Schema13.Struct({
+  type: Schema13.Literal("run.respondApproval"),
+  commandId: CommandId,
+  runId: RunId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision,
+  createdAt: IsoDateTime
+});
+var RunRespondUserInputCommand = Schema13.Struct({
+  type: Schema13.Literal("run.respondUserInput"),
+  commandId: CommandId,
+  runId: RunId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers,
+  createdAt: IsoDateTime
+});
+var RuntimePrepareCommand = Schema13.Struct({
+  type: Schema13.Literal("runtime.prepare"),
+  commandId: CommandId,
+  runId: RunId,
+  workspaceId: WorkspaceId,
+  adapter: RuntimeAdapterKind,
+  executionTarget: Schema13.optional(RunExecutionTarget),
+  remoteHostId: Schema13.optional(TrimmedNonEmptyString),
+  model: Schema13.optional(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var RuntimeAttachCommand = Schema13.Struct({
+  type: Schema13.Literal("runtime.attach"),
+  commandId: CommandId,
+  runId: RunId,
+  runtimeId: EngineRuntimeId,
+  createdAt: IsoDateTime
+});
+var RuntimeDetachCommand = Schema13.Struct({
+  type: Schema13.Literal("runtime.detach"),
+  commandId: CommandId,
+  runId: RunId,
+  reason: TrimmedNonEmptyString,
+  createdAt: IsoDateTime
+});
+var GraphUpdateTaskStatusCommand = Schema13.Struct({
+  type: Schema13.Literal("graph.updateTaskStatus"),
+  commandId: CommandId,
+  taskId: TaskId,
+  status: TaskStatus,
+  createdAt: IsoDateTime
+});
+var TaskEnqueueCommand = Schema13.Struct({
+  type: Schema13.Literal("task.enqueue"),
+  commandId: CommandId,
+  taskId: TaskId,
+  score: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var WorkspaceHydrateImportedStateCommand = Schema13.Struct({
+  type: Schema13.Literal("workspace.hydrateImportedState"),
+  commandId: CommandId,
+  workspaceId: WorkspaceId,
+  rootPath: Schema13.optional(Schema13.String),
+  graph: GraphSummary,
+  tasks: Schema13.Array(TaskSummary),
+  runs: Schema13.Array(RunSummary),
+  runtimes: Schema13.Array(RuntimeSummary),
+  actions: Schema13.Array(EngineAction),
+  logs: Schema13.optional(Schema13.Array(EngineRunLog)),
+  validations: Schema13.Array(ValidationSummary),
+  reviews: Schema13.Array(ReviewSummary),
+  artifacts: Schema13.Array(ArtifactSummary),
+  policyDecisions: Schema13.Array(PolicyDecisionSummary),
+  queue: Schema13.Array(QueueEntry),
+  createdAt: IsoDateTime
+});
+var WorkspaceCompileTopologyCommand = Schema13.Struct({
+  type: Schema13.Literal("workspace.compileTopology"),
+  commandId: CommandId,
+  workspaceId: WorkspaceId,
+  rootPath: TrimmedNonEmptyString,
+  topology: WorkspaceTopologySummary,
+  createdAt: IsoDateTime
+});
+var WorkspaceSyncRemoteFleetCommand = Schema13.Struct({
+  type: Schema13.Literal("workspace.syncRemoteFleet"),
+  commandId: CommandId,
+  workspaceId: WorkspaceId,
+  rootPath: TrimmedNonEmptyString,
+  remoteFleet: WorkspaceRemoteFleetSummary,
+  createdAt: IsoDateTime
+});
+var WorkspaceSyncServiceFabricCommand = Schema13.Struct({
+  type: Schema13.Literal("workspace.syncServiceFabric"),
+  commandId: CommandId,
+  workspaceId: WorkspaceId,
+  rootPath: TrimmedNonEmptyString,
+  serviceFabric: WorkspaceServiceFabricSummary,
+  createdAt: IsoDateTime
+});
+var WorkspaceRegisterRemoteHostCommand = Schema13.Struct({
+  type: Schema13.Literal("workspace.registerRemoteHost"),
+  commandId: CommandId,
+  workspaceId: WorkspaceId,
+  host: Schema13.Struct({
+    id: TrimmedNonEmptyString,
+    name: TrimmedNonEmptyString,
+    baseUrl: TrimmedNonEmptyString,
+    workspacePath: Schema13.NullOr(TrimmedNonEmptyString),
+    transport: TrimmedNonEmptyString,
+    hostname: Schema13.NullOr(TrimmedNonEmptyString),
+    region: Schema13.NullOr(TrimmedNonEmptyString),
+    labels: Schema13.Array(TrimmedNonEmptyString),
+    capabilities: Schema13.Array(TrimmedNonEmptyString),
+    runtimeAdapters: Schema13.Array(TrimmedNonEmptyString),
+    status: Schema13.Literals([
+      "registering",
+      "ready",
+      "busy",
+      "degraded",
+      "draining",
+      "offline",
+      "quarantined"
+    ]),
+    currentLeaseCount: Schema13.Number,
+    lastHeartbeatAt: Schema13.NullOr(IsoDateTime),
+    registeredAt: IsoDateTime,
+    manifestPath: TrimmedNonEmptyString
+  }),
+  createdAt: IsoDateTime
+});
+var WorkspaceUpdateRemoteHostStatusCommand = Schema13.Struct({
+  type: Schema13.Literal("workspace.updateRemoteHostStatus"),
+  commandId: CommandId,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  status: Schema13.Literals([
+    "registering",
+    "ready",
+    "busy",
+    "degraded",
+    "draining",
+    "offline",
+    "quarantined"
+  ]),
+  currentLeaseCount: Schema13.optional(Schema13.Number),
+  lastHeartbeatAt: Schema13.optional(IsoDateTime),
+  createdAt: IsoDateTime
+});
+var RunClaimRemoteLeaseCommand = Schema13.Struct({
+  type: Schema13.Literal("run.claimRemoteLease"),
+  commandId: CommandId,
+  runId: RunId,
+  hostId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  createdAt: IsoDateTime
+});
+var RunReleaseRemoteLeaseCommand = Schema13.Struct({
+  type: Schema13.Literal("run.releaseRemoteLease"),
+  commandId: CommandId,
+  runId: RunId,
+  leaseId: TrimmedNonEmptyString,
+  createdAt: IsoDateTime
+});
+var RuntimeRecordMessageCommand = Schema13.Struct({
+  type: Schema13.Literal("runtime.recordMessage"),
+  commandId: CommandId,
+  runId: RunId,
+  messageId: MessageId,
+  role: EngineMessageRole,
+  text: Schema13.String,
+  state: EngineMessageState,
+  attachments: Schema13.optional(Schema13.Array(Schema13.Unknown)),
+  createdAt: IsoDateTime,
+  completedAt: Schema13.optional(IsoDateTime)
+});
+var RuntimeStartActionCommand = Schema13.Struct({
+  type: Schema13.Literal("runtime.startAction"),
+  commandId: CommandId,
+  runId: RunId,
+  actionId: ActionId,
+  messageId: Schema13.optional(MessageId),
+  actionType: TrimmedNonEmptyString,
+  title: TrimmedNonEmptyString,
+  detail: Schema13.optional(Schema13.String),
+  payload: Schema13.Unknown,
+  createdAt: IsoDateTime
+});
+var RuntimeCompleteActionCommand = Schema13.Struct({
+  type: Schema13.Literal("runtime.completeAction"),
+  commandId: CommandId,
+  runId: RunId,
+  actionId: ActionId,
+  state: TrimmedNonEmptyString,
+  detail: Schema13.optional(Schema13.String),
+  payload: Schema13.Unknown,
+  createdAt: IsoDateTime
+});
+var RuntimeRecordLogCommand = Schema13.Struct({
+  type: Schema13.Literal("runtime.recordLog"),
+  commandId: CommandId,
+  runId: RunId,
+  logId: TrimmedNonEmptyString,
+  title: TrimmedNonEmptyString,
+  detail: Schema13.optional(Schema13.String),
+  tone: EngineLogTone,
+  status: Schema13.optional(TrimmedNonEmptyString),
+  payload: Schema13.optional(Schema13.Unknown),
+  createdAt: IsoDateTime
+});
+var RuntimeUpdateMetadataCommand = Schema13.Struct({
+  type: Schema13.Literal("runtime.updateMetadata"),
+  commandId: CommandId,
+  runId: RunId,
+  runtimeId: EngineRuntimeId,
+  sandboxMode: Schema13.optional(EngineSandboxMode),
+  isolationMode: Schema13.optional(IsolationMode),
+  workspaceDir: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
+  homeDir: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
+  tmpDir: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
+  cacheDir: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
+  logsDir: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
+  stateDir: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
+  sessionDir: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
+  sessionLogPath: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
+  pid: Schema13.optional(NonNegativeInt),
+  worktreePath: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
+  branch: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
+  createdAt: IsoDateTime
+});
+var RuntimeRequestApprovalCommand = Schema13.Struct({
+  type: Schema13.Literal("runtime.requestApproval"),
+  commandId: CommandId,
+  runId: RunId,
+  requestId: ApprovalRequestId,
+  requestKind: TrimmedNonEmptyString,
+  actionId: Schema13.optional(ActionId),
+  payload: Schema13.Unknown,
+  createdAt: IsoDateTime
+});
+var RuntimeRequestUserInputCommand = Schema13.Struct({
+  type: Schema13.Literal("runtime.requestUserInput"),
+  commandId: CommandId,
+  runId: RunId,
+  requestId: ApprovalRequestId,
+  payload: Schema13.Unknown,
+  createdAt: IsoDateTime
+});
+var RunMarkCompletedCommand = Schema13.Struct({
+  type: Schema13.Literal("run.markCompleted"),
+  commandId: CommandId,
+  runId: RunId,
+  createdAt: IsoDateTime
+});
+var RunMarkFailedCommand = Schema13.Struct({
+  type: Schema13.Literal("run.markFailed"),
+  commandId: CommandId,
+  runId: RunId,
+  errorText: Schema13.optional(Schema13.String),
+  createdAt: IsoDateTime
+});
+var RunSetStatusCommand = Schema13.Struct({
+  type: Schema13.Literal("run.setStatus"),
+  commandId: CommandId,
+  runId: RunId,
+  status: Schema13.Literals(["created", "queued", "preparing", "running", "validating", "reviewing", "paused"]),
+  createdAt: IsoDateTime
+});
+var RuntimeRecordValidationCommand = Schema13.Struct({
+  type: Schema13.Literal("runtime.recordValidation"),
+  commandId: CommandId,
+  runId: RunId,
+  taskId: Schema13.optional(Schema13.NullOr(TaskId)),
+  validationId: ValidationResultId,
+  validatorKey: TrimmedNonEmptyString,
+  status: Schema13.Literals(["pending", "running", "passed", "failed", "skipped"]),
+  output: Schema13.Unknown,
+  startedAt: IsoDateTime,
+  completedAt: Schema13.optional(Schema13.NullOr(IsoDateTime)),
+  createdAt: IsoDateTime
+});
+var RuntimeRecordReviewCommand = Schema13.Struct({
+  type: Schema13.Literal("runtime.recordReview"),
+  commandId: CommandId,
+  runId: RunId,
+  taskId: Schema13.optional(Schema13.NullOr(TaskId)),
+  reviewId: ReviewResultId,
+  provider: TrimmedNonEmptyString,
+  mode: Schema13.Literals(["off", "advisory", "required"]),
+  status: Schema13.Literals(["pending", "running", "approved", "rejected", "error"]),
+  summary: Schema13.optional(Schema13.NullOr(Schema13.String)),
+  output: Schema13.Unknown,
+  createdAt: IsoDateTime,
+  completedAt: Schema13.optional(Schema13.NullOr(IsoDateTime))
+});
+var RuntimeRegisterArtifactCommand = Schema13.Struct({
+  type: Schema13.Literal("runtime.registerArtifact"),
+  commandId: CommandId,
+  runId: RunId,
+  taskId: Schema13.optional(Schema13.NullOr(TaskId)),
+  artifactId: ArtifactId,
+  kind: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  path: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
+  url: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
+  metadata: Schema13.optional(Schema13.Record(Schema13.String, Schema13.Unknown)),
+  createdAt: IsoDateTime
+});
+var RemoteRegisterEndpointCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.registerEndpoint"),
+  commandId: CommandId,
+  endpoint: RemoteEndpoint,
+  createdAt: IsoDateTime
+});
+var RemoteRemoveEndpointCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.removeEndpoint"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  createdAt: IsoDateTime
+});
+var RemoteUpdateEndpointCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.updateEndpoint"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  updates: Schema13.Unknown,
+  createdAt: IsoDateTime
+});
+var RemoteConnectCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.connect"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  createdAt: IsoDateTime
+});
+var RemoteDisconnectCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.disconnect"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  createdAt: IsoDateTime
+});
+var RemotePauseCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.pause"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  createdAt: IsoDateTime
+});
+var RemoteResumeCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.resume"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  createdAt: IsoDateTime
+});
+var RemoteStopCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.stop"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  createdAt: IsoDateTime
+});
+var RemoteContinueCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.continue"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  createdAt: IsoDateTime
+});
+var RemoteCreateRunForTaskCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.createRunForTask"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  taskId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  workspaceId: TrimmedNonEmptyString,
+  runtimeMode: Schema13.optional(Schema13.String),
+  interactionMode: Schema13.optional(Schema13.String),
+  createdAt: IsoDateTime
+});
+var RemoteRefreshTasksCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.refreshTasks"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  createdAt: IsoDateTime
+});
+var RemoteAddIterationsCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.addIterations"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  count: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1)),
+  createdAt: IsoDateTime
+});
+var RemoteRemoveIterationsCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.removeIterations"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  count: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1)),
+  createdAt: IsoDateTime
+});
+var RemoteOrchestrateStartCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.orchestrate.start"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  maxWorkers: Schema13.optional(Schema13.Int),
+  maxIterations: Schema13.optional(Schema13.Int),
+  directMerge: Schema13.optional(Schema13.Boolean),
+  createdAt: IsoDateTime
+});
+var RemoteOrchestratePauseCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.orchestrate.pause"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  orchestrationId: TrimmedNonEmptyString,
+  createdAt: IsoDateTime
+});
+var RemoteOrchestrateResumeCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.orchestrate.resume"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  orchestrationId: TrimmedNonEmptyString,
+  createdAt: IsoDateTime
+});
+var RemoteOrchestrateStopCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.orchestrate.stop"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  orchestrationId: TrimmedNonEmptyString,
+  createdAt: IsoDateTime
+});
+var RemoteGetPromptPreviewCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.getPromptPreview"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  taskId: TrimmedNonEmptyString,
+  createdAt: IsoDateTime
+});
+var RemoteGetIterationOutputCommand = Schema13.Struct({
+  type: Schema13.Literal("remote.getIterationOutput"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  taskId: TrimmedNonEmptyString,
+  createdAt: IsoDateTime
+});
+var EngineCommand = Schema13.Union([
+  WorkspaceRegisterCommand,
+  WorkspaceImportRigCommand,
+  WorkspaceHydrateImportedStateCommand,
+  WorkspaceCompileTopologyCommand,
+  WorkspaceSyncRemoteFleetCommand,
+  WorkspaceSyncServiceFabricCommand,
+  WorkspaceRegisterRemoteHostCommand,
+  WorkspaceUpdateRemoteHostStatusCommand,
+  RunClaimRemoteLeaseCommand,
+  RunReleaseRemoteLeaseCommand,
+  RunCreateAdhocCommand,
+  RunCreateForTaskCommand,
+  RunMarkCompletedCommand,
+  RunMarkFailedCommand,
+  RunSetStatusCommand,
+  RunSubmitUserMessageCommand,
+  RunInterruptCommand,
+  RunStopCommand,
+  RunSetRuntimeModeCommand,
+  RunSetInteractionModeCommand,
+  RunRespondApprovalCommand,
+  RunRespondUserInputCommand,
+  RuntimePrepareCommand,
+  RuntimeAttachCommand,
+  RuntimeDetachCommand,
+  RuntimeRecordMessageCommand,
+  RuntimeStartActionCommand,
+  RuntimeCompleteActionCommand,
+  RuntimeRecordLogCommand,
+  RuntimeUpdateMetadataCommand,
+  RuntimeRequestApprovalCommand,
+  RuntimeRequestUserInputCommand,
+  RuntimeRecordValidationCommand,
+  RuntimeRecordReviewCommand,
+  RuntimeRegisterArtifactCommand,
+  GraphUpdateTaskStatusCommand,
+  TaskEnqueueCommand,
+  RemoteRegisterEndpointCommand,
+  RemoteRemoveEndpointCommand,
+  RemoteUpdateEndpointCommand,
+  RemoteConnectCommand,
+  RemoteDisconnectCommand,
+  RemotePauseCommand,
+  RemoteResumeCommand,
+  RemoteStopCommand,
+  RemoteContinueCommand,
+  RemoteCreateRunForTaskCommand,
+  RemoteRefreshTasksCommand,
+  RemoteAddIterationsCommand,
+  RemoteRemoveIterationsCommand,
+  RemoteOrchestrateStartCommand,
+  RemoteOrchestratePauseCommand,
+  RemoteOrchestrateResumeCommand,
+  RemoteOrchestrateStopCommand,
+  RemoteGetPromptPreviewCommand,
+  RemoteGetIterationOutputCommand
+]);
+var EngineDispatchResult = Schema13.Struct({
+  sequence: NonNegativeInt
+});
+var EngineGetSnapshotInput = Schema13.Struct({});
+var EngineReplayEventsInput = Schema13.Struct({
+  fromSequenceExclusive: NonNegativeInt
+});
+var EngineReplayEventsResult = Schema13.Array(EngineEvent);
+var EngineGetTaskArtifactsInput = Schema13.Struct({
+  taskId: TaskId
+});
+var EngineGetTaskArtifactsResult = Schema13.Array(ArtifactSummary);
+var EngineRpcSchemas = {
+  getSnapshot: {
+    input: EngineGetSnapshotInput,
+    output: EngineReadModel
+  },
+  dispatch: {
+    input: EngineCommand,
+    output: EngineDispatchResult
+  },
+  replayEvents: {
+    input: EngineReplayEventsInput,
+    output: EngineReplayEventsResult
+  },
+  getTaskArtifacts: {
+    input: EngineGetTaskArtifactsInput,
+    output: EngineGetTaskArtifactsResult
+  }
+};
+var EngineRuntimeDefaults = Schema13.Struct({
+  runtimeAdapter: TrimmedNonEmptyString,
+  runMode: RunMode,
+  sandboxMode: EngineSandboxMode,
+  isolationMode: IsolationMode
+});
+export {
+  WorkspaceUpdateRemoteHostStatusCommand,
+  WorkspaceSyncServiceFabricCommand,
+  WorkspaceSyncRemoteFleetCommand,
+  WorkspaceRegisterRemoteHostCommand,
+  WorkspaceRegisterCommand,
+  WorkspaceImportRigCommand,
+  WorkspaceHydrateImportedStateCommand,
+  WorkspaceCompileTopologyCommand,
+  TaskEnqueueCommand,
+  RuntimeUpdateMetadataCommand,
+  RuntimeStartActionCommand,
+  RuntimeRequestUserInputCommand,
+  RuntimeRequestApprovalCommand,
+  RuntimeRegisterArtifactCommand,
+  RuntimeRecordValidationCommand,
+  RuntimeRecordReviewCommand,
+  RuntimeRecordMessageCommand,
+  RuntimeRecordLogCommand,
+  RuntimePrepareCommand,
+  RuntimeDetachCommand,
+  RuntimeCompleteActionCommand,
+  RuntimeAttachCommand,
+  RuntimeAdapterKind,
+  RunSubmitUserMessageCommand,
+  RunStopCommand,
+  RunSetStatusCommand,
+  RunSetRuntimeModeCommand,
+  RunSetInteractionModeCommand,
+  RunRespondUserInputCommand,
+  RunRespondApprovalCommand,
+  RunReleaseRemoteLeaseCommand,
+  RunMarkFailedCommand,
+  RunMarkCompletedCommand,
+  RunInterruptCommand,
+  RunCreateForTaskCommand,
+  RunCreateAdhocCommand,
+  RunClaimRemoteLeaseCommand,
+  RemoteUpdateEndpointCommand,
+  RemoteStopCommand,
+  RemoteResumeCommand,
+  RemoteRemoveIterationsCommand,
+  RemoteRemoveEndpointCommand,
+  RemoteRegisterEndpointCommand,
+  RemoteRefreshTasksCommand,
+  RemotePauseCommand,
+  RemoteOrchestrateStopCommand,
+  RemoteOrchestrateStartCommand,
+  RemoteOrchestrateResumeCommand,
+  RemoteOrchestratePauseCommand,
+  RemoteGetPromptPreviewCommand,
+  RemoteGetIterationOutputCommand,
+  RemoteDisconnectCommand,
+  RemoteCreateRunForTaskCommand,
+  RemoteContinueCommand,
+  RemoteConnectCommand,
+  RemoteAddIterationsCommand,
+  GraphUpdateTaskStatusCommand,
+  EngineRuntimeDefaults,
+  EngineRpcSchemas,
+  EngineReplayEventsResult,
+  EngineReplayEventsInput,
+  EngineReadModel,
+  EngineGetTaskArtifactsResult,
+  EngineGetTaskArtifactsInput,
+  EngineGetSnapshotInput,
+  EngineEvent,
+  EngineDispatchResult,
+  EngineCommand
+};