@h-rig/contracts 0.0.6-alpha.0

package/dist/src/index.js

@@ -0,0 +1,4545 @@
+// @bun
+// 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/workspace.ts
+import { Schema as Schema4 } from "effect";
+
+// packages/contracts/src/orchestration.ts
+import { Option, Schema as Schema3, SchemaIssue, Struct } from "effect";
+
+// packages/contracts/src/model.ts
+import { Schema as Schema2 } from "effect";
+var CODEX_REASONING_EFFORT_OPTIONS = ["xhigh", "high", "medium", "low"];
+var CodexModelOptions = Schema2.Struct({
+  reasoningEffort: Schema2.optional(Schema2.Literals(CODEX_REASONING_EFFORT_OPTIONS)),
+  fastMode: Schema2.optional(Schema2.Boolean)
+});
+var ClaudeModelOptions = Schema2.Struct({});
+var ProviderModelOptions = Schema2.Struct({
+  codex: Schema2.optional(CodexModelOptions),
+  claude: Schema2.optional(ClaudeModelOptions)
+});
+var MODEL_OPTIONS_BY_PROVIDER = {
+  codex: [
+    { slug: "gpt-5.4", name: "GPT-5.4" },
+    { slug: "gpt-5.3-codex", name: "GPT-5.3 Codex" },
+    { slug: "gpt-5.3-codex-spark", name: "GPT-5.3 Codex Spark" },
+    { slug: "gpt-5.2-codex", name: "GPT-5.2 Codex" },
+    { slug: "gpt-5.2", name: "GPT-5.2" }
+  ],
+  claude: [
+    { slug: "claude-sonnet-4-6", name: "Claude Sonnet 4.6" },
+    { slug: "claude-opus-4-1", name: "Claude Opus 4.1" },
+    { slug: "claude-3-7-sonnet-latest", name: "Claude 3.7 Sonnet" }
+  ]
+};
+var DEFAULT_MODEL_BY_PROVIDER = {
+  codex: "gpt-5.4",
+  claude: "claude-sonnet-4-6"
+};
+var MODEL_SLUG_ALIASES_BY_PROVIDER = {
+  codex: {
+    "5.4": "gpt-5.4",
+    "5.3": "gpt-5.3-codex",
+    "gpt-5.3": "gpt-5.3-codex",
+    "5.3-spark": "gpt-5.3-codex-spark",
+    "gpt-5.3-spark": "gpt-5.3-codex-spark"
+  },
+  claude: {
+    sonnet: "claude-sonnet-4-6",
+    opus: "claude-opus-4-1",
+    "3.7-sonnet": "claude-3-7-sonnet-latest"
+  }
+};
+var REASONING_EFFORT_OPTIONS_BY_PROVIDER = {
+  codex: CODEX_REASONING_EFFORT_OPTIONS,
+  claude: []
+};
+var DEFAULT_REASONING_EFFORT_BY_PROVIDER = {
+  codex: "high",
+  claude: null
+};
+
+// packages/contracts/src/orchestration.ts
+var ORCHESTRATION_WS_METHODS = {
+  getSnapshot: "orchestration.getSnapshot",
+  dispatchCommand: "orchestration.dispatchCommand",
+  getTurnDiff: "orchestration.getTurnDiff",
+  getFullThreadDiff: "orchestration.getFullThreadDiff",
+  replayEvents: "orchestration.replayEvents"
+};
+var ORCHESTRATION_WS_CHANNELS = {
+  domainEvent: "orchestration.domainEvent"
+};
+var ProviderKind = Schema3.Literals(["codex", "claude"]);
+var ProviderApprovalPolicy = Schema3.Literals([
+  "untrusted",
+  "on-failure",
+  "on-request",
+  "never"
+]);
+var ProviderSandboxMode = Schema3.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var ProviderServiceTier = Schema3.Literals(["fast", "flex"]);
+var DEFAULT_PROVIDER_KIND = "codex";
+var RuntimeMode = Schema3.Literals(["approval-required", "full-access"]);
+var DEFAULT_RUNTIME_MODE = "full-access";
+var ProviderInteractionMode = Schema3.Literals(["default", "plan"]);
+var DEFAULT_PROVIDER_INTERACTION_MODE = "default";
+var ProviderRequestKind = Schema3.Literals(["command", "file-read", "file-change"]);
+var AssistantDeliveryMode = Schema3.Literals(["buffered", "streaming"]);
+var ProviderApprovalDecision = Schema3.Literals([
+  "accept",
+  "acceptForSession",
+  "decline",
+  "cancel"
+]);
+var ProviderUserInputAnswers = Schema3.Record(Schema3.String, Schema3.Unknown);
+var PROVIDER_SEND_TURN_MAX_INPUT_CHARS = 120000;
+var PROVIDER_SEND_TURN_MAX_ATTACHMENTS = 8;
+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 CorrelationId = CommandId;
+var ChatAttachmentId = TrimmedNonEmptyString.check(Schema3.isMaxLength(CHAT_ATTACHMENT_ID_MAX_CHARS), Schema3.isPattern(/^[a-z0-9_-]+$/i));
+var ChatImageAttachment = Schema3.Struct({
+  type: Schema3.Literal("image"),
+  id: ChatAttachmentId,
+  name: TrimmedNonEmptyString.check(Schema3.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema3.isMaxLength(100), Schema3.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema3.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES))
+});
+var UploadChatImageAttachment = Schema3.Struct({
+  type: Schema3.Literal("image"),
+  name: TrimmedNonEmptyString.check(Schema3.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema3.isMaxLength(100), Schema3.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema3.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES)),
+  dataUrl: TrimmedNonEmptyString.check(Schema3.isMaxLength(PROVIDER_SEND_TURN_MAX_IMAGE_DATA_URL_CHARS))
+});
+var ChatAttachment = Schema3.Union([ChatImageAttachment]);
+var UploadChatAttachment = Schema3.Union([UploadChatImageAttachment]);
+var ProjectScriptIcon = Schema3.Literals([
+  "play",
+  "test",
+  "lint",
+  "configure",
+  "build",
+  "debug"
+]);
+var ProjectScript = Schema3.Struct({
+  id: TrimmedNonEmptyString,
+  name: TrimmedNonEmptyString,
+  command: TrimmedNonEmptyString,
+  icon: ProjectScriptIcon,
+  runOnWorktreeCreate: Schema3.Boolean
+});
+var OrchestrationProject = Schema3.Struct({
+  id: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema3.NullOr(TrimmedNonEmptyString),
+  scripts: Schema3.Array(ProjectScript),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  deletedAt: Schema3.NullOr(IsoDateTime)
+});
+var OrchestrationMessageRole = Schema3.Literals(["user", "assistant", "system"]);
+var OrchestrationMessage = Schema3.Struct({
+  id: MessageId,
+  role: OrchestrationMessageRole,
+  text: Schema3.String,
+  attachments: Schema3.optional(Schema3.Array(ChatAttachment)),
+  turnId: Schema3.NullOr(TurnId),
+  streaming: Schema3.Boolean,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var OrchestrationProposedPlanId = TrimmedNonEmptyString;
+var OrchestrationProposedPlan = Schema3.Struct({
+  id: OrchestrationProposedPlanId,
+  turnId: Schema3.NullOr(TurnId),
+  planMarkdown: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var OrchestrationSessionStatus = Schema3.Literals([
+  "idle",
+  "starting",
+  "running",
+  "ready",
+  "interrupted",
+  "stopped",
+  "error"
+]);
+var OrchestrationSession = Schema3.Struct({
+  threadId: ThreadId,
+  status: OrchestrationSessionStatus,
+  providerName: Schema3.NullOr(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  activeTurnId: Schema3.NullOr(TurnId),
+  lastError: Schema3.NullOr(TrimmedNonEmptyString),
+  updatedAt: IsoDateTime
+});
+var OrchestrationCheckpointFile = Schema3.Struct({
+  path: TrimmedNonEmptyString,
+  kind: TrimmedNonEmptyString,
+  additions: NonNegativeInt,
+  deletions: NonNegativeInt
+});
+var OrchestrationCheckpointStatus = Schema3.Literals(["ready", "missing", "error"]);
+var OrchestrationCheckpointSummary = Schema3.Struct({
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema3.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema3.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var OrchestrationThreadActivityTone = Schema3.Literals([
+  "info",
+  "tool",
+  "approval",
+  "error"
+]);
+var OrchestrationThreadActivity = Schema3.Struct({
+  id: EventId,
+  tone: OrchestrationThreadActivityTone,
+  kind: TrimmedNonEmptyString,
+  summary: TrimmedNonEmptyString,
+  payload: Schema3.Unknown,
+  turnId: Schema3.NullOr(TurnId),
+  sequence: Schema3.optional(NonNegativeInt),
+  createdAt: IsoDateTime
+});
+var OrchestrationLatestTurnState = Schema3.Literals([
+  "running",
+  "interrupted",
+  "completed",
+  "error"
+]);
+var OrchestrationLatestTurn = Schema3.Struct({
+  turnId: TurnId,
+  state: OrchestrationLatestTurnState,
+  requestedAt: IsoDateTime,
+  startedAt: Schema3.NullOr(IsoDateTime),
+  completedAt: Schema3.NullOr(IsoDateTime),
+  assistantMessageId: Schema3.NullOr(MessageId)
+});
+var OrchestrationThread = Schema3.Struct({
+  id: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema3.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema3.NullOr(TrimmedNonEmptyString),
+  latestTurn: Schema3.NullOr(OrchestrationLatestTurn),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  deletedAt: Schema3.NullOr(IsoDateTime),
+  messages: Schema3.Array(OrchestrationMessage),
+  proposedPlans: Schema3.Array(OrchestrationProposedPlan).pipe(Schema3.withDecodingDefault(() => [])),
+  activities: Schema3.Array(OrchestrationThreadActivity),
+  checkpoints: Schema3.Array(OrchestrationCheckpointSummary),
+  session: Schema3.NullOr(OrchestrationSession)
+});
+var OrchestrationReadModel = Schema3.Struct({
+  snapshotSequence: NonNegativeInt,
+  projects: Schema3.Array(OrchestrationProject),
+  threads: Schema3.Array(OrchestrationThread),
+  updatedAt: IsoDateTime
+});
+var ProjectCreateCommand = Schema3.Struct({
+  type: Schema3.Literal("project.create"),
+  commandId: CommandId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema3.optional(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var ProjectMetaUpdateCommand = Schema3.Struct({
+  type: Schema3.Literal("project.meta.update"),
+  commandId: CommandId,
+  projectId: ProjectId,
+  title: Schema3.optional(TrimmedNonEmptyString),
+  workspaceRoot: Schema3.optional(TrimmedNonEmptyString),
+  defaultModel: Schema3.optional(TrimmedNonEmptyString),
+  scripts: Schema3.optional(Schema3.Array(ProjectScript))
+});
+var ProjectDeleteCommand = Schema3.Struct({
+  type: Schema3.Literal("project.delete"),
+  commandId: CommandId,
+  projectId: ProjectId
+});
+var ThreadCreateCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.create"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema3.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema3.NullOr(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var ThreadDeleteCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.delete"),
+  commandId: CommandId,
+  threadId: ThreadId
+});
+var ThreadMetaUpdateCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.meta.update"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  title: Schema3.optional(TrimmedNonEmptyString),
+  model: Schema3.optional(TrimmedNonEmptyString),
+  branch: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  worktreePath: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString))
+});
+var ThreadRuntimeModeSetCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.runtime-mode.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  runtimeMode: RuntimeMode,
+  createdAt: IsoDateTime
+});
+var ThreadInteractionModeSetCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.interaction-mode.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  interactionMode: ProviderInteractionMode,
+  createdAt: IsoDateTime
+});
+var ThreadTurnStartCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.turn.start"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  message: Schema3.Struct({
+    messageId: MessageId,
+    role: Schema3.Literal("user"),
+    text: Schema3.String,
+    attachments: Schema3.Array(ChatAttachment)
+  }),
+  provider: Schema3.optional(ProviderKind),
+  model: Schema3.optional(TrimmedNonEmptyString),
+  serviceTier: Schema3.optional(Schema3.NullOr(ProviderServiceTier)),
+  modelOptions: Schema3.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema3.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  createdAt: IsoDateTime
+});
+var ClientThreadTurnStartCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.turn.start"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  message: Schema3.Struct({
+    messageId: MessageId,
+    role: Schema3.Literal("user"),
+    text: Schema3.String,
+    attachments: Schema3.Array(UploadChatAttachment)
+  }),
+  provider: Schema3.optional(ProviderKind),
+  model: Schema3.optional(TrimmedNonEmptyString),
+  serviceTier: Schema3.optional(Schema3.NullOr(ProviderServiceTier)),
+  modelOptions: Schema3.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema3.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  createdAt: IsoDateTime
+});
+var ThreadTurnInterruptCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.turn.interrupt"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnId: Schema3.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadApprovalRespondCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.approval.respond"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision,
+  createdAt: IsoDateTime
+});
+var ThreadUserInputRespondCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.user-input.respond"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers,
+  createdAt: IsoDateTime
+});
+var ThreadCheckpointRevertCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.checkpoint.revert"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadSessionStopCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.session.stop"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  createdAt: IsoDateTime
+});
+var DispatchableClientOrchestrationCommand = Schema3.Union([
+  ProjectCreateCommand,
+  ProjectMetaUpdateCommand,
+  ProjectDeleteCommand,
+  ThreadCreateCommand,
+  ThreadDeleteCommand,
+  ThreadMetaUpdateCommand,
+  ThreadRuntimeModeSetCommand,
+  ThreadInteractionModeSetCommand,
+  ThreadTurnStartCommand,
+  ThreadTurnInterruptCommand,
+  ThreadApprovalRespondCommand,
+  ThreadUserInputRespondCommand,
+  ThreadCheckpointRevertCommand,
+  ThreadSessionStopCommand
+]);
+var ClientOrchestrationCommand = Schema3.Union([
+  ProjectCreateCommand,
+  ProjectMetaUpdateCommand,
+  ProjectDeleteCommand,
+  ThreadCreateCommand,
+  ThreadDeleteCommand,
+  ThreadMetaUpdateCommand,
+  ThreadRuntimeModeSetCommand,
+  ThreadInteractionModeSetCommand,
+  ClientThreadTurnStartCommand,
+  ThreadTurnInterruptCommand,
+  ThreadApprovalRespondCommand,
+  ThreadUserInputRespondCommand,
+  ThreadCheckpointRevertCommand,
+  ThreadSessionStopCommand
+]);
+var ThreadSessionSetCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.session.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  session: OrchestrationSession,
+  createdAt: IsoDateTime
+});
+var ThreadMessageAssistantDeltaCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.message.assistant.delta"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  messageId: MessageId,
+  delta: Schema3.String,
+  turnId: Schema3.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadMessageAssistantCompleteCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.message.assistant.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  messageId: MessageId,
+  turnId: Schema3.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadProposedPlanUpsertCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.proposed-plan.upsert"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  proposedPlan: OrchestrationProposedPlan,
+  createdAt: IsoDateTime
+});
+var ThreadTurnDiffCompleteCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.turn.diff.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnId: TurnId,
+  completedAt: IsoDateTime,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema3.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema3.optional(MessageId),
+  checkpointTurnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadActivityAppendCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.activity.append"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  activity: OrchestrationThreadActivity,
+  createdAt: IsoDateTime
+});
+var ThreadRevertCompleteCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.revert.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var InternalOrchestrationCommand = Schema3.Union([
+  ThreadSessionSetCommand,
+  ThreadMessageAssistantDeltaCommand,
+  ThreadMessageAssistantCompleteCommand,
+  ThreadProposedPlanUpsertCommand,
+  ThreadTurnDiffCompleteCommand,
+  ThreadActivityAppendCommand,
+  ThreadRevertCompleteCommand
+]);
+var OrchestrationCommand = Schema3.Union([
+  DispatchableClientOrchestrationCommand,
+  InternalOrchestrationCommand
+]);
+var OrchestrationEventType = Schema3.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 = Schema3.Literals(["project", "thread"]);
+var OrchestrationActorKind = Schema3.Literals(["client", "server", "provider"]);
+var ProjectCreatedPayload = Schema3.Struct({
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema3.NullOr(TrimmedNonEmptyString),
+  scripts: Schema3.Array(ProjectScript),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ProjectMetaUpdatedPayload = Schema3.Struct({
+  projectId: ProjectId,
+  title: Schema3.optional(TrimmedNonEmptyString),
+  workspaceRoot: Schema3.optional(TrimmedNonEmptyString),
+  defaultModel: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  scripts: Schema3.optional(Schema3.Array(ProjectScript)),
+  updatedAt: IsoDateTime
+});
+var ProjectDeletedPayload = Schema3.Struct({
+  projectId: ProjectId,
+  deletedAt: IsoDateTime
+});
+var ThreadCreatedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema3.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema3.NullOr(TrimmedNonEmptyString),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ThreadDeletedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  deletedAt: IsoDateTime
+});
+var ThreadMetaUpdatedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  title: Schema3.optional(TrimmedNonEmptyString),
+  model: Schema3.optional(TrimmedNonEmptyString),
+  branch: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  worktreePath: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  updatedAt: IsoDateTime
+});
+var ThreadRuntimeModeSetPayload = Schema3.Struct({
+  threadId: ThreadId,
+  runtimeMode: RuntimeMode,
+  updatedAt: IsoDateTime
+});
+var ThreadInteractionModeSetPayload = Schema3.Struct({
+  threadId: ThreadId,
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  updatedAt: IsoDateTime
+});
+var ThreadMessageSentPayload = Schema3.Struct({
+  threadId: ThreadId,
+  messageId: MessageId,
+  role: OrchestrationMessageRole,
+  text: Schema3.String,
+  attachments: Schema3.optional(Schema3.Array(ChatAttachment)),
+  turnId: Schema3.NullOr(TurnId),
+  streaming: Schema3.Boolean,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ThreadTurnStartRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  messageId: MessageId,
+  provider: Schema3.optional(ProviderKind),
+  model: Schema3.optional(TrimmedNonEmptyString),
+  serviceTier: Schema3.optional(Schema3.NullOr(ProviderServiceTier)),
+  modelOptions: Schema3.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema3.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  createdAt: IsoDateTime
+});
+var ThreadTurnInterruptRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  turnId: Schema3.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadApprovalResponseRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision,
+  createdAt: IsoDateTime
+});
+var ThreadUserInputResponseRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers,
+  createdAt: IsoDateTime
+});
+var ThreadCheckpointRevertRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadRevertedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  turnCount: NonNegativeInt
+});
+var ThreadSessionStopRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  createdAt: IsoDateTime
+});
+var ThreadSessionSetPayload = Schema3.Struct({
+  threadId: ThreadId,
+  session: OrchestrationSession
+});
+var ThreadProposedPlanUpsertedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  proposedPlan: OrchestrationProposedPlan
+});
+var ThreadTurnDiffCompletedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema3.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema3.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var ThreadActivityAppendedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  activity: OrchestrationThreadActivity
+});
+var OrchestrationEventMetadata = Schema3.Struct({
+  providerTurnId: Schema3.optional(TrimmedNonEmptyString),
+  providerItemId: Schema3.optional(ProviderItemId),
+  adapterKey: Schema3.optional(TrimmedNonEmptyString),
+  requestId: Schema3.optional(ApprovalRequestId),
+  ingestedAt: Schema3.optional(IsoDateTime)
+});
+var EventBaseFields = {
+  sequence: NonNegativeInt,
+  eventId: EventId,
+  aggregateKind: OrchestrationAggregateKind,
+  aggregateId: Schema3.Union([ProjectId, ThreadId]),
+  occurredAt: IsoDateTime,
+  commandId: Schema3.NullOr(CommandId),
+  causationEventId: Schema3.NullOr(EventId),
+  correlationId: Schema3.NullOr(CommandId),
+  metadata: OrchestrationEventMetadata
+};
+var PersistedEventBaseFields = {
+  sequence: NonNegativeInt,
+  eventId: EventId,
+  aggregateKind: OrchestrationAggregateKind,
+  streamId: Schema3.Union([ProjectId, ThreadId]),
+  streamVersion: NonNegativeInt,
+  occurredAt: IsoDateTime,
+  commandId: Schema3.NullOr(CommandId),
+  causationEventId: Schema3.NullOr(EventId),
+  correlationId: Schema3.NullOr(CommandId),
+  actorKind: OrchestrationActorKind,
+  metadata: OrchestrationEventMetadata
+};
+var OrchestrationEvent = Schema3.Union([
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("project.created"),
+    payload: ProjectCreatedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("project.meta-updated"),
+    payload: ProjectMetaUpdatedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("project.deleted"),
+    payload: ProjectDeletedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.created"),
+    payload: ThreadCreatedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.deleted"),
+    payload: ThreadDeletedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.meta-updated"),
+    payload: ThreadMetaUpdatedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.runtime-mode-set"),
+    payload: ThreadRuntimeModeSetPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.interaction-mode-set"),
+    payload: ThreadInteractionModeSetPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.message-sent"),
+    payload: ThreadMessageSentPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.turn-start-requested"),
+    payload: ThreadTurnStartRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.turn-interrupt-requested"),
+    payload: ThreadTurnInterruptRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.approval-response-requested"),
+    payload: ThreadApprovalResponseRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.user-input-response-requested"),
+    payload: ThreadUserInputResponseRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.checkpoint-revert-requested"),
+    payload: ThreadCheckpointRevertRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.reverted"),
+    payload: ThreadRevertedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.session-stop-requested"),
+    payload: ThreadSessionStopRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.session-set"),
+    payload: ThreadSessionSetPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.proposed-plan-upserted"),
+    payload: ThreadProposedPlanUpsertedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.turn-diff-completed"),
+    payload: ThreadTurnDiffCompletedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.activity-appended"),
+    payload: ThreadActivityAppendedPayload
+  })
+]);
+var OrchestrationPersistedEvent = Schema3.Union([
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("project.created"),
+    payload: ProjectCreatedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("project.meta-updated"),
+    payload: ProjectMetaUpdatedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("project.deleted"),
+    payload: ProjectDeletedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.created"),
+    payload: ThreadCreatedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.deleted"),
+    payload: ThreadDeletedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.meta-updated"),
+    payload: ThreadMetaUpdatedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.runtime-mode-set"),
+    payload: ThreadRuntimeModeSetPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.interaction-mode-set"),
+    payload: ThreadInteractionModeSetPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.message-sent"),
+    payload: ThreadMessageSentPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.turn-start-requested"),
+    payload: ThreadTurnStartRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.turn-interrupt-requested"),
+    payload: ThreadTurnInterruptRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.approval-response-requested"),
+    payload: ThreadApprovalResponseRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.user-input-response-requested"),
+    payload: ThreadUserInputResponseRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.checkpoint-revert-requested"),
+    payload: ThreadCheckpointRevertRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.reverted"),
+    payload: ThreadRevertedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.session-stop-requested"),
+    payload: ThreadSessionStopRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.session-set"),
+    payload: ThreadSessionSetPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.proposed-plan-upserted"),
+    payload: ThreadProposedPlanUpsertedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.turn-diff-completed"),
+    payload: ThreadTurnDiffCompletedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.activity-appended"),
+    payload: ThreadActivityAppendedPayload
+  })
+]);
+var OrchestrationCommandReceiptStatus = Schema3.Literals(["accepted", "rejected"]);
+var TurnCountRange = Schema3.Struct({
+  fromTurnCount: NonNegativeInt,
+  toTurnCount: NonNegativeInt
+}).check(Schema3.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: Schema3.String
+}), { unsafePreserveChecks: true });
+var ProviderSessionRuntimeStatus = Schema3.Literals([
+  "starting",
+  "running",
+  "stopped",
+  "error"
+]);
+var ProjectionThreadTurnStatus = Schema3.Literals([
+  "running",
+  "completed",
+  "interrupted",
+  "error"
+]);
+var ProjectionCheckpointRow = Schema3.Struct({
+  threadId: ThreadId,
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema3.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema3.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var ProjectionPendingApprovalStatus = Schema3.Literals(["pending", "resolved"]);
+var ProjectionPendingApprovalDecision = Schema3.NullOr(ProviderApprovalDecision);
+var DispatchResult = Schema3.Struct({
+  sequence: NonNegativeInt
+});
+var OrchestrationGetSnapshotInput = Schema3.Struct({});
+var OrchestrationGetSnapshotResult = OrchestrationReadModel;
+var OrchestrationGetTurnDiffInput = TurnCountRange.mapFields(Struct.assign({ threadId: ThreadId }), { unsafePreserveChecks: true });
+var OrchestrationGetTurnDiffResult = ThreadTurnDiff;
+var OrchestrationGetFullThreadDiffInput = Schema3.Struct({
+  threadId: ThreadId,
+  toTurnCount: NonNegativeInt
+});
+var OrchestrationGetFullThreadDiffResult = ThreadTurnDiff;
+var OrchestrationReplayEventsInput = Schema3.Struct({
+  fromSequenceExclusive: NonNegativeInt
+});
+var OrchestrationReplayEventsResult = Schema3.Array(OrchestrationEvent);
+var OrchestrationRpcSchemas = {
+  getSnapshot: {
+    input: OrchestrationGetSnapshotInput,
+    output: OrchestrationGetSnapshotResult
+  },
+  dispatchCommand: {
+    input: ClientOrchestrationCommand,
+    output: DispatchResult
+  },
+  getTurnDiff: {
+    input: OrchestrationGetTurnDiffInput,
+    output: OrchestrationGetTurnDiffResult
+  },
+  getFullThreadDiff: {
+    input: OrchestrationGetFullThreadDiffInput,
+    output: OrchestrationGetFullThreadDiffResult
+  },
+  replayEvents: {
+    input: OrchestrationReplayEventsInput,
+    output: OrchestrationReplayEventsResult
+  }
+};
+
+// packages/contracts/src/workspace.ts
+var WorkspaceSourceKind = Schema4.Literals(["native", "rig-import", "manual", "remote"]);
+var WorkspaceTopologyStatus = Schema4.Literals(["empty", "ready", "degraded"]);
+var WorkspaceRemoteFleetStatus = Schema4.Literals(["empty", "ready", "degraded"]);
+var WorkspaceServiceFabricStatus = Schema4.Literals([
+  "empty",
+  "booting",
+  "ready",
+  "degraded",
+  "stopped"
+]);
+var WorkspaceRemoteHostStatus = Schema4.Literals([
+  "registering",
+  "ready",
+  "busy",
+  "degraded",
+  "draining",
+  "offline",
+  "quarantined"
+]);
+var WorkspaceTopologyServiceSummary = Schema4.Struct({
+  name: TrimmedNonEmptyString,
+  relativeRootPath: TrimmedNonEmptyString,
+  runtime: TrimmedNonEmptyString,
+  port: Schema4.NullOr(Schema4.Number),
+  healthcheck: Schema4.NullOr(TrimmedNonEmptyString),
+  sourceOfTruth: Schema4.Struct({
+    code: Schema4.NullOr(TrimmedNonEmptyString),
+    tests: Schema4.NullOr(TrimmedNonEmptyString),
+    infra: Schema4.NullOr(TrimmedNonEmptyString),
+    deploy: Schema4.NullOr(TrimmedNonEmptyString),
+    dependencies: Schema4.NullOr(TrimmedNonEmptyString)
+  }),
+  splitReadyChecklist: Schema4.Array(TrimmedNonEmptyString)
+});
+var WorkspaceTopologySummary = Schema4.Struct({
+  compiledAt: IsoDateTime,
+  status: WorkspaceTopologyStatus,
+  manifestCount: Schema4.Number,
+  serviceCount: Schema4.Number,
+  services: Schema4.Array(WorkspaceTopologyServiceSummary),
+  warnings: Schema4.Array(Schema4.String)
+});
+var WorkspaceRemoteHostSummary = Schema4.Struct({
+  id: TrimmedNonEmptyString,
+  name: TrimmedNonEmptyString,
+  baseUrl: TrimmedNonEmptyString,
+  workspacePath: Schema4.NullOr(TrimmedNonEmptyString),
+  transport: TrimmedNonEmptyString,
+  hostname: Schema4.NullOr(TrimmedNonEmptyString),
+  region: Schema4.NullOr(TrimmedNonEmptyString),
+  labels: Schema4.Array(TrimmedNonEmptyString),
+  capabilities: Schema4.Array(TrimmedNonEmptyString),
+  runtimeAdapters: Schema4.Array(TrimmedNonEmptyString),
+  status: WorkspaceRemoteHostStatus,
+  currentLeaseCount: Schema4.Number,
+  lastHeartbeatAt: Schema4.NullOr(IsoDateTime),
+  registeredAt: IsoDateTime,
+  manifestPath: TrimmedNonEmptyString
+});
+var WorkspaceRemoteFleetSummary = Schema4.Struct({
+  updatedAt: IsoDateTime,
+  status: WorkspaceRemoteFleetStatus,
+  manifestCount: Schema4.Number,
+  hostCount: Schema4.Number,
+  onlineHostCount: Schema4.Number,
+  hosts: Schema4.Array(WorkspaceRemoteHostSummary),
+  warnings: Schema4.Array(Schema4.String)
+});
+var WorkspaceServiceFabricServiceSummary = Schema4.Struct({
+  name: TrimmedNonEmptyString,
+  relativeRootPath: TrimmedNonEmptyString,
+  mode: Schema4.Literals(["stub", "process"]),
+  port: Schema4.Number,
+  healthcheck: TrimmedNonEmptyString,
+  routePrefix: Schema4.NullOr(TrimmedNonEmptyString),
+  status: Schema4.Literals(["planned", "booting", "healthy", "degraded", "failed", "stopped"]),
+  pid: Schema4.NullOr(Schema4.Number),
+  logPath: Schema4.NullOr(TrimmedNonEmptyString)
+});
+var WorkspaceServiceFabricSummary = Schema4.Struct({
+  updatedAt: IsoDateTime,
+  status: WorkspaceServiceFabricStatus,
+  serviceCount: Schema4.Number,
+  healthyServiceCount: Schema4.Number,
+  stateDir: TrimmedNonEmptyString,
+  services: Schema4.Array(WorkspaceServiceFabricServiceSummary),
+  warnings: Schema4.Array(Schema4.String)
+});
+var WorkspaceSummary = Schema4.Struct({
+  id: WorkspaceId,
+  title: TrimmedNonEmptyString,
+  rootPath: TrimmedNonEmptyString,
+  sourceKind: WorkspaceSourceKind,
+  defaultRuntimeAdapter: Schema4.optional(TrimmedNonEmptyString),
+  defaultProvider: Schema4.optional(ProviderKind),
+  defaultModel: Schema4.NullOr(TrimmedNonEmptyString),
+  topology: Schema4.optional(WorkspaceTopologySummary),
+  remoteFleet: Schema4.optional(WorkspaceRemoteFleetSummary),
+  serviceFabric: Schema4.optional(WorkspaceServiceFabricSummary),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+// packages/contracts/src/graph.ts
+import { Schema as Schema5 } from "effect";
+var TaskStatus = Schema5.Literals([
+  "draft",
+  "open",
+  "ready",
+  "queued",
+  "running",
+  "in_progress",
+  "under_review",
+  "blocked",
+  "unknown",
+  "completed",
+  "failed",
+  "cancelled",
+  "closed"
+]);
+var GraphSummary = Schema5.Struct({
+  id: GraphId,
+  workspaceId: WorkspaceId,
+  title: TrimmedNonEmptyString,
+  description: Schema5.NullOr(Schema5.String),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var TaskSummary = Schema5.Struct({
+  id: TaskId,
+  workspaceId: WorkspaceId,
+  graphId: Schema5.NullOr(GraphId),
+  externalId: Schema5.NullOr(TrimmedNonEmptyString),
+  title: TrimmedNonEmptyString,
+  description: Schema5.String,
+  status: TaskStatus,
+  priority: Schema5.NullOr(PositiveInt),
+  role: Schema5.NullOr(TrimmedNonEmptyString),
+  scope: Schema5.Array(TrimmedNonEmptyString),
+  validationKeys: Schema5.Array(TrimmedNonEmptyString),
+  sourceIssueId: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  dependencies: Schema5.optional(Schema5.Array(TrimmedNonEmptyString)),
+  parentChildDeps: Schema5.optional(Schema5.Array(TrimmedNonEmptyString)),
+  metadata: Schema5.Unknown,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var QueueEntry = Schema5.Struct({
+  taskId: TaskId,
+  score: NonNegativeInt,
+  unblockCount: NonNegativeInt,
+  position: NonNegativeInt
+});
+// packages/contracts/src/runtime.ts
+import { Schema as Schema6 } from "effect";
+var RunKind = Schema6.Literals(["adhoc", "task", "batch", "validation", "review"]);
+var RunMode = Schema6.Literals(["interactive", "autonomous", "supervised"]);
+var RunStatus = Schema6.Literals([
+  "created",
+  "queued",
+  "preparing",
+  "running",
+  "waiting-approval",
+  "waiting-user-input",
+  "validating",
+  "reviewing",
+  "completed",
+  "failed",
+  "cancelled",
+  "paused"
+]);
+var EngineSandboxMode = Schema6.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var IsolationMode = Schema6.Literals(["none", "env", "worktree"]);
+var RuntimeStatus = Schema6.Literals([
+  "prepared",
+  "starting",
+  "running",
+  "interrupted",
+  "exited",
+  "failed",
+  "destroyed"
+]);
+var RunExecutionTarget = Schema6.Literals(["local", "remote"]);
+var RunSummary = Schema6.Struct({
+  id: RunId,
+  workspaceId: WorkspaceId,
+  taskId: Schema6.NullOr(TaskId),
+  title: TrimmedNonEmptyString,
+  runKind: RunKind,
+  mode: RunMode,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  status: RunStatus,
+  runtimeAdapter: TrimmedNonEmptyString,
+  model: Schema6.NullOr(TrimmedNonEmptyString),
+  initialPrompt: Schema6.NullOr(Schema6.String),
+  executionTarget: Schema6.optional(RunExecutionTarget),
+  remoteHostId: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseId: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseClaimedAt: Schema6.optional(Schema6.NullOr(IsoDateTime)),
+  activeRuntimeId: Schema6.NullOr(EngineRuntimeId),
+  latestMessageId: Schema6.NullOr(TrimmedNonEmptyString),
+  pendingApprovalCount: NonNegativeInt,
+  pendingUserInputCount: NonNegativeInt,
+  branch: Schema6.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema6.NullOr(TrimmedNonEmptyString),
+  errorText: Schema6.NullOr(Schema6.String),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  startedAt: Schema6.NullOr(IsoDateTime),
+  completedAt: Schema6.NullOr(IsoDateTime)
+});
+var RuntimeSummary = Schema6.Struct({
+  id: EngineRuntimeId,
+  workspaceId: WorkspaceId,
+  runId: RunId,
+  adapterKind: TrimmedNonEmptyString,
+  executionTarget: Schema6.optional(RunExecutionTarget),
+  remoteHostId: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
+  status: RuntimeStatus,
+  sandboxMode: EngineSandboxMode,
+  isolationMode: IsolationMode,
+  workspaceDir: Schema6.NullOr(TrimmedNonEmptyString),
+  homeDir: Schema6.NullOr(TrimmedNonEmptyString),
+  tmpDir: Schema6.NullOr(TrimmedNonEmptyString),
+  cacheDir: Schema6.NullOr(TrimmedNonEmptyString),
+  logsDir: Schema6.NullOr(TrimmedNonEmptyString),
+  stateDir: Schema6.NullOr(TrimmedNonEmptyString),
+  sessionDir: Schema6.NullOr(TrimmedNonEmptyString),
+  sessionLogPath: Schema6.NullOr(TrimmedNonEmptyString),
+  pid: Schema6.NullOr(NonNegativeInt),
+  startedAt: Schema6.NullOr(IsoDateTime),
+  updatedAt: IsoDateTime,
+  exitedAt: Schema6.NullOr(IsoDateTime)
+});
+var ApprovalStatus = Schema6.Literals(["pending", "resolved"]);
+var ApprovalSummary = Schema6.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  actionId: Schema6.NullOr(TrimmedNonEmptyString),
+  requestKind: TrimmedNonEmptyString,
+  status: ApprovalStatus,
+  payload: Schema6.Unknown,
+  createdAt: IsoDateTime,
+  resolvedAt: Schema6.NullOr(IsoDateTime)
+});
+var UserInputRequestSummary = Schema6.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  status: ApprovalStatus,
+  payload: Schema6.Unknown,
+  createdAt: IsoDateTime,
+  resolvedAt: Schema6.NullOr(IsoDateTime)
+});
+var WorktreeSummary = Schema6.Struct({
+  id: WorktreeId,
+  workspaceId: WorkspaceId,
+  runId: RunId,
+  taskId: Schema6.NullOr(TaskId),
+  branchName: TrimmedNonEmptyString,
+  path: TrimmedNonEmptyString,
+  status: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  cleanedAt: Schema6.NullOr(IsoDateTime)
+});
+// packages/contracts/src/conversation.ts
+import { Schema as Schema7 } from "effect";
+var EngineMessageRole = Schema7.Literals(["user", "assistant", "system"]);
+var EngineMessageState = Schema7.Literals([
+  "streaming",
+  "completed",
+  "interrupted",
+  "errored"
+]);
+var ConversationSummary = Schema7.Struct({
+  id: ConversationId,
+  runId: RunId,
+  title: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var EngineMessage = Schema7.Struct({
+  id: MessageId,
+  conversationId: ConversationId,
+  role: EngineMessageRole,
+  text: Schema7.String,
+  attachments: Schema7.Array(Schema7.Unknown),
+  state: EngineMessageState,
+  createdAt: IsoDateTime,
+  completedAt: Schema7.NullOr(IsoDateTime)
+});
+var EngineAction = Schema7.Struct({
+  id: ActionId,
+  runId: RunId,
+  messageId: Schema7.NullOr(MessageId),
+  actionType: TrimmedNonEmptyString,
+  title: TrimmedNonEmptyString,
+  detail: Schema7.NullOr(Schema7.String),
+  state: TrimmedNonEmptyString,
+  payload: Schema7.Unknown,
+  startedAt: IsoDateTime,
+  completedAt: Schema7.NullOr(IsoDateTime)
+});
+var EngineLogTone = Schema7.Literals(["thinking", "tool", "info", "error"]);
+var EngineRunLog = Schema7.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  title: TrimmedNonEmptyString,
+  detail: Schema7.NullOr(Schema7.String),
+  tone: EngineLogTone,
+  status: Schema7.NullOr(TrimmedNonEmptyString),
+  payload: Schema7.Unknown,
+  createdAt: IsoDateTime
+});
+// packages/contracts/src/plugin.ts
+import { Schema as Schema8 } from "effect";
+var ValidatorCategory = Schema8.Literals([
+  "boundary",
+  "contract",
+  "integration",
+  "regression",
+  "external",
+  "custom"
+]);
+var ValidatorRegistration = Schema8.Struct({
+  id: Schema8.String,
+  category: ValidatorCategory,
+  description: Schema8.optional(Schema8.String)
+});
+var HookEvent = Schema8.Literals([
+  "PreToolUse",
+  "PostToolUse",
+  "UserPromptSubmit",
+  "Stop",
+  "SessionStart",
+  "SessionEnd"
+]);
+var HookMatcher = Schema8.Union([
+  Schema8.Struct({ kind: Schema8.Literal("all") }),
+  Schema8.Struct({ kind: Schema8.Literal("tool"), name: Schema8.String }),
+  Schema8.Struct({ kind: Schema8.Literal("glob"), pattern: Schema8.String })
+]);
+var HookRegistration = Schema8.Struct({
+  id: Schema8.String,
+  event: HookEvent,
+  matcher: HookMatcher,
+  command: Schema8.optional(Schema8.String),
+  description: Schema8.optional(Schema8.String)
+});
+var SkillRegistration = Schema8.Struct({
+  id: Schema8.String,
+  path: Schema8.String,
+  description: Schema8.optional(Schema8.String)
+});
+var RepoSourceRegistration = Schema8.Struct({
+  id: Schema8.String,
+  url: Schema8.String,
+  defaultPath: Schema8.optional(Schema8.String),
+  description: Schema8.optional(Schema8.String),
+  defaultBranch: Schema8.optional(Schema8.String),
+  remoteEnvVar: Schema8.optional(Schema8.String),
+  checkoutEnvVar: Schema8.optional(Schema8.String)
+});
+var AgentRoleRegistration = Schema8.Struct({
+  id: Schema8.String,
+  defaultModel: Schema8.optional(Schema8.String),
+  description: Schema8.optional(Schema8.String)
+});
+var TaskFieldExtension = Schema8.Struct({
+  id: Schema8.String,
+  fieldName: Schema8.String,
+  schemaJson: Schema8.String
+});
+var TaskSourceKind = Schema8.String;
+var TaskSourceRegistration = Schema8.Struct({
+  id: Schema8.String,
+  kind: Schema8.String,
+  description: Schema8.optional(Schema8.String)
+});
+var CliCommandRegistration = Schema8.Struct({
+  id: Schema8.String,
+  command: Schema8.String,
+  description: Schema8.optional(Schema8.String)
+});
+var PluginContributes = Schema8.Struct({
+  validators: Schema8.optional(Schema8.Array(ValidatorRegistration)),
+  hooks: Schema8.optional(Schema8.Array(HookRegistration)),
+  skills: Schema8.optional(Schema8.Array(SkillRegistration)),
+  repoSources: Schema8.optional(Schema8.Array(RepoSourceRegistration)),
+  agentRoles: Schema8.optional(Schema8.Array(AgentRoleRegistration)),
+  taskFieldSchemas: Schema8.optional(Schema8.Array(TaskFieldExtension)),
+  taskSources: Schema8.optional(Schema8.Array(TaskSourceRegistration)),
+  cliCommands: Schema8.optional(Schema8.Array(CliCommandRegistration))
+});
+var RigPlugin = Schema8.Struct({
+  name: Schema8.String,
+  version: Schema8.String,
+  contributes: Schema8.optional(PluginContributes)
+});
+// packages/contracts/src/config.ts
+import { Schema as Schema9 } from "effect";
+var WorkspaceIsolation = Schema9.Literals([
+  "worktree",
+  "directory"
+]);
+var ScopeSearchPrefix = Schema9.Struct({
+  prefix: Schema9.String,
+  matchStartsWith: Schema9.optional(Schema9.Array(Schema9.String)),
+  matchExact: Schema9.optional(Schema9.Array(Schema9.String))
+});
+var ScopeNormalizationRules = Schema9.Struct({
+  stripPrefixes: Schema9.optional(Schema9.Array(Schema9.String)),
+  searchPrefixes: Schema9.optional(Schema9.Array(ScopeSearchPrefix))
+});
+var WorkspaceConfig = Schema9.Struct({
+  mainRepo: Schema9.String,
+  isolation: WorkspaceIsolation,
+  scopeNormalization: Schema9.optional(ScopeNormalizationRules)
+});
+var TaskSourceConfig = Schema9.Struct({
+  kind: Schema9.String,
+  path: Schema9.optional(Schema9.String),
+  owner: Schema9.optional(Schema9.String),
+  repo: Schema9.optional(Schema9.String),
+  labels: Schema9.optional(Schema9.Array(Schema9.String)),
+  state: Schema9.optional(Schema9.Literals(["open", "closed", "all"])),
+  url: Schema9.optional(Schema9.String),
+  options: Schema9.optional(Schema9.Record(Schema9.String, Schema9.Unknown))
+});
+var RuntimeHarness = Schema9.Literals(["pi", "claude-code", "codex"]);
+var RigRuntimeMode = Schema9.Literals(["yolo", "approval-required"]);
+var RuntimeConfig = Schema9.Struct({
+  agentRoles: Schema9.optional(Schema9.Record(Schema9.String, Schema9.Unknown)),
+  timeouts: Schema9.optional(Schema9.Record(Schema9.String, Schema9.Number)),
+  harness: Schema9.optional(RuntimeHarness),
+  model: Schema9.optional(Schema9.String),
+  mode: Schema9.optional(RigRuntimeMode)
+});
+var ProjectIdentity = Schema9.Struct({
+  name: Schema9.String,
+  repo: Schema9.optional(Schema9.String)
+});
+var PlanningConfig = Schema9.Struct({
+  mode: Schema9.optional(Schema9.Literals(["auto", "always", "off"])),
+  requireForLabels: Schema9.optional(Schema9.Array(Schema9.String)),
+  skipForLabels: Schema9.optional(Schema9.Array(Schema9.String))
+});
+var GitHubProjectStatusConfig = Schema9.Struct({
+  enabled: Schema9.optional(Schema9.Boolean),
+  projectId: Schema9.optional(Schema9.String),
+  statusFieldId: Schema9.optional(Schema9.String),
+  statuses: Schema9.optional(Schema9.Struct({
+    running: Schema9.optional(Schema9.String),
+    prOpen: Schema9.optional(Schema9.String),
+    ciFixing: Schema9.optional(Schema9.String),
+    done: Schema9.optional(Schema9.String),
+    needsAttention: Schema9.optional(Schema9.String)
+  }))
+});
+var GitHubConfig = Schema9.Struct({
+  issueUpdates: Schema9.optional(Schema9.Literals(["lifecycle", "minimal", "off"])),
+  projects: Schema9.optional(GitHubProjectStatusConfig)
+});
+var AutomationConfig = Schema9.Struct({
+  maxValidationAttempts: Schema9.optional(Schema9.Number),
+  maxPrFixIterations: Schema9.optional(Schema9.Number)
+});
+var PullRequestConfig = Schema9.Struct({
+  mode: Schema9.optional(Schema9.Literals(["auto", "ask", "off"])),
+  watchChecks: Schema9.optional(Schema9.Boolean),
+  autoFixChecks: Schema9.optional(Schema9.Boolean),
+  autoFixReview: Schema9.optional(Schema9.Boolean)
+});
+var MergeConfig = Schema9.Struct({
+  mode: Schema9.optional(Schema9.Literals(["auto", "off", "pr-ready"])),
+  method: Schema9.optional(Schema9.Literals(["repo-default", "squash", "merge", "rebase"])),
+  deleteBranch: Schema9.optional(Schema9.Union([Schema9.Literal("repo-default"), Schema9.Boolean])),
+  allowedFailures: Schema9.optional(Schema9.Array(Schema9.String)),
+  bypass: Schema9.optional(Schema9.Boolean)
+});
+var IssueAnalysisConfig = Schema9.Struct({
+  enabled: Schema9.optional(Schema9.Boolean),
+  harness: Schema9.optional(Schema9.Literal("pi")),
+  model: Schema9.optional(Schema9.String),
+  mode: Schema9.optional(Schema9.Literals(["continuous", "off"]))
+});
+var ReviewConfig = Schema9.Struct({
+  mode: Schema9.optional(Schema9.Literals(["off", "advisory", "required"])),
+  provider: Schema9.optional(Schema9.Literal("greptile"))
+});
+var RigConfig = Schema9.Struct({
+  project: ProjectIdentity,
+  plugins: Schema9.Array(RigPlugin),
+  taskSource: TaskSourceConfig,
+  workspace: WorkspaceConfig,
+  runtime: Schema9.optional(RuntimeConfig),
+  planning: Schema9.optional(PlanningConfig),
+  github: Schema9.optional(GitHubConfig),
+  automation: Schema9.optional(AutomationConfig),
+  pr: Schema9.optional(PullRequestConfig),
+  merge: Schema9.optional(MergeConfig),
+  review: Schema9.optional(ReviewConfig),
+  issueAnalysis: Schema9.optional(IssueAnalysisConfig)
+});
+// packages/contracts/src/policy.ts
+import { Schema as Schema10 } from "effect";
+var PolicyDecision = Schema10.Literals(["allow", "warn", "block"]);
+var PolicyMode = Schema10.Literals(["off", "observe", "enforce"]);
+var PolicyDecisionSummary = Schema10.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  actionId: Schema10.NullOr(ActionId),
+  decision: PolicyDecision,
+  mode: PolicyMode,
+  matchedRules: Schema10.Array(TrimmedNonEmptyString),
+  reason: Schema10.String,
+  createdAt: IsoDateTime
+});
+// packages/contracts/src/validation.ts
+import { Schema as Schema11 } from "effect";
+var ValidationStatus = Schema11.Literals([
+  "pending",
+  "running",
+  "passed",
+  "failed",
+  "skipped"
+]);
+var ValidationSummary = Schema11.Struct({
+  id: ValidationResultId,
+  runId: RunId,
+  taskId: Schema11.NullOr(TaskId),
+  validatorKey: TrimmedNonEmptyString,
+  status: ValidationStatus,
+  output: Schema11.Unknown,
+  startedAt: IsoDateTime,
+  completedAt: Schema11.NullOr(IsoDateTime)
+});
+// packages/contracts/src/review.ts
+import { Schema as Schema12 } from "effect";
+var ReviewMode = Schema12.Literals(["off", "advisory", "required"]);
+var ReviewStatus = Schema12.Literals(["pending", "running", "approved", "rejected", "error"]);
+var ReviewSummary = Schema12.Struct({
+  id: ReviewResultId,
+  runId: RunId,
+  taskId: Schema12.NullOr(TaskId),
+  provider: TrimmedNonEmptyString,
+  mode: ReviewMode,
+  status: ReviewStatus,
+  summary: Schema12.NullOr(Schema12.String),
+  output: Schema12.Unknown,
+  createdAt: IsoDateTime,
+  completedAt: Schema12.NullOr(IsoDateTime)
+});
+// packages/contracts/src/artifact.ts
+import { Schema as Schema13 } from "effect";
+var ArtifactSummary = Schema13.Struct({
+  id: ArtifactId,
+  runId: RunId,
+  taskId: Schema13.NullOr(TaskId),
+  kind: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  path: Schema13.NullOr(TrimmedNonEmptyString),
+  url: Schema13.NullOr(TrimmedNonEmptyString),
+  metadata: Schema13.Record(Schema13.String, Schema13.Unknown),
+  createdAt: IsoDateTime
+});
+// packages/contracts/src/engine.ts
+import { Schema as Schema15 } from "effect";
+
+// packages/contracts/src/remote.ts
+import { Schema as Schema14 } from "effect";
+var RemoteEndpoint = Schema14.Struct({
+  id: RemoteEndpointId,
+  alias: TrimmedNonEmptyString,
+  host: TrimmedNonEmptyString,
+  port: Schema14.Int.check(Schema14.isGreaterThanOrEqualTo(1)).check(Schema14.isLessThanOrEqualTo(65535)),
+  token: Schema14.String,
+  tokenConfigured: Schema14.optional(Schema14.Boolean),
+  autoConnect: Schema14.optional(Schema14.Boolean),
+  addedAt: IsoDateTime,
+  lastConnectedAt: Schema14.NullOr(IsoDateTime)
+});
+var RemoteConnectionStatus = Schema14.Literals([
+  "disconnected",
+  "connecting",
+  "authenticating",
+  "connected",
+  "reconnecting",
+  "error"
+]);
+var RemoteConnectionSummary = Schema14.Struct({
+  endpointId: RemoteEndpointId,
+  status: RemoteConnectionStatus,
+  error: Schema14.NullOr(Schema14.String),
+  connectedAt: Schema14.NullOr(IsoDateTime),
+  tokenExpiresAt: Schema14.NullOr(IsoDateTime),
+  latencyMs: Schema14.NullOr(Schema14.Number),
+  subscribedEvents: Schema14.Array(Schema14.String)
+});
+var RemoteConnectionStatusChanged = Schema14.Struct({
+  endpointId: Schema14.String,
+  endpointAlias: Schema14.String,
+  status: RemoteConnectionStatus,
+  previousStatus: RemoteConnectionStatus,
+  error: Schema14.NullOr(Schema14.String),
+  connectedAt: Schema14.NullOr(Schema14.String),
+  latencyMs: Schema14.NullOr(Schema14.Number),
+  timestamp: Schema14.String
+});
+var EnrichedRemoteEvent = Schema14.Struct({
+  endpointId: Schema14.String,
+  endpointAlias: Schema14.String,
+  receivedAt: Schema14.String,
+  originalTimestamp: Schema14.optional(Schema14.NullOr(Schema14.String)),
+  event: Schema14.Unknown
+});
+var RemoteOrchestratorState = Schema14.Struct({
+  activeTaskId: Schema14.NullOr(Schema14.String),
+  activeIteration: Schema14.NullOr(Schema14.Number),
+  maxIterations: Schema14.Number,
+  isPaused: Schema14.Boolean,
+  isRunning: Schema14.Boolean,
+  totalCompleted: NonNegativeInt,
+  totalFailed: NonNegativeInt,
+  lastActivity: Schema14.NullOr(IsoDateTime)
+});
+var RemoteOrchestrationSummary = Schema14.Struct({
+  orchestrationId: TrimmedNonEmptyString,
+  endpointId: RemoteEndpointId,
+  status: Schema14.Literals(["running", "paused", "stopped", "completed"]),
+  totalTasks: NonNegativeInt,
+  totalGroups: NonNegativeInt,
+  maxParallelism: NonNegativeInt,
+  startedAt: IsoDateTime
+});
+var RemoteIterationOutput = Schema14.Struct({
+  taskId: Schema14.optional(Schema14.String),
+  iteration: Schema14.optional(Schema14.Number),
+  output: Schema14.optional(Schema14.String),
+  startedAt: Schema14.optional(IsoDateTime),
+  endedAt: Schema14.optional(IsoDateTime),
+  durationMs: Schema14.optional(Schema14.Number),
+  isRunning: Schema14.optional(Schema14.Boolean)
+});
+var RemoteRunnerRegisterInput = Schema14.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  name: TrimmedNonEmptyString,
+  baseUrl: TrimmedNonEmptyString,
+  workspacePath: Schema14.optional(TrimmedNonEmptyString),
+  transport: Schema14.optional(TrimmedNonEmptyString),
+  hostname: Schema14.optional(TrimmedNonEmptyString),
+  region: Schema14.optional(TrimmedNonEmptyString),
+  labels: Schema14.optional(Schema14.Array(TrimmedNonEmptyString)),
+  capabilities: Schema14.optional(Schema14.Array(TrimmedNonEmptyString)),
+  runtimeAdapters: Schema14.optional(Schema14.Array(TrimmedNonEmptyString)),
+  status: Schema14.optional(WorkspaceRemoteHostStatus),
+  currentLeaseCount: Schema14.optional(Schema14.Number)
+});
+var RemoteRunnerHeartbeatInput = Schema14.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  status: WorkspaceRemoteHostStatus,
+  currentLeaseCount: Schema14.optional(Schema14.Number),
+  observedAt: Schema14.optional(IsoDateTime)
+});
+var RemoteRunnerLifecycleResult = Schema14.Struct({
+  ok: Schema14.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime,
+  heartbeatIntervalMs: Schema14.Number
+});
+var RemoteRunClaimInput = Schema14.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runtimeAdapters: Schema14.optional(Schema14.Array(TrimmedNonEmptyString))
+});
+var RemoteRunLeaseSummary = Schema14.Struct({
+  leaseId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  workspaceId: WorkspaceId,
+  title: TrimmedNonEmptyString,
+  runtimeAdapter: TrimmedNonEmptyString,
+  model: Schema14.NullOr(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  executionTarget: RunExecutionTarget,
+  remoteHostId: Schema14.NullOr(TrimmedNonEmptyString),
+  claimedAt: IsoDateTime
+});
+var RemoteRunConversationEntry = Schema14.Struct({
+  role: Schema14.Literals(["user", "assistant", "system"]),
+  text: Schema14.String,
+  createdAt: IsoDateTime
+});
+var RemoteRunExecutionBundle = Schema14.Struct({
+  workspaceId: WorkspaceId,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  workspacePath: Schema14.NullOr(TrimmedNonEmptyString),
+  runtimeAdapter: TrimmedNonEmptyString,
+  model: Schema14.NullOr(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  prompt: Schema14.String,
+  conversation: Schema14.Array(RemoteRunConversationEntry),
+  taskId: Schema14.NullOr(TrimmedNonEmptyString),
+  taskTitle: Schema14.NullOr(TrimmedNonEmptyString)
+});
+var RemoteRunClaimResult = Schema14.Struct({
+  ok: Schema14.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime,
+  lease: Schema14.NullOr(RemoteRunLeaseSummary),
+  bundle: Schema14.NullOr(RemoteRunExecutionBundle)
+});
+var RemoteRunReleaseInput = Schema14.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  status: Schema14.optional(WorkspaceRemoteHostStatus)
+});
+var RemoteRunReleaseResult = Schema14.Struct({
+  ok: Schema14.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime
+});
+var RemoteRunStartInput = Schema14.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString
+});
+var RemoteRunStartResult = Schema14.Struct({
+  ok: Schema14.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  runtimeId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime
+});
+var RemoteRunLogInput = Schema14.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  title: TrimmedNonEmptyString,
+  detail: Schema14.optional(Schema14.String),
+  tone: Schema14.optional(EngineLogTone),
+  status: Schema14.optional(TrimmedNonEmptyString),
+  payload: Schema14.optional(Schema14.Unknown)
+});
+var RemoteRunMessageInput = Schema14.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  messageId: Schema14.optional(TrimmedNonEmptyString),
+  text: Schema14.String,
+  state: Schema14.optional(Schema14.Literals(["streaming", "completed"]))
+});
+var RemoteRunMutationResult = Schema14.Struct({
+  ok: Schema14.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime
+});
+var RemoteRunCompleteInput = Schema14.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString
+});
+var RemoteRunFailInput = Schema14.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  errorText: Schema14.optional(Schema14.String)
+});
+var RemoteRunArtifactInput = Schema14.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  kind: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  filename: TrimmedNonEmptyString,
+  contentType: TrimmedNonEmptyString,
+  contentBase64: TrimmedNonEmptyString
+});
+var RemoteRunArtifactResult = Schema14.Struct({
+  ok: Schema14.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime,
+  artifactPath: TrimmedNonEmptyString
+});
+var RemoteRunArtifactSummary = Schema14.Struct({
+  workspaceId: WorkspaceId,
+  runId: TrimmedNonEmptyString,
+  hostId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  kind: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  filename: TrimmedNonEmptyString,
+  contentType: TrimmedNonEmptyString,
+  uploadedAt: IsoDateTime,
+  byteSize: Schema14.Number,
+  artifactPath: TrimmedNonEmptyString,
+  downloadPath: TrimmedNonEmptyString
+});
+var RemoteRunArtifactsResult = Schema14.Struct({
+  workspaceId: WorkspaceId,
+  runId: TrimmedNonEmptyString,
+  artifacts: Schema14.Array(RemoteRunArtifactSummary)
+});
+
+// packages/contracts/src/engine.ts
+var EngineEvent = Schema15.Struct({
+  id: EventId,
+  sequence: NonNegativeInt,
+  createdAt: IsoDateTime,
+  type: TrimmedNonEmptyString,
+  aggregateId: TrimmedNonEmptyString,
+  payload: Schema15.Unknown
+});
+var EngineReadModel = Schema15.Struct({
+  snapshotSequence: NonNegativeInt,
+  workspaces: Schema15.Array(WorkspaceSummary),
+  graphs: Schema15.Array(GraphSummary),
+  tasks: Schema15.Array(TaskSummary),
+  runs: Schema15.Array(RunSummary),
+  runtimes: Schema15.Array(RuntimeSummary),
+  conversations: Schema15.Array(ConversationSummary),
+  messages: Schema15.Array(EngineMessage),
+  actions: Schema15.Array(EngineAction),
+  logs: Schema15.Array(EngineRunLog),
+  approvals: Schema15.Array(ApprovalSummary),
+  userInputs: Schema15.optional(Schema15.Array(UserInputRequestSummary)),
+  validations: Schema15.Array(ValidationSummary),
+  reviews: Schema15.Array(ReviewSummary),
+  artifacts: Schema15.Array(ArtifactSummary),
+  policyDecisions: Schema15.Array(PolicyDecisionSummary),
+  queue: Schema15.Array(QueueEntry),
+  worktrees: Schema15.Array(WorktreeSummary),
+  remoteEndpoints: Schema15.Array(RemoteEndpoint),
+  remoteConnections: Schema15.Array(RemoteConnectionSummary),
+  remoteOrchestrations: Schema15.Array(RemoteOrchestrationSummary),
+  updatedAt: IsoDateTime
+});
+var RuntimeAdapterKind = Schema15.Literals(["codex", "claude-code", "pi"]);
+var WorkspaceRegisterCommand = Schema15.Struct({
+  type: Schema15.Literal("workspace.register"),
+  commandId: CommandId,
+  workspaceId: WorkspaceId,
+  title: TrimmedNonEmptyString,
+  rootPath: TrimmedNonEmptyString,
+  defaultModel: Schema15.optional(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var WorkspaceImportRigCommand = Schema15.Struct({
+  type: Schema15.Literal("workspace.importRig"),
+  commandId: CommandId,
+  workspaceId: WorkspaceId,
+  rootPath: TrimmedNonEmptyString,
+  title: Schema15.optional(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var RunCreateAdhocCommand = Schema15.Struct({
+  type: Schema15.Literal("run.createAdhoc"),
+  commandId: CommandId,
+  runId: RunId,
+  workspaceId: WorkspaceId,
+  title: TrimmedNonEmptyString,
+  runtimeAdapter: Schema15.optional(RuntimeAdapterKind),
+  model: Schema15.optional(TrimmedNonEmptyString),
+  executionTarget: Schema15.optional(RunExecutionTarget),
+  remoteHostId: Schema15.optional(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode.pipe(Schema15.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema15.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  initialPrompt: Schema15.optional(Schema15.String),
+  createdAt: IsoDateTime
+});
+var RunCreateForTaskCommand = Schema15.Struct({
+  type: Schema15.Literal("run.createForTask"),
+  commandId: CommandId,
+  runId: RunId,
+  workspaceId: WorkspaceId,
+  taskId: TaskId,
+  runtimeAdapter: Schema15.optional(RuntimeAdapterKind),
+  model: Schema15.optional(TrimmedNonEmptyString),
+  executionTarget: Schema15.optional(RunExecutionTarget),
+  remoteHostId: Schema15.optional(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode.pipe(Schema15.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema15.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  createdAt: IsoDateTime
+});
+var RunSubmitUserMessageCommand = Schema15.Struct({
+  type: Schema15.Literal("run.submitUserMessage"),
+  commandId: CommandId,
+  runId: RunId,
+  messageId: MessageId,
+  text: Schema15.String,
+  attachments: Schema15.optional(Schema15.Array(Schema15.Unknown)),
+  createdAt: IsoDateTime
+});
+var RunInterruptCommand = Schema15.Struct({
+  type: Schema15.Literal("run.interrupt"),
+  commandId: CommandId,
+  runId: RunId,
+  createdAt: IsoDateTime
+});
+var RunStopCommand = Schema15.Struct({
+  type: Schema15.Literal("run.stop"),
+  commandId: CommandId,
+  runId: RunId,
+  createdAt: IsoDateTime
+});
+var RunSetRuntimeModeCommand = Schema15.Struct({
+  type: Schema15.Literal("run.setRuntimeMode"),
+  commandId: CommandId,
+  runId: RunId,
+  runtimeMode: RuntimeMode,
+  createdAt: IsoDateTime
+});
+var RunSetInteractionModeCommand = Schema15.Struct({
+  type: Schema15.Literal("run.setInteractionMode"),
+  commandId: CommandId,
+  runId: RunId,
+  interactionMode: ProviderInteractionMode,
+  createdAt: IsoDateTime
+});
+var RunRespondApprovalCommand = Schema15.Struct({
+  type: Schema15.Literal("run.respondApproval"),
+  commandId: CommandId,
+  runId: RunId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision,
+  createdAt: IsoDateTime
+});
+var RunRespondUserInputCommand = Schema15.Struct({
+  type: Schema15.Literal("run.respondUserInput"),
+  commandId: CommandId,
+  runId: RunId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers,
+  createdAt: IsoDateTime
+});
+var RuntimePrepareCommand = Schema15.Struct({
+  type: Schema15.Literal("runtime.prepare"),
+  commandId: CommandId,
+  runId: RunId,
+  workspaceId: WorkspaceId,
+  adapter: RuntimeAdapterKind,
+  executionTarget: Schema15.optional(RunExecutionTarget),
+  remoteHostId: Schema15.optional(TrimmedNonEmptyString),
+  model: Schema15.optional(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var RuntimeAttachCommand = Schema15.Struct({
+  type: Schema15.Literal("runtime.attach"),
+  commandId: CommandId,
+  runId: RunId,
+  runtimeId: EngineRuntimeId,
+  createdAt: IsoDateTime
+});
+var RuntimeDetachCommand = Schema15.Struct({
+  type: Schema15.Literal("runtime.detach"),
+  commandId: CommandId,
+  runId: RunId,
+  reason: TrimmedNonEmptyString,
+  createdAt: IsoDateTime
+});
+var GraphUpdateTaskStatusCommand = Schema15.Struct({
+  type: Schema15.Literal("graph.updateTaskStatus"),
+  commandId: CommandId,
+  taskId: TaskId,
+  status: TaskStatus,
+  createdAt: IsoDateTime
+});
+var TaskEnqueueCommand = Schema15.Struct({
+  type: Schema15.Literal("task.enqueue"),
+  commandId: CommandId,
+  taskId: TaskId,
+  score: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var WorkspaceHydrateImportedStateCommand = Schema15.Struct({
+  type: Schema15.Literal("workspace.hydrateImportedState"),
+  commandId: CommandId,
+  workspaceId: WorkspaceId,
+  rootPath: Schema15.optional(Schema15.String),
+  graph: GraphSummary,
+  tasks: Schema15.Array(TaskSummary),
+  runs: Schema15.Array(RunSummary),
+  runtimes: Schema15.Array(RuntimeSummary),
+  actions: Schema15.Array(EngineAction),
+  logs: Schema15.optional(Schema15.Array(EngineRunLog)),
+  validations: Schema15.Array(ValidationSummary),
+  reviews: Schema15.Array(ReviewSummary),
+  artifacts: Schema15.Array(ArtifactSummary),
+  policyDecisions: Schema15.Array(PolicyDecisionSummary),
+  queue: Schema15.Array(QueueEntry),
+  createdAt: IsoDateTime
+});
+var WorkspaceCompileTopologyCommand = Schema15.Struct({
+  type: Schema15.Literal("workspace.compileTopology"),
+  commandId: CommandId,
+  workspaceId: WorkspaceId,
+  rootPath: TrimmedNonEmptyString,
+  topology: WorkspaceTopologySummary,
+  createdAt: IsoDateTime
+});
+var WorkspaceSyncRemoteFleetCommand = Schema15.Struct({
+  type: Schema15.Literal("workspace.syncRemoteFleet"),
+  commandId: CommandId,
+  workspaceId: WorkspaceId,
+  rootPath: TrimmedNonEmptyString,
+  remoteFleet: WorkspaceRemoteFleetSummary,
+  createdAt: IsoDateTime
+});
+var WorkspaceSyncServiceFabricCommand = Schema15.Struct({
+  type: Schema15.Literal("workspace.syncServiceFabric"),
+  commandId: CommandId,
+  workspaceId: WorkspaceId,
+  rootPath: TrimmedNonEmptyString,
+  serviceFabric: WorkspaceServiceFabricSummary,
+  createdAt: IsoDateTime
+});
+var WorkspaceRegisterRemoteHostCommand = Schema15.Struct({
+  type: Schema15.Literal("workspace.registerRemoteHost"),
+  commandId: CommandId,
+  workspaceId: WorkspaceId,
+  host: Schema15.Struct({
+    id: TrimmedNonEmptyString,
+    name: TrimmedNonEmptyString,
+    baseUrl: TrimmedNonEmptyString,
+    workspacePath: Schema15.NullOr(TrimmedNonEmptyString),
+    transport: TrimmedNonEmptyString,
+    hostname: Schema15.NullOr(TrimmedNonEmptyString),
+    region: Schema15.NullOr(TrimmedNonEmptyString),
+    labels: Schema15.Array(TrimmedNonEmptyString),
+    capabilities: Schema15.Array(TrimmedNonEmptyString),
+    runtimeAdapters: Schema15.Array(TrimmedNonEmptyString),
+    status: Schema15.Literals([
+      "registering",
+      "ready",
+      "busy",
+      "degraded",
+      "draining",
+      "offline",
+      "quarantined"
+    ]),
+    currentLeaseCount: Schema15.Number,
+    lastHeartbeatAt: Schema15.NullOr(IsoDateTime),
+    registeredAt: IsoDateTime,
+    manifestPath: TrimmedNonEmptyString
+  }),
+  createdAt: IsoDateTime
+});
+var WorkspaceUpdateRemoteHostStatusCommand = Schema15.Struct({
+  type: Schema15.Literal("workspace.updateRemoteHostStatus"),
+  commandId: CommandId,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  status: Schema15.Literals([
+    "registering",
+    "ready",
+    "busy",
+    "degraded",
+    "draining",
+    "offline",
+    "quarantined"
+  ]),
+  currentLeaseCount: Schema15.optional(Schema15.Number),
+  lastHeartbeatAt: Schema15.optional(IsoDateTime),
+  createdAt: IsoDateTime
+});
+var RunClaimRemoteLeaseCommand = Schema15.Struct({
+  type: Schema15.Literal("run.claimRemoteLease"),
+  commandId: CommandId,
+  runId: RunId,
+  hostId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  createdAt: IsoDateTime
+});
+var RunReleaseRemoteLeaseCommand = Schema15.Struct({
+  type: Schema15.Literal("run.releaseRemoteLease"),
+  commandId: CommandId,
+  runId: RunId,
+  leaseId: TrimmedNonEmptyString,
+  createdAt: IsoDateTime
+});
+var RuntimeRecordMessageCommand = Schema15.Struct({
+  type: Schema15.Literal("runtime.recordMessage"),
+  commandId: CommandId,
+  runId: RunId,
+  messageId: MessageId,
+  role: EngineMessageRole,
+  text: Schema15.String,
+  state: EngineMessageState,
+  attachments: Schema15.optional(Schema15.Array(Schema15.Unknown)),
+  createdAt: IsoDateTime,
+  completedAt: Schema15.optional(IsoDateTime)
+});
+var RuntimeStartActionCommand = Schema15.Struct({
+  type: Schema15.Literal("runtime.startAction"),
+  commandId: CommandId,
+  runId: RunId,
+  actionId: ActionId,
+  messageId: Schema15.optional(MessageId),
+  actionType: TrimmedNonEmptyString,
+  title: TrimmedNonEmptyString,
+  detail: Schema15.optional(Schema15.String),
+  payload: Schema15.Unknown,
+  createdAt: IsoDateTime
+});
+var RuntimeCompleteActionCommand = Schema15.Struct({
+  type: Schema15.Literal("runtime.completeAction"),
+  commandId: CommandId,
+  runId: RunId,
+  actionId: ActionId,
+  state: TrimmedNonEmptyString,
+  detail: Schema15.optional(Schema15.String),
+  payload: Schema15.Unknown,
+  createdAt: IsoDateTime
+});
+var RuntimeRecordLogCommand = Schema15.Struct({
+  type: Schema15.Literal("runtime.recordLog"),
+  commandId: CommandId,
+  runId: RunId,
+  logId: TrimmedNonEmptyString,
+  title: TrimmedNonEmptyString,
+  detail: Schema15.optional(Schema15.String),
+  tone: EngineLogTone,
+  status: Schema15.optional(TrimmedNonEmptyString),
+  payload: Schema15.optional(Schema15.Unknown),
+  createdAt: IsoDateTime
+});
+var RuntimeUpdateMetadataCommand = Schema15.Struct({
+  type: Schema15.Literal("runtime.updateMetadata"),
+  commandId: CommandId,
+  runId: RunId,
+  runtimeId: EngineRuntimeId,
+  sandboxMode: Schema15.optional(EngineSandboxMode),
+  isolationMode: Schema15.optional(IsolationMode),
+  workspaceDir: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
+  homeDir: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
+  tmpDir: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
+  cacheDir: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
+  logsDir: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
+  stateDir: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
+  sessionDir: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
+  sessionLogPath: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
+  pid: Schema15.optional(NonNegativeInt),
+  worktreePath: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
+  branch: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
+  createdAt: IsoDateTime
+});
+var RuntimeRequestApprovalCommand = Schema15.Struct({
+  type: Schema15.Literal("runtime.requestApproval"),
+  commandId: CommandId,
+  runId: RunId,
+  requestId: ApprovalRequestId,
+  requestKind: TrimmedNonEmptyString,
+  actionId: Schema15.optional(ActionId),
+  payload: Schema15.Unknown,
+  createdAt: IsoDateTime
+});
+var RuntimeRequestUserInputCommand = Schema15.Struct({
+  type: Schema15.Literal("runtime.requestUserInput"),
+  commandId: CommandId,
+  runId: RunId,
+  requestId: ApprovalRequestId,
+  payload: Schema15.Unknown,
+  createdAt: IsoDateTime
+});
+var RunMarkCompletedCommand = Schema15.Struct({
+  type: Schema15.Literal("run.markCompleted"),
+  commandId: CommandId,
+  runId: RunId,
+  createdAt: IsoDateTime
+});
+var RunMarkFailedCommand = Schema15.Struct({
+  type: Schema15.Literal("run.markFailed"),
+  commandId: CommandId,
+  runId: RunId,
+  errorText: Schema15.optional(Schema15.String),
+  createdAt: IsoDateTime
+});
+var RunSetStatusCommand = Schema15.Struct({
+  type: Schema15.Literal("run.setStatus"),
+  commandId: CommandId,
+  runId: RunId,
+  status: Schema15.Literals(["created", "queued", "preparing", "running", "validating", "reviewing", "paused"]),
+  createdAt: IsoDateTime
+});
+var RuntimeRecordValidationCommand = Schema15.Struct({
+  type: Schema15.Literal("runtime.recordValidation"),
+  commandId: CommandId,
+  runId: RunId,
+  taskId: Schema15.optional(Schema15.NullOr(TaskId)),
+  validationId: ValidationResultId,
+  validatorKey: TrimmedNonEmptyString,
+  status: Schema15.Literals(["pending", "running", "passed", "failed", "skipped"]),
+  output: Schema15.Unknown,
+  startedAt: IsoDateTime,
+  completedAt: Schema15.optional(Schema15.NullOr(IsoDateTime)),
+  createdAt: IsoDateTime
+});
+var RuntimeRecordReviewCommand = Schema15.Struct({
+  type: Schema15.Literal("runtime.recordReview"),
+  commandId: CommandId,
+  runId: RunId,
+  taskId: Schema15.optional(Schema15.NullOr(TaskId)),
+  reviewId: ReviewResultId,
+  provider: TrimmedNonEmptyString,
+  mode: Schema15.Literals(["off", "advisory", "required"]),
+  status: Schema15.Literals(["pending", "running", "approved", "rejected", "error"]),
+  summary: Schema15.optional(Schema15.NullOr(Schema15.String)),
+  output: Schema15.Unknown,
+  createdAt: IsoDateTime,
+  completedAt: Schema15.optional(Schema15.NullOr(IsoDateTime))
+});
+var RuntimeRegisterArtifactCommand = Schema15.Struct({
+  type: Schema15.Literal("runtime.registerArtifact"),
+  commandId: CommandId,
+  runId: RunId,
+  taskId: Schema15.optional(Schema15.NullOr(TaskId)),
+  artifactId: ArtifactId,
+  kind: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  path: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
+  url: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
+  metadata: Schema15.optional(Schema15.Record(Schema15.String, Schema15.Unknown)),
+  createdAt: IsoDateTime
+});
+var RemoteRegisterEndpointCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.registerEndpoint"),
+  commandId: CommandId,
+  endpoint: RemoteEndpoint,
+  createdAt: IsoDateTime
+});
+var RemoteRemoveEndpointCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.removeEndpoint"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  createdAt: IsoDateTime
+});
+var RemoteUpdateEndpointCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.updateEndpoint"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  updates: Schema15.Unknown,
+  createdAt: IsoDateTime
+});
+var RemoteConnectCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.connect"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  createdAt: IsoDateTime
+});
+var RemoteDisconnectCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.disconnect"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  createdAt: IsoDateTime
+});
+var RemotePauseCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.pause"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  createdAt: IsoDateTime
+});
+var RemoteResumeCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.resume"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  createdAt: IsoDateTime
+});
+var RemoteStopCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.stop"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  createdAt: IsoDateTime
+});
+var RemoteContinueCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.continue"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  createdAt: IsoDateTime
+});
+var RemoteCreateRunForTaskCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.createRunForTask"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  taskId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  workspaceId: TrimmedNonEmptyString,
+  runtimeMode: Schema15.optional(Schema15.String),
+  interactionMode: Schema15.optional(Schema15.String),
+  createdAt: IsoDateTime
+});
+var RemoteRefreshTasksCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.refreshTasks"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  createdAt: IsoDateTime
+});
+var RemoteAddIterationsCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.addIterations"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  count: Schema15.Int.check(Schema15.isGreaterThanOrEqualTo(1)),
+  createdAt: IsoDateTime
+});
+var RemoteRemoveIterationsCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.removeIterations"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  count: Schema15.Int.check(Schema15.isGreaterThanOrEqualTo(1)),
+  createdAt: IsoDateTime
+});
+var RemoteOrchestrateStartCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.orchestrate.start"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  maxWorkers: Schema15.optional(Schema15.Int),
+  maxIterations: Schema15.optional(Schema15.Int),
+  directMerge: Schema15.optional(Schema15.Boolean),
+  createdAt: IsoDateTime
+});
+var RemoteOrchestratePauseCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.orchestrate.pause"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  orchestrationId: TrimmedNonEmptyString,
+  createdAt: IsoDateTime
+});
+var RemoteOrchestrateResumeCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.orchestrate.resume"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  orchestrationId: TrimmedNonEmptyString,
+  createdAt: IsoDateTime
+});
+var RemoteOrchestrateStopCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.orchestrate.stop"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  orchestrationId: TrimmedNonEmptyString,
+  createdAt: IsoDateTime
+});
+var RemoteGetPromptPreviewCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.getPromptPreview"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  taskId: TrimmedNonEmptyString,
+  createdAt: IsoDateTime
+});
+var RemoteGetIterationOutputCommand = Schema15.Struct({
+  type: Schema15.Literal("remote.getIterationOutput"),
+  commandId: CommandId,
+  endpointId: RemoteEndpointId,
+  taskId: TrimmedNonEmptyString,
+  createdAt: IsoDateTime
+});
+var EngineCommand = Schema15.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 = Schema15.Struct({
+  sequence: NonNegativeInt
+});
+var EngineGetSnapshotInput = Schema15.Struct({});
+var EngineReplayEventsInput = Schema15.Struct({
+  fromSequenceExclusive: NonNegativeInt
+});
+var EngineReplayEventsResult = Schema15.Array(EngineEvent);
+var EngineGetTaskArtifactsInput = Schema15.Struct({
+  taskId: TaskId
+});
+var EngineGetTaskArtifactsResult = Schema15.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 = Schema15.Struct({
+  runtimeAdapter: TrimmedNonEmptyString,
+  runMode: RunMode,
+  sandboxMode: EngineSandboxMode,
+  isolationMode: IsolationMode
+});
+// packages/contracts/src/rig.ts
+import { Schema as Schema16 } from "effect";
+var RIG_WS_METHODS = {
+  getSnapshot: "rig.getSnapshot",
+  replayEvents: "rig.replayEvents",
+  listWorkspaces: "rig.listWorkspaces",
+  getWorkspace: "rig.getWorkspace",
+  getRunLogs: "rig.getRunLogs",
+  createAdhocRun: "rig.createAdhocRun",
+  createTaskRun: "rig.createTaskRun",
+  deleteRun: "rig.deleteRun",
+  enqueueTask: "rig.enqueueTask",
+  resumeRun: "rig.resumeRun",
+  submitRunMessage: "rig.submitRunMessage",
+  interruptRun: "rig.interruptRun",
+  stopRun: "rig.stopRun",
+  resolveApproval: "rig.resolveApproval",
+  resolveUserInput: "rig.resolveUserInput",
+  getTaskArtifacts: "rig.getTaskArtifacts"
+};
+var RIG_WS_CHANNELS = {
+  snapshotInvalidated: "rig.snapshotInvalidated",
+  event: "rig.event",
+  runLogAppended: "rig.runLogAppended"
+};
+var RigSnapshotInvalidatedPayload = Schema16.Struct({
+  sequence: NonNegativeInt,
+  updatedAt: IsoDateTime,
+  reason: Schema16.optional(TrimmedNonEmptyString)
+});
+var RigSnapshot = EngineReadModel;
+var RigGetSnapshotInput = Schema16.Struct({});
+var RigReplayEventsInput = Schema16.Struct({
+  fromSequenceExclusive: NonNegativeInt
+});
+var RigReplayEventsResult = Schema16.Array(EngineEvent);
+var RigListWorkspacesInput = Schema16.Struct({});
+var RigListWorkspacesResult = Schema16.Array(WorkspaceSummary);
+var RigGetWorkspaceInput = Schema16.Struct({
+  workspaceId: WorkspaceId
+});
+var RigGetWorkspaceResult = Schema16.Struct({
+  workspace: Schema16.NullOr(WorkspaceSummary),
+  tasks: Schema16.Array(TaskSummary),
+  runs: Schema16.Array(RunSummary),
+  approvals: Schema16.Array(ApprovalSummary),
+  userInputs: Schema16.Array(UserInputRequestSummary),
+  artifacts: Schema16.Array(ArtifactSummary),
+  updatedAt: IsoDateTime
+});
+var RigRawRunLogEntry = Schema16.Record(Schema16.String, Schema16.Unknown);
+var RigGetRunLogsInput = Schema16.Struct({
+  runId: RunId,
+  limit: Schema16.optional(PositiveInt.check(Schema16.isLessThanOrEqualTo(500))),
+  cursor: Schema16.optional(Schema16.String)
+});
+var RigGetRunLogsResult = Schema16.Struct({
+  entries: Schema16.Array(RigRawRunLogEntry),
+  nextCursor: Schema16.NullOr(Schema16.String),
+  hasMore: Schema16.Boolean
+});
+var RigRunLogAppendedPayload = Schema16.Struct({
+  runId: RunId,
+  entry: RigRawRunLogEntry
+});
+var RigCreateAdhocRunInput = Schema16.Struct({
+  commandId: CommandId,
+  runId: RunId,
+  workspaceId: WorkspaceId,
+  title: Schema16.String,
+  runtimeAdapter: Schema16.optional(RuntimeAdapterKind),
+  model: Schema16.optional(Schema16.String),
+  runtimeMode: RuntimeMode.pipe(Schema16.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema16.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  executionTarget: Schema16.optional(RunExecutionTarget),
+  remoteHostId: Schema16.optional(Schema16.String),
+  initialPrompt: Schema16.optional(Schema16.String),
+  createdAt: IsoDateTime
+});
+var RigCreateTaskRunInput = Schema16.Struct({
+  commandId: CommandId,
+  runId: RunId,
+  workspaceId: WorkspaceId,
+  taskId: TaskId,
+  runtimeAdapter: Schema16.optional(RuntimeAdapterKind),
+  model: Schema16.optional(Schema16.String),
+  runtimeMode: RuntimeMode.pipe(Schema16.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema16.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  executionTarget: Schema16.optional(RunExecutionTarget),
+  remoteHostId: Schema16.optional(Schema16.String),
+  createdAt: IsoDateTime
+});
+var RigEnqueueTaskInput = Schema16.Struct({
+  commandId: CommandId,
+  taskId: TaskId,
+  score: Schema16.optional(Schema16.Number),
+  createdAt: IsoDateTime
+});
+var RigDeleteRunInput = Schema16.Struct({
+  commandId: CommandId,
+  runId: RunId,
+  purgeTaskArtifacts: Schema16.optional(Schema16.Boolean),
+  createdAt: IsoDateTime
+});
+var RigResumeRunInput = Schema16.Struct({
+  commandId: CommandId,
+  runId: RunId,
+  promptOverride: Schema16.optional(Schema16.String),
+  createdAt: IsoDateTime
+});
+var RigSubmitRunMessageInput = Schema16.Struct({
+  commandId: CommandId,
+  runId: RunId,
+  messageId: MessageId,
+  text: Schema16.String,
+  attachments: Schema16.optional(Schema16.Array(Schema16.Unknown)),
+  createdAt: IsoDateTime
+});
+var RigInterruptRunInput = Schema16.Struct({
+  commandId: CommandId,
+  runId: RunId,
+  createdAt: IsoDateTime
+});
+var RigStopRunInput = Schema16.Struct({
+  commandId: CommandId,
+  runId: RunId,
+  createdAt: IsoDateTime
+});
+var RigResolveApprovalInput = Schema16.Struct({
+  commandId: CommandId,
+  runId: RunId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision,
+  createdAt: IsoDateTime
+});
+var RigResolveUserInputInput = Schema16.Struct({
+  commandId: CommandId,
+  runId: RunId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers,
+  createdAt: IsoDateTime
+});
+var RigGetTaskArtifactsInput = Schema16.Struct({
+  taskId: TaskId
+});
+var RigGetTaskArtifactsResult = Schema16.Array(ArtifactSummary);
+var RigMutationResult = Schema16.Struct({
+  sequence: NonNegativeInt
+});
+// packages/contracts/src/terminal.ts
+import { Schema as Schema17 } from "effect";
+var DEFAULT_TERMINAL_ID = "default";
+var TrimmedNonEmptyStringSchema = TrimmedNonEmptyString;
+var TerminalColsSchema = Schema17.Int.check(Schema17.isGreaterThanOrEqualTo(20)).check(Schema17.isLessThanOrEqualTo(400));
+var TerminalRowsSchema = Schema17.Int.check(Schema17.isGreaterThanOrEqualTo(5)).check(Schema17.isLessThanOrEqualTo(200));
+var TerminalIdSchema = TrimmedNonEmptyStringSchema.check(Schema17.isMaxLength(128));
+var TerminalEnvKeySchema = Schema17.String.check(Schema17.isPattern(/^[A-Za-z_][A-Za-z0-9_]*$/)).check(Schema17.isMaxLength(128));
+var TerminalEnvValueSchema = Schema17.String.check(Schema17.isMaxLength(8192));
+var TerminalEnvSchema = Schema17.Record(TerminalEnvKeySchema, TerminalEnvValueSchema).check(Schema17.isMaxProperties(128));
+var TerminalIdWithDefaultSchema = TerminalIdSchema.pipe(Schema17.withDecodingDefault(() => DEFAULT_TERMINAL_ID));
+var TerminalThreadInput = Schema17.Struct({
+  threadId: TrimmedNonEmptyStringSchema
+});
+var TerminalSessionInput = Schema17.Struct({
+  ...TerminalThreadInput.fields,
+  terminalId: TerminalIdWithDefaultSchema
+});
+var TerminalOpenInput = Schema17.Struct({
+  ...TerminalSessionInput.fields,
+  cwd: TrimmedNonEmptyStringSchema,
+  cols: Schema17.optional(TerminalColsSchema),
+  rows: Schema17.optional(TerminalRowsSchema),
+  env: Schema17.optional(TerminalEnvSchema)
+});
+var TerminalWriteInput = Schema17.Struct({
+  ...TerminalSessionInput.fields,
+  data: Schema17.String.check(Schema17.isNonEmpty()).check(Schema17.isMaxLength(65536))
+});
+var TerminalResizeInput = Schema17.Struct({
+  ...TerminalSessionInput.fields,
+  cols: TerminalColsSchema,
+  rows: TerminalRowsSchema
+});
+var TerminalClearInput = TerminalSessionInput;
+var TerminalRestartInput = Schema17.Struct({
+  ...TerminalThreadInput.fields,
+  cwd: TrimmedNonEmptyStringSchema,
+  cols: TerminalColsSchema,
+  rows: TerminalRowsSchema,
+  env: Schema17.optional(TerminalEnvSchema)
+});
+var TerminalCloseInput = Schema17.Struct({
+  ...TerminalThreadInput.fields,
+  terminalId: Schema17.optional(TerminalIdSchema),
+  deleteHistory: Schema17.optional(Schema17.Boolean)
+});
+var TerminalSessionStatus = Schema17.Literals(["starting", "running", "exited", "error"]);
+var TerminalSessionSnapshot = Schema17.Struct({
+  threadId: Schema17.String.check(Schema17.isNonEmpty()),
+  terminalId: Schema17.String.check(Schema17.isNonEmpty()),
+  cwd: Schema17.String.check(Schema17.isNonEmpty()),
+  status: TerminalSessionStatus,
+  pid: Schema17.NullOr(Schema17.Int.check(Schema17.isGreaterThan(0))),
+  history: Schema17.String,
+  exitCode: Schema17.NullOr(Schema17.Int),
+  exitSignal: Schema17.NullOr(Schema17.String),
+  updatedAt: Schema17.String
+});
+var TerminalEventBaseSchema = Schema17.Struct({
+  threadId: Schema17.String.check(Schema17.isNonEmpty()),
+  terminalId: Schema17.String.check(Schema17.isNonEmpty()),
+  createdAt: Schema17.String
+});
+var TerminalStartedEvent = Schema17.Struct({
+  ...TerminalEventBaseSchema.fields,
+  type: Schema17.Literal("started"),
+  snapshot: TerminalSessionSnapshot
+});
+var TerminalOutputEvent = Schema17.Struct({
+  ...TerminalEventBaseSchema.fields,
+  type: Schema17.Literal("output"),
+  data: Schema17.String
+});
+var TerminalExitedEvent = Schema17.Struct({
+  ...TerminalEventBaseSchema.fields,
+  type: Schema17.Literal("exited"),
+  exitCode: Schema17.NullOr(Schema17.Int),
+  exitSignal: Schema17.NullOr(Schema17.String)
+});
+var TerminalErrorEvent = Schema17.Struct({
+  ...TerminalEventBaseSchema.fields,
+  type: Schema17.Literal("error"),
+  message: Schema17.String.check(Schema17.isNonEmpty())
+});
+var TerminalClearedEvent = Schema17.Struct({
+  ...TerminalEventBaseSchema.fields,
+  type: Schema17.Literal("cleared")
+});
+var TerminalRestartedEvent = Schema17.Struct({
+  ...TerminalEventBaseSchema.fields,
+  type: Schema17.Literal("restarted"),
+  snapshot: TerminalSessionSnapshot
+});
+var TerminalActivityEvent = Schema17.Struct({
+  ...TerminalEventBaseSchema.fields,
+  type: Schema17.Literal("activity"),
+  hasRunningSubprocess: Schema17.Boolean
+});
+var TerminalEvent = Schema17.Union([
+  TerminalStartedEvent,
+  TerminalOutputEvent,
+  TerminalExitedEvent,
+  TerminalErrorEvent,
+  TerminalClearedEvent,
+  TerminalRestartedEvent,
+  TerminalActivityEvent
+]);
+// packages/contracts/src/provider.ts
+import { Schema as Schema18 } from "effect";
+var TrimmedNonEmptyStringSchema2 = TrimmedNonEmptyString;
+var ProviderSessionStatus = Schema18.Literals([
+  "connecting",
+  "ready",
+  "running",
+  "error",
+  "closed"
+]);
+var ProviderSession = Schema18.Struct({
+  provider: ProviderKind,
+  status: ProviderSessionStatus,
+  runtimeMode: RuntimeMode,
+  cwd: Schema18.optional(TrimmedNonEmptyStringSchema2),
+  model: Schema18.optional(TrimmedNonEmptyStringSchema2),
+  threadId: ThreadId,
+  resumeCursor: Schema18.optional(Schema18.Unknown),
+  activeTurnId: Schema18.optional(TurnId),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  lastError: Schema18.optional(TrimmedNonEmptyStringSchema2)
+});
+var CodexProviderStartOptions = Schema18.Struct({
+  binaryPath: Schema18.optional(TrimmedNonEmptyStringSchema2),
+  homePath: Schema18.optional(TrimmedNonEmptyStringSchema2)
+});
+var ProviderStartOptions = Schema18.Struct({
+  codex: Schema18.optional(CodexProviderStartOptions)
+});
+var ProviderSessionStartInput = Schema18.Struct({
+  threadId: ThreadId,
+  provider: Schema18.optional(ProviderKind),
+  cwd: Schema18.optional(TrimmedNonEmptyStringSchema2),
+  model: Schema18.optional(TrimmedNonEmptyStringSchema2),
+  modelOptions: Schema18.optional(ProviderModelOptions),
+  resumeCursor: Schema18.optional(Schema18.Unknown),
+  serviceTier: Schema18.optional(Schema18.NullOr(ProviderServiceTier)),
+  approvalPolicy: Schema18.optional(ProviderApprovalPolicy),
+  sandboxMode: Schema18.optional(ProviderSandboxMode),
+  providerOptions: Schema18.optional(ProviderStartOptions),
+  runtimeMode: RuntimeMode
+});
+var ProviderSendTurnInput = Schema18.Struct({
+  threadId: ThreadId,
+  input: Schema18.optional(TrimmedNonEmptyStringSchema2.check(Schema18.isMaxLength(PROVIDER_SEND_TURN_MAX_INPUT_CHARS))),
+  attachments: Schema18.optional(Schema18.Array(ChatAttachment).check(Schema18.isMaxLength(PROVIDER_SEND_TURN_MAX_ATTACHMENTS))),
+  model: Schema18.optional(TrimmedNonEmptyStringSchema2),
+  serviceTier: Schema18.optional(Schema18.NullOr(ProviderServiceTier)),
+  modelOptions: Schema18.optional(ProviderModelOptions),
+  interactionMode: Schema18.optional(ProviderInteractionMode)
+});
+var ProviderTurnStartResult = Schema18.Struct({
+  threadId: ThreadId,
+  turnId: TurnId,
+  resumeCursor: Schema18.optional(Schema18.Unknown)
+});
+var ProviderInterruptTurnInput = Schema18.Struct({
+  threadId: ThreadId,
+  turnId: Schema18.optional(TurnId)
+});
+var ProviderStopSessionInput = Schema18.Struct({
+  threadId: ThreadId
+});
+var ProviderRespondToRequestInput = Schema18.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision
+});
+var ProviderRespondToUserInputInput = Schema18.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers
+});
+var ProviderEventKind = Schema18.Literals(["session", "notification", "request", "error"]);
+var ProviderEvent = Schema18.Struct({
+  id: EventId,
+  kind: ProviderEventKind,
+  provider: ProviderKind,
+  threadId: ThreadId,
+  createdAt: IsoDateTime,
+  method: TrimmedNonEmptyStringSchema2,
+  message: Schema18.optional(TrimmedNonEmptyStringSchema2),
+  turnId: Schema18.optional(TurnId),
+  itemId: Schema18.optional(ProviderItemId),
+  requestId: Schema18.optional(ApprovalRequestId),
+  requestKind: Schema18.optional(ProviderRequestKind),
+  textDelta: Schema18.optional(Schema18.String),
+  payload: Schema18.optional(Schema18.Unknown)
+});
+// packages/contracts/src/providerRuntime.ts
+import { Schema as Schema19 } from "effect";
+var TrimmedNonEmptyStringSchema3 = TrimmedNonEmptyString;
+var UnknownRecordSchema = Schema19.Record(Schema19.String, Schema19.Unknown);
+var RuntimeEventRawSource = Schema19.Literals([
+  "codex.app-server.notification",
+  "codex.app-server.request",
+  "codex.eventmsg",
+  "codex.sdk.thread-event",
+  "claude.cli.stream-json"
+]);
+var RuntimeEventRaw = Schema19.Struct({
+  source: RuntimeEventRawSource,
+  method: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  messageType: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  payload: Schema19.Unknown
+});
+var ProviderRequestId = TrimmedNonEmptyStringSchema3;
+var ProviderRefs = Schema19.Struct({
+  providerTurnId: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  providerItemId: Schema19.optional(ProviderItemId),
+  providerRequestId: Schema19.optional(ProviderRequestId)
+});
+var RuntimeSessionState = Schema19.Literals([
+  "starting",
+  "ready",
+  "running",
+  "waiting",
+  "stopped",
+  "error"
+]);
+var RuntimeThreadState = Schema19.Literals([
+  "active",
+  "idle",
+  "archived",
+  "closed",
+  "compacted",
+  "error"
+]);
+var RuntimeTurnState = Schema19.Literals([
+  "completed",
+  "failed",
+  "interrupted",
+  "cancelled"
+]);
+var RuntimePlanStepStatus = Schema19.Literals(["pending", "inProgress", "completed"]);
+var RuntimeItemStatus = Schema19.Literals(["inProgress", "completed", "failed", "declined"]);
+var RuntimeContentStreamKind = Schema19.Literals([
+  "assistant_text",
+  "reasoning_text",
+  "reasoning_summary_text",
+  "plan_text",
+  "command_output",
+  "file_change_output",
+  "unknown"
+]);
+var RuntimeSessionExitKind = Schema19.Literals(["graceful", "error"]);
+var RuntimeErrorClass = Schema19.Literals([
+  "provider_error",
+  "transport_error",
+  "permission_error",
+  "validation_error",
+  "unknown"
+]);
+var CanonicalItemType = Schema19.Literals([
+  "user_message",
+  "assistant_message",
+  "reasoning",
+  "plan",
+  "command_execution",
+  "file_change",
+  "mcp_tool_call",
+  "dynamic_tool_call",
+  "collab_agent_tool_call",
+  "web_search",
+  "image_view",
+  "review_entered",
+  "review_exited",
+  "context_compaction",
+  "error",
+  "unknown"
+]);
+var CanonicalRequestType = Schema19.Literals([
+  "command_execution_approval",
+  "file_read_approval",
+  "file_change_approval",
+  "apply_patch_approval",
+  "exec_command_approval",
+  "tool_user_input",
+  "dynamic_tool_call",
+  "auth_tokens_refresh",
+  "unknown"
+]);
+var ProviderRuntimeEventType = Schema19.Literals([
+  "session.started",
+  "session.configured",
+  "session.state.changed",
+  "session.exited",
+  "thread.started",
+  "thread.state.changed",
+  "thread.metadata.updated",
+  "thread.token-usage.updated",
+  "thread.realtime.started",
+  "thread.realtime.item-added",
+  "thread.realtime.audio.delta",
+  "thread.realtime.error",
+  "thread.realtime.closed",
+  "turn.started",
+  "turn.completed",
+  "turn.aborted",
+  "turn.plan.updated",
+  "turn.proposed.delta",
+  "turn.proposed.completed",
+  "turn.diff.updated",
+  "item.started",
+  "item.updated",
+  "item.completed",
+  "content.delta",
+  "request.opened",
+  "request.resolved",
+  "user-input.requested",
+  "user-input.resolved",
+  "task.started",
+  "task.progress",
+  "task.completed",
+  "hook.started",
+  "hook.progress",
+  "hook.completed",
+  "tool.progress",
+  "tool.summary",
+  "auth.status",
+  "account.updated",
+  "account.rate-limits.updated",
+  "mcp.status.updated",
+  "mcp.oauth.completed",
+  "model.rerouted",
+  "config.warning",
+  "deprecation.notice",
+  "files.persisted",
+  "runtime.warning",
+  "runtime.error"
+]);
+var SessionStartedType = Schema19.Literal("session.started");
+var SessionConfiguredType = Schema19.Literal("session.configured");
+var SessionStateChangedType = Schema19.Literal("session.state.changed");
+var SessionExitedType = Schema19.Literal("session.exited");
+var ThreadStartedType = Schema19.Literal("thread.started");
+var ThreadStateChangedType = Schema19.Literal("thread.state.changed");
+var ThreadMetadataUpdatedType = Schema19.Literal("thread.metadata.updated");
+var ThreadTokenUsageUpdatedType = Schema19.Literal("thread.token-usage.updated");
+var ThreadRealtimeStartedType = Schema19.Literal("thread.realtime.started");
+var ThreadRealtimeItemAddedType = Schema19.Literal("thread.realtime.item-added");
+var ThreadRealtimeAudioDeltaType = Schema19.Literal("thread.realtime.audio.delta");
+var ThreadRealtimeErrorType = Schema19.Literal("thread.realtime.error");
+var ThreadRealtimeClosedType = Schema19.Literal("thread.realtime.closed");
+var TurnStartedType = Schema19.Literal("turn.started");
+var TurnCompletedType = Schema19.Literal("turn.completed");
+var TurnAbortedType = Schema19.Literal("turn.aborted");
+var TurnPlanUpdatedType = Schema19.Literal("turn.plan.updated");
+var TurnProposedDeltaType = Schema19.Literal("turn.proposed.delta");
+var TurnProposedCompletedType = Schema19.Literal("turn.proposed.completed");
+var TurnDiffUpdatedType = Schema19.Literal("turn.diff.updated");
+var ItemStartedType = Schema19.Literal("item.started");
+var ItemUpdatedType = Schema19.Literal("item.updated");
+var ItemCompletedType = Schema19.Literal("item.completed");
+var ContentDeltaType = Schema19.Literal("content.delta");
+var RequestOpenedType = Schema19.Literal("request.opened");
+var RequestResolvedType = Schema19.Literal("request.resolved");
+var UserInputRequestedType = Schema19.Literal("user-input.requested");
+var UserInputResolvedType = Schema19.Literal("user-input.resolved");
+var TaskStartedType = Schema19.Literal("task.started");
+var TaskProgressType = Schema19.Literal("task.progress");
+var TaskCompletedType = Schema19.Literal("task.completed");
+var HookStartedType = Schema19.Literal("hook.started");
+var HookProgressType = Schema19.Literal("hook.progress");
+var HookCompletedType = Schema19.Literal("hook.completed");
+var ToolProgressType = Schema19.Literal("tool.progress");
+var ToolSummaryType = Schema19.Literal("tool.summary");
+var AuthStatusType = Schema19.Literal("auth.status");
+var AccountUpdatedType = Schema19.Literal("account.updated");
+var AccountRateLimitsUpdatedType = Schema19.Literal("account.rate-limits.updated");
+var McpStatusUpdatedType = Schema19.Literal("mcp.status.updated");
+var McpOauthCompletedType = Schema19.Literal("mcp.oauth.completed");
+var ModelReroutedType = Schema19.Literal("model.rerouted");
+var ConfigWarningType = Schema19.Literal("config.warning");
+var DeprecationNoticeType = Schema19.Literal("deprecation.notice");
+var FilesPersistedType = Schema19.Literal("files.persisted");
+var RuntimeWarningType = Schema19.Literal("runtime.warning");
+var RuntimeErrorType = Schema19.Literal("runtime.error");
+var ProviderRuntimeEventBase = Schema19.Struct({
+  eventId: EventId,
+  provider: ProviderKind,
+  threadId: ThreadId,
+  createdAt: IsoDateTime,
+  turnId: Schema19.optional(TurnId),
+  itemId: Schema19.optional(RuntimeItemId),
+  requestId: Schema19.optional(RuntimeRequestId),
+  providerRefs: Schema19.optional(ProviderRefs),
+  raw: Schema19.optional(RuntimeEventRaw)
+});
+var SessionStartedPayload = Schema19.Struct({
+  message: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  resume: Schema19.optional(Schema19.Unknown)
+});
+var SessionConfiguredPayload = Schema19.Struct({
+  config: UnknownRecordSchema
+});
+var SessionStateChangedPayload = Schema19.Struct({
+  state: RuntimeSessionState,
+  reason: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  detail: Schema19.optional(Schema19.Unknown)
+});
+var SessionExitedPayload = Schema19.Struct({
+  reason: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  recoverable: Schema19.optional(Schema19.Boolean),
+  exitKind: Schema19.optional(RuntimeSessionExitKind)
+});
+var ThreadStartedPayload = Schema19.Struct({
+  providerThreadId: Schema19.optional(TrimmedNonEmptyStringSchema3)
+});
+var ThreadStateChangedPayload = Schema19.Struct({
+  state: RuntimeThreadState,
+  detail: Schema19.optional(Schema19.Unknown)
+});
+var ThreadMetadataUpdatedPayload = Schema19.Struct({
+  name: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  metadata: Schema19.optional(UnknownRecordSchema)
+});
+var ThreadTokenUsageUpdatedPayload = Schema19.Struct({
+  usage: Schema19.Unknown
+});
+var ThreadRealtimeStartedPayload = Schema19.Struct({
+  realtimeSessionId: Schema19.optional(TrimmedNonEmptyStringSchema3)
+});
+var ThreadRealtimeItemAddedPayload = Schema19.Struct({
+  item: Schema19.Unknown
+});
+var ThreadRealtimeAudioDeltaPayload = Schema19.Struct({
+  audio: Schema19.Unknown
+});
+var ThreadRealtimeErrorPayload = Schema19.Struct({
+  message: TrimmedNonEmptyStringSchema3
+});
+var ThreadRealtimeClosedPayload = Schema19.Struct({
+  reason: Schema19.optional(TrimmedNonEmptyStringSchema3)
+});
+var TurnStartedPayload = Schema19.Struct({
+  model: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  effort: Schema19.optional(TrimmedNonEmptyStringSchema3)
+});
+var TurnCompletedPayload = Schema19.Struct({
+  state: RuntimeTurnState,
+  stopReason: Schema19.optional(Schema19.NullOr(TrimmedNonEmptyStringSchema3)),
+  usage: Schema19.optional(Schema19.Unknown),
+  modelUsage: Schema19.optional(UnknownRecordSchema),
+  totalCostUsd: Schema19.optional(Schema19.Number),
+  errorMessage: Schema19.optional(TrimmedNonEmptyStringSchema3)
+});
+var TurnAbortedPayload = Schema19.Struct({
+  reason: TrimmedNonEmptyStringSchema3
+});
+var RuntimePlanStep = Schema19.Struct({
+  step: TrimmedNonEmptyStringSchema3,
+  status: RuntimePlanStepStatus
+});
+var TurnPlanUpdatedPayload = Schema19.Struct({
+  explanation: Schema19.optional(Schema19.NullOr(TrimmedNonEmptyStringSchema3)),
+  plan: Schema19.Array(RuntimePlanStep)
+});
+var TurnProposedDeltaPayload = Schema19.Struct({
+  delta: Schema19.String
+});
+var TurnProposedCompletedPayload = Schema19.Struct({
+  planMarkdown: TrimmedNonEmptyStringSchema3
+});
+var TurnDiffUpdatedPayload = Schema19.Struct({
+  unifiedDiff: Schema19.String
+});
+var ItemLifecyclePayload = Schema19.Struct({
+  itemType: CanonicalItemType,
+  status: Schema19.optional(RuntimeItemStatus),
+  title: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  detail: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  data: Schema19.optional(Schema19.Unknown)
+});
+var ContentDeltaPayload = Schema19.Struct({
+  streamKind: RuntimeContentStreamKind,
+  delta: Schema19.String,
+  contentIndex: Schema19.optional(Schema19.Int),
+  summaryIndex: Schema19.optional(Schema19.Int)
+});
+var RequestOpenedPayload = Schema19.Struct({
+  requestType: CanonicalRequestType,
+  detail: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  args: Schema19.optional(Schema19.Unknown)
+});
+var RequestResolvedPayload = Schema19.Struct({
+  requestType: CanonicalRequestType,
+  decision: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  resolution: Schema19.optional(Schema19.Unknown)
+});
+var UserInputQuestionOption = Schema19.Struct({
+  label: TrimmedNonEmptyStringSchema3,
+  description: TrimmedNonEmptyStringSchema3
+});
+var UserInputQuestion = Schema19.Struct({
+  id: TrimmedNonEmptyStringSchema3,
+  header: TrimmedNonEmptyStringSchema3,
+  question: TrimmedNonEmptyStringSchema3,
+  options: Schema19.Array(UserInputQuestionOption)
+});
+var UserInputRequestedPayload = Schema19.Struct({
+  questions: Schema19.Array(UserInputQuestion)
+});
+var UserInputResolvedPayload = Schema19.Struct({
+  answers: UnknownRecordSchema
+});
+var TaskStartedPayload = Schema19.Struct({
+  taskId: RuntimeTaskId,
+  description: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  taskType: Schema19.optional(TrimmedNonEmptyStringSchema3)
+});
+var TaskProgressPayload = Schema19.Struct({
+  taskId: RuntimeTaskId,
+  description: TrimmedNonEmptyStringSchema3,
+  usage: Schema19.optional(Schema19.Unknown),
+  lastToolName: Schema19.optional(TrimmedNonEmptyStringSchema3)
+});
+var TaskCompletedPayload = Schema19.Struct({
+  taskId: RuntimeTaskId,
+  status: Schema19.Literals(["completed", "failed", "stopped"]),
+  summary: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  usage: Schema19.optional(Schema19.Unknown)
+});
+var HookStartedPayload = Schema19.Struct({
+  hookId: TrimmedNonEmptyStringSchema3,
+  hookName: TrimmedNonEmptyStringSchema3,
+  hookEvent: TrimmedNonEmptyStringSchema3
+});
+var HookProgressPayload = Schema19.Struct({
+  hookId: TrimmedNonEmptyStringSchema3,
+  output: Schema19.optional(Schema19.String),
+  stdout: Schema19.optional(Schema19.String),
+  stderr: Schema19.optional(Schema19.String)
+});
+var HookCompletedPayload = Schema19.Struct({
+  hookId: TrimmedNonEmptyStringSchema3,
+  outcome: Schema19.Literals(["success", "error", "cancelled"]),
+  output: Schema19.optional(Schema19.String),
+  stdout: Schema19.optional(Schema19.String),
+  stderr: Schema19.optional(Schema19.String),
+  exitCode: Schema19.optional(Schema19.Int)
+});
+var ToolProgressPayload = Schema19.Struct({
+  toolUseId: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  toolName: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  summary: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  elapsedSeconds: Schema19.optional(Schema19.Number)
+});
+var ToolSummaryPayload = Schema19.Struct({
+  summary: TrimmedNonEmptyStringSchema3,
+  precedingToolUseIds: Schema19.optional(Schema19.Array(TrimmedNonEmptyStringSchema3))
+});
+var AuthStatusPayload = Schema19.Struct({
+  isAuthenticating: Schema19.optional(Schema19.Boolean),
+  output: Schema19.optional(Schema19.Array(Schema19.String)),
+  error: Schema19.optional(TrimmedNonEmptyStringSchema3)
+});
+var AccountUpdatedPayload = Schema19.Struct({
+  account: Schema19.Unknown
+});
+var AccountRateLimitsUpdatedPayload = Schema19.Struct({
+  rateLimits: Schema19.Unknown
+});
+var McpStatusUpdatedPayload = Schema19.Struct({
+  status: Schema19.Unknown
+});
+var McpOauthCompletedPayload = Schema19.Struct({
+  success: Schema19.Boolean,
+  name: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  error: Schema19.optional(TrimmedNonEmptyStringSchema3)
+});
+var ModelReroutedPayload = Schema19.Struct({
+  fromModel: TrimmedNonEmptyStringSchema3,
+  toModel: TrimmedNonEmptyStringSchema3,
+  reason: TrimmedNonEmptyStringSchema3
+});
+var ConfigWarningPayload = Schema19.Struct({
+  summary: TrimmedNonEmptyStringSchema3,
+  details: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  path: Schema19.optional(TrimmedNonEmptyStringSchema3),
+  range: Schema19.optional(Schema19.Unknown)
+});
+var DeprecationNoticePayload = Schema19.Struct({
+  summary: TrimmedNonEmptyStringSchema3,
+  details: Schema19.optional(TrimmedNonEmptyStringSchema3)
+});
+var FilesPersistedPayload = Schema19.Struct({
+  files: Schema19.Array(Schema19.Struct({
+    filename: TrimmedNonEmptyStringSchema3,
+    fileId: TrimmedNonEmptyStringSchema3
+  })),
+  failed: Schema19.optional(Schema19.Array(Schema19.Struct({
+    filename: TrimmedNonEmptyStringSchema3,
+    error: TrimmedNonEmptyStringSchema3
+  })))
+});
+var RuntimeWarningPayload = Schema19.Struct({
+  message: TrimmedNonEmptyStringSchema3,
+  detail: Schema19.optional(Schema19.Unknown)
+});
+var RuntimeErrorPayload = Schema19.Struct({
+  message: TrimmedNonEmptyStringSchema3,
+  class: Schema19.optional(RuntimeErrorClass),
+  detail: Schema19.optional(Schema19.Unknown)
+});
+var ProviderRuntimeSessionStartedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: SessionStartedType,
+  payload: SessionStartedPayload
+});
+var ProviderRuntimeSessionConfiguredEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: SessionConfiguredType,
+  payload: SessionConfiguredPayload
+});
+var ProviderRuntimeSessionStateChangedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: SessionStateChangedType,
+  payload: SessionStateChangedPayload
+});
+var ProviderRuntimeSessionExitedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: SessionExitedType,
+  payload: SessionExitedPayload
+});
+var ProviderRuntimeThreadStartedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadStartedType,
+  payload: ThreadStartedPayload
+});
+var ProviderRuntimeThreadStateChangedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadStateChangedType,
+  payload: ThreadStateChangedPayload
+});
+var ProviderRuntimeThreadMetadataUpdatedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadMetadataUpdatedType,
+  payload: ThreadMetadataUpdatedPayload
+});
+var ProviderRuntimeThreadTokenUsageUpdatedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadTokenUsageUpdatedType,
+  payload: ThreadTokenUsageUpdatedPayload
+});
+var ProviderRuntimeThreadRealtimeStartedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadRealtimeStartedType,
+  payload: ThreadRealtimeStartedPayload
+});
+var ProviderRuntimeThreadRealtimeItemAddedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadRealtimeItemAddedType,
+  payload: ThreadRealtimeItemAddedPayload
+});
+var ProviderRuntimeThreadRealtimeAudioDeltaEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadRealtimeAudioDeltaType,
+  payload: ThreadRealtimeAudioDeltaPayload
+});
+var ProviderRuntimeThreadRealtimeErrorEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadRealtimeErrorType,
+  payload: ThreadRealtimeErrorPayload
+});
+var ProviderRuntimeThreadRealtimeClosedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadRealtimeClosedType,
+  payload: ThreadRealtimeClosedPayload
+});
+var ProviderRuntimeTurnStartedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TurnStartedType,
+  payload: TurnStartedPayload
+});
+var ProviderRuntimeTurnCompletedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TurnCompletedType,
+  payload: TurnCompletedPayload
+});
+var ProviderRuntimeTurnAbortedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TurnAbortedType,
+  payload: TurnAbortedPayload
+});
+var ProviderRuntimeTurnPlanUpdatedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TurnPlanUpdatedType,
+  payload: TurnPlanUpdatedPayload
+});
+var ProviderRuntimeTurnProposedDeltaEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TurnProposedDeltaType,
+  payload: TurnProposedDeltaPayload
+});
+var ProviderRuntimeTurnProposedCompletedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TurnProposedCompletedType,
+  payload: TurnProposedCompletedPayload
+});
+var ProviderRuntimeTurnDiffUpdatedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TurnDiffUpdatedType,
+  payload: TurnDiffUpdatedPayload
+});
+var ProviderRuntimeItemStartedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ItemStartedType,
+  payload: ItemLifecyclePayload
+});
+var ProviderRuntimeItemUpdatedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ItemUpdatedType,
+  payload: ItemLifecyclePayload
+});
+var ProviderRuntimeItemCompletedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ItemCompletedType,
+  payload: ItemLifecyclePayload
+});
+var ProviderRuntimeContentDeltaEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ContentDeltaType,
+  payload: ContentDeltaPayload
+});
+var ProviderRuntimeRequestOpenedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: RequestOpenedType,
+  payload: RequestOpenedPayload
+});
+var ProviderRuntimeRequestResolvedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: RequestResolvedType,
+  payload: RequestResolvedPayload
+});
+var ProviderRuntimeUserInputRequestedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: UserInputRequestedType,
+  payload: UserInputRequestedPayload
+});
+var ProviderRuntimeUserInputResolvedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: UserInputResolvedType,
+  payload: UserInputResolvedPayload
+});
+var ProviderRuntimeTaskStartedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TaskStartedType,
+  payload: TaskStartedPayload
+});
+var ProviderRuntimeTaskProgressEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TaskProgressType,
+  payload: TaskProgressPayload
+});
+var ProviderRuntimeTaskCompletedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TaskCompletedType,
+  payload: TaskCompletedPayload
+});
+var ProviderRuntimeHookStartedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: HookStartedType,
+  payload: HookStartedPayload
+});
+var ProviderRuntimeHookProgressEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: HookProgressType,
+  payload: HookProgressPayload
+});
+var ProviderRuntimeHookCompletedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: HookCompletedType,
+  payload: HookCompletedPayload
+});
+var ProviderRuntimeToolProgressEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ToolProgressType,
+  payload: ToolProgressPayload
+});
+var ProviderRuntimeToolSummaryEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ToolSummaryType,
+  payload: ToolSummaryPayload
+});
+var ProviderRuntimeAuthStatusEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: AuthStatusType,
+  payload: AuthStatusPayload
+});
+var ProviderRuntimeAccountUpdatedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: AccountUpdatedType,
+  payload: AccountUpdatedPayload
+});
+var ProviderRuntimeAccountRateLimitsUpdatedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: AccountRateLimitsUpdatedType,
+  payload: AccountRateLimitsUpdatedPayload
+});
+var ProviderRuntimeMcpStatusUpdatedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: McpStatusUpdatedType,
+  payload: McpStatusUpdatedPayload
+});
+var ProviderRuntimeMcpOauthCompletedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: McpOauthCompletedType,
+  payload: McpOauthCompletedPayload
+});
+var ProviderRuntimeModelReroutedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ModelReroutedType,
+  payload: ModelReroutedPayload
+});
+var ProviderRuntimeConfigWarningEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ConfigWarningType,
+  payload: ConfigWarningPayload
+});
+var ProviderRuntimeDeprecationNoticeEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: DeprecationNoticeType,
+  payload: DeprecationNoticePayload
+});
+var ProviderRuntimeFilesPersistedEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: FilesPersistedType,
+  payload: FilesPersistedPayload
+});
+var ProviderRuntimeWarningEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: RuntimeWarningType,
+  payload: RuntimeWarningPayload
+});
+var ProviderRuntimeErrorEvent = Schema19.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: RuntimeErrorType,
+  payload: RuntimeErrorPayload
+});
+var ProviderRuntimeEventV2 = Schema19.Union([
+  ProviderRuntimeSessionStartedEvent,
+  ProviderRuntimeSessionConfiguredEvent,
+  ProviderRuntimeSessionStateChangedEvent,
+  ProviderRuntimeSessionExitedEvent,
+  ProviderRuntimeThreadStartedEvent,
+  ProviderRuntimeThreadStateChangedEvent,
+  ProviderRuntimeThreadMetadataUpdatedEvent,
+  ProviderRuntimeThreadTokenUsageUpdatedEvent,
+  ProviderRuntimeThreadRealtimeStartedEvent,
+  ProviderRuntimeThreadRealtimeItemAddedEvent,
+  ProviderRuntimeThreadRealtimeAudioDeltaEvent,
+  ProviderRuntimeThreadRealtimeErrorEvent,
+  ProviderRuntimeThreadRealtimeClosedEvent,
+  ProviderRuntimeTurnStartedEvent,
+  ProviderRuntimeTurnCompletedEvent,
+  ProviderRuntimeTurnAbortedEvent,
+  ProviderRuntimeTurnPlanUpdatedEvent,
+  ProviderRuntimeTurnProposedDeltaEvent,
+  ProviderRuntimeTurnProposedCompletedEvent,
+  ProviderRuntimeTurnDiffUpdatedEvent,
+  ProviderRuntimeItemStartedEvent,
+  ProviderRuntimeItemUpdatedEvent,
+  ProviderRuntimeItemCompletedEvent,
+  ProviderRuntimeContentDeltaEvent,
+  ProviderRuntimeRequestOpenedEvent,
+  ProviderRuntimeRequestResolvedEvent,
+  ProviderRuntimeUserInputRequestedEvent,
+  ProviderRuntimeUserInputResolvedEvent,
+  ProviderRuntimeTaskStartedEvent,
+  ProviderRuntimeTaskProgressEvent,
+  ProviderRuntimeTaskCompletedEvent,
+  ProviderRuntimeHookStartedEvent,
+  ProviderRuntimeHookProgressEvent,
+  ProviderRuntimeHookCompletedEvent,
+  ProviderRuntimeToolProgressEvent,
+  ProviderRuntimeToolSummaryEvent,
+  ProviderRuntimeAuthStatusEvent,
+  ProviderRuntimeAccountUpdatedEvent,
+  ProviderRuntimeAccountRateLimitsUpdatedEvent,
+  ProviderRuntimeMcpStatusUpdatedEvent,
+  ProviderRuntimeMcpOauthCompletedEvent,
+  ProviderRuntimeModelReroutedEvent,
+  ProviderRuntimeConfigWarningEvent,
+  ProviderRuntimeDeprecationNoticeEvent,
+  ProviderRuntimeFilesPersistedEvent,
+  ProviderRuntimeWarningEvent,
+  ProviderRuntimeErrorEvent
+]);
+var ProviderRuntimeEvent = ProviderRuntimeEventV2;
+var ProviderRuntimeToolKind = Schema19.Literals([
+  "command",
+  "file-read",
+  "file-change",
+  "other"
+]);
+var ProviderRuntimeTurnStatus = RuntimeTurnState;
+// packages/contracts/src/ws.ts
+import { Schema as Schema24, Struct as Struct2 } from "effect";
+
+// packages/contracts/src/git.ts
+import { Schema as Schema20 } from "effect";
+var TrimmedNonEmptyStringSchema4 = TrimmedNonEmptyString;
+var GitStackedAction = Schema20.Literals(["commit", "commit_push", "commit_push_pr"]);
+var GitCommitStepStatus = Schema20.Literals(["created", "skipped_no_changes"]);
+var GitPushStepStatus = Schema20.Literals([
+  "pushed",
+  "skipped_not_requested",
+  "skipped_up_to_date"
+]);
+var GitBranchStepStatus = Schema20.Literals(["created", "skipped_not_requested"]);
+var GitPrStepStatus = Schema20.Literals([
+  "created",
+  "opened_existing",
+  "skipped_not_requested"
+]);
+var GitStatusPrState = Schema20.Literals(["open", "closed", "merged"]);
+var GitBranch = Schema20.Struct({
+  name: TrimmedNonEmptyStringSchema4,
+  isRemote: Schema20.optional(Schema20.Boolean),
+  remoteName: Schema20.optional(TrimmedNonEmptyStringSchema4),
+  current: Schema20.Boolean,
+  isDefault: Schema20.Boolean,
+  worktreePath: TrimmedNonEmptyStringSchema4.pipe(Schema20.NullOr)
+});
+var GitWorktree = Schema20.Struct({
+  path: TrimmedNonEmptyStringSchema4,
+  branch: TrimmedNonEmptyStringSchema4
+});
+var GitStatusInput = Schema20.Struct({
+  cwd: TrimmedNonEmptyStringSchema4
+});
+var GitPullInput = Schema20.Struct({
+  cwd: TrimmedNonEmptyStringSchema4
+});
+var GitReadWorkingTreePatchInput = Schema20.Struct({
+  cwd: TrimmedNonEmptyStringSchema4,
+  relativePath: Schema20.optional(TrimmedNonEmptyStringSchema4)
+});
+var GitRunStackedActionInput = Schema20.Struct({
+  cwd: TrimmedNonEmptyStringSchema4,
+  action: GitStackedAction,
+  commitMessage: Schema20.optional(TrimmedNonEmptyStringSchema4.check(Schema20.isMaxLength(1e4))),
+  featureBranch: Schema20.optional(Schema20.Boolean)
+});
+var GitListBranchesInput = Schema20.Struct({
+  cwd: TrimmedNonEmptyStringSchema4
+});
+var GitCreateWorktreeInput = Schema20.Struct({
+  cwd: TrimmedNonEmptyStringSchema4,
+  branch: TrimmedNonEmptyStringSchema4,
+  newBranch: TrimmedNonEmptyStringSchema4,
+  path: Schema20.NullOr(TrimmedNonEmptyStringSchema4)
+});
+var GitRemoveWorktreeInput = Schema20.Struct({
+  cwd: TrimmedNonEmptyStringSchema4,
+  path: TrimmedNonEmptyStringSchema4,
+  force: Schema20.optional(Schema20.Boolean)
+});
+var GitCreateBranchInput = Schema20.Struct({
+  cwd: TrimmedNonEmptyStringSchema4,
+  branch: TrimmedNonEmptyStringSchema4
+});
+var GitCheckoutInput = Schema20.Struct({
+  cwd: TrimmedNonEmptyStringSchema4,
+  branch: TrimmedNonEmptyStringSchema4
+});
+var GitInitInput = Schema20.Struct({
+  cwd: TrimmedNonEmptyStringSchema4
+});
+var GitStatusPr = Schema20.Struct({
+  number: PositiveInt,
+  title: TrimmedNonEmptyStringSchema4,
+  url: Schema20.String,
+  baseBranch: TrimmedNonEmptyStringSchema4,
+  headBranch: TrimmedNonEmptyStringSchema4,
+  state: GitStatusPrState
+});
+var GitStatusResult = Schema20.Struct({
+  branch: TrimmedNonEmptyStringSchema4.pipe(Schema20.NullOr),
+  hasWorkingTreeChanges: Schema20.Boolean,
+  workingTree: Schema20.Struct({
+    files: Schema20.Array(Schema20.Struct({
+      path: TrimmedNonEmptyStringSchema4,
+      insertions: NonNegativeInt,
+      deletions: NonNegativeInt
+    })),
+    insertions: NonNegativeInt,
+    deletions: NonNegativeInt
+  }),
+  hasUpstream: Schema20.Boolean,
+  aheadCount: NonNegativeInt,
+  behindCount: NonNegativeInt,
+  pr: Schema20.NullOr(GitStatusPr)
+});
+var GitListBranchesResult = Schema20.Struct({
+  branches: Schema20.Array(GitBranch),
+  isRepo: Schema20.Boolean
+});
+var GitCreateWorktreeResult = Schema20.Struct({
+  worktree: GitWorktree
+});
+var GitRunStackedActionResult = Schema20.Struct({
+  action: GitStackedAction,
+  branch: Schema20.Struct({
+    status: GitBranchStepStatus,
+    name: Schema20.optional(TrimmedNonEmptyStringSchema4)
+  }),
+  commit: Schema20.Struct({
+    status: GitCommitStepStatus,
+    commitSha: Schema20.optional(TrimmedNonEmptyStringSchema4),
+    subject: Schema20.optional(TrimmedNonEmptyStringSchema4)
+  }),
+  push: Schema20.Struct({
+    status: GitPushStepStatus,
+    branch: Schema20.optional(TrimmedNonEmptyStringSchema4),
+    upstreamBranch: Schema20.optional(TrimmedNonEmptyStringSchema4),
+    setUpstream: Schema20.optional(Schema20.Boolean)
+  }),
+  pr: Schema20.Struct({
+    status: GitPrStepStatus,
+    url: Schema20.optional(Schema20.String),
+    number: Schema20.optional(PositiveInt),
+    baseBranch: Schema20.optional(TrimmedNonEmptyStringSchema4),
+    headBranch: Schema20.optional(TrimmedNonEmptyStringSchema4),
+    title: Schema20.optional(TrimmedNonEmptyStringSchema4)
+  })
+});
+var GitPullResult = Schema20.Struct({
+  status: Schema20.Literals(["pulled", "skipped_up_to_date"]),
+  branch: TrimmedNonEmptyStringSchema4,
+  upstreamBranch: TrimmedNonEmptyStringSchema4.pipe(Schema20.NullOr)
+});
+var GitReadWorkingTreePatchResult = Schema20.Struct({
+  diff: Schema20.String
+});
+
+// packages/contracts/src/keybindings.ts
+import { Schema as Schema21 } from "effect";
+var MAX_KEYBINDING_VALUE_LENGTH = 64;
+var MAX_KEYBINDING_WHEN_LENGTH = 256;
+var MAX_WHEN_EXPRESSION_DEPTH = 64;
+var MAX_SCRIPT_ID_LENGTH = 24;
+var MAX_KEYBINDINGS_COUNT = 256;
+var STATIC_KEYBINDING_COMMANDS = [
+  "terminal.toggle",
+  "terminal.split",
+  "terminal.new",
+  "terminal.close",
+  "diff.toggle",
+  "chat.new",
+  "chat.newLocal",
+  "editor.openFavorite"
+];
+var SCRIPT_RUN_COMMAND_PATTERN = Schema21.TemplateLiteral([
+  Schema21.Literal("script."),
+  Schema21.NonEmptyString.check(Schema21.isMaxLength(MAX_SCRIPT_ID_LENGTH), Schema21.isPattern(/^[a-z0-9][a-z0-9-]*$/)),
+  Schema21.Literal(".run")
+]);
+var KeybindingCommand = Schema21.Union([
+  Schema21.Literals(STATIC_KEYBINDING_COMMANDS),
+  SCRIPT_RUN_COMMAND_PATTERN
+]);
+var KeybindingValue = TrimmedString.check(Schema21.isMinLength(1), Schema21.isMaxLength(MAX_KEYBINDING_VALUE_LENGTH));
+var KeybindingWhen = TrimmedString.check(Schema21.isMinLength(1), Schema21.isMaxLength(MAX_KEYBINDING_WHEN_LENGTH));
+var KeybindingRule = Schema21.Struct({
+  key: KeybindingValue,
+  command: KeybindingCommand,
+  when: Schema21.optional(KeybindingWhen)
+});
+var KeybindingsConfig = Schema21.Array(KeybindingRule).check(Schema21.isMaxLength(MAX_KEYBINDINGS_COUNT));
+var KeybindingShortcut = Schema21.Struct({
+  key: KeybindingValue,
+  metaKey: Schema21.Boolean,
+  ctrlKey: Schema21.Boolean,
+  shiftKey: Schema21.Boolean,
+  altKey: Schema21.Boolean,
+  modKey: Schema21.Boolean
+});
+var KeybindingWhenNode = Schema21.Union([
+  Schema21.Struct({
+    type: Schema21.Literal("identifier"),
+    name: Schema21.NonEmptyString
+  }),
+  Schema21.Struct({
+    type: Schema21.Literal("not"),
+    node: Schema21.suspend(() => KeybindingWhenNode)
+  }),
+  Schema21.Struct({
+    type: Schema21.Literal("and"),
+    left: Schema21.suspend(() => KeybindingWhenNode),
+    right: Schema21.suspend(() => KeybindingWhenNode)
+  }),
+  Schema21.Struct({
+    type: Schema21.Literal("or"),
+    left: Schema21.suspend(() => KeybindingWhenNode),
+    right: Schema21.suspend(() => KeybindingWhenNode)
+  })
+]);
+var ResolvedKeybindingRule = Schema21.Struct({
+  command: KeybindingCommand,
+  shortcut: KeybindingShortcut,
+  whenAst: Schema21.optional(KeybindingWhenNode)
+}).annotate({ parseOptions: { onExcessProperty: "ignore" } });
+var ResolvedKeybindingsConfig = Schema21.Array(ResolvedKeybindingRule).check(Schema21.isMaxLength(MAX_KEYBINDINGS_COUNT));
+
+// packages/contracts/src/project.ts
+import { Schema as Schema22 } from "effect";
+var PROJECT_SEARCH_ENTRIES_MAX_LIMIT = 200;
+var PROJECT_LIST_DIRECTORY_MAX_LIMIT = 500;
+var PROJECT_WRITE_FILE_PATH_MAX_LENGTH = 512;
+var PROJECT_READ_FILE_MAX_BYTES = 512 * 1024;
+var ProjectSearchEntriesInput = Schema22.Struct({
+  cwd: TrimmedNonEmptyString,
+  query: TrimmedNonEmptyString.check(Schema22.isMaxLength(256)),
+  limit: PositiveInt.check(Schema22.isLessThanOrEqualTo(PROJECT_SEARCH_ENTRIES_MAX_LIMIT))
+});
+var ProjectEntryKind = Schema22.Literals(["file", "directory"]);
+var ProjectEntry = Schema22.Struct({
+  path: TrimmedNonEmptyString,
+  kind: ProjectEntryKind,
+  parentPath: Schema22.optional(TrimmedNonEmptyString)
+});
+var ProjectSearchEntriesResult = Schema22.Struct({
+  entries: Schema22.Array(ProjectEntry),
+  truncated: Schema22.Boolean
+});
+var ProjectListDirectoryInput = Schema22.Struct({
+  cwd: TrimmedNonEmptyString,
+  relativePath: TrimmedNonEmptyString.check(Schema22.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH)),
+  limit: PositiveInt.check(Schema22.isLessThanOrEqualTo(PROJECT_LIST_DIRECTORY_MAX_LIMIT))
+});
+var ProjectDirectoryEntry = Schema22.Struct({
+  name: TrimmedNonEmptyString,
+  relativePath: TrimmedNonEmptyString,
+  kind: ProjectEntryKind,
+  sizeBytes: Schema22.optional(NonNegativeInt),
+  modifiedAt: Schema22.optional(Schema22.String)
+});
+var ProjectListDirectoryResult = Schema22.Struct({
+  entries: Schema22.Array(ProjectDirectoryEntry),
+  truncated: Schema22.Boolean
+});
+var ProjectWriteFileInput = Schema22.Struct({
+  cwd: TrimmedNonEmptyString,
+  relativePath: TrimmedNonEmptyString.check(Schema22.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH)),
+  contents: Schema22.String
+});
+var ProjectWriteFileResult = Schema22.Struct({
+  relativePath: TrimmedNonEmptyString
+});
+var ProjectReadFileInput = Schema22.Struct({
+  cwd: TrimmedNonEmptyString,
+  relativePath: TrimmedNonEmptyString.check(Schema22.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH))
+});
+var ProjectReadFileResult = Schema22.Struct({
+  relativePath: TrimmedNonEmptyString,
+  contents: Schema22.String,
+  truncated: Schema22.Boolean,
+  sizeBytes: NonNegativeInt,
+  maxBytes: PositiveInt
+});
+var PROJECT_READ_FILE_MAX_BYTES_VALUE = PROJECT_READ_FILE_MAX_BYTES;
+
+// packages/contracts/src/editor.ts
+import { Schema as Schema23 } from "effect";
+var EDITORS = [
+  { id: "cursor", label: "Cursor", command: "cursor" },
+  { id: "vscode", label: "VS Code", command: "code" },
+  { id: "zed", label: "Zed", command: "zed" },
+  { id: "file-manager", label: "File Manager", command: null }
+];
+var EditorId = Schema23.Literals(EDITORS.map((e) => e.id));
+var OpenInEditorInput = Schema23.Struct({
+  cwd: TrimmedNonEmptyString,
+  editor: EditorId
+});
+
+// packages/contracts/src/ws.ts
+var WS_METHODS = {
+  projectsList: "projects.list",
+  projectsAdd: "projects.add",
+  projectsRemove: "projects.remove",
+  projectsListDirectory: "projects.listDirectory",
+  projectsSearchEntries: "projects.searchEntries",
+  projectsReadFile: "projects.readFile",
+  projectsWriteFile: "projects.writeFile",
+  shellOpenInEditor: "shell.openInEditor",
+  gitPull: "git.pull",
+  gitStatus: "git.status",
+  gitReadWorkingTreePatch: "git.readWorkingTreePatch",
+  gitRunStackedAction: "git.runStackedAction",
+  gitListBranches: "git.listBranches",
+  gitCreateWorktree: "git.createWorktree",
+  gitRemoveWorktree: "git.removeWorktree",
+  gitCreateBranch: "git.createBranch",
+  gitCheckout: "git.checkout",
+  gitInit: "git.init",
+  terminalOpen: "terminal.open",
+  terminalWrite: "terminal.write",
+  terminalResize: "terminal.resize",
+  terminalClear: "terminal.clear",
+  terminalRestart: "terminal.restart",
+  terminalClose: "terminal.close",
+  serverGetConfig: "server.getConfig",
+  serverUpsertKeybinding: "server.upsertKeybinding",
+  remoteListEndpoints: "remote.listEndpoints",
+  remoteRegisterEndpoint: "remote.registerEndpoint",
+  remoteRemoveEndpoint: "remote.removeEndpoint",
+  remoteUpdateEndpoint: "remote.updateEndpoint",
+  remoteTestEndpoint: "remote.testEndpoint",
+  remoteConnect: "remote.connect",
+  remoteDisconnect: "remote.disconnect",
+  remotePause: "remote.pause",
+  remoteResume: "remote.resume",
+  remoteStop: "remote.stop",
+  remoteContinue: "remote.continue",
+  remoteCreateRunForTask: "remote.createRunForTask",
+  remoteRefreshTasks: "remote.refreshTasks",
+  remoteAddIterations: "remote.addIterations",
+  remoteRemoveIterations: "remote.removeIterations",
+  remoteOrchestrateStart: "remote.orchestrate.start",
+  remoteOrchestratePause: "remote.orchestrate.pause",
+  remoteOrchestrateResume: "remote.orchestrate.resume",
+  remoteOrchestrateStop: "remote.orchestrate.stop",
+  remoteOrchestrateState: "remote.orchestrate.state",
+  remotePromptPreview: "remote.promptPreview",
+  remoteIterationOutput: "remote.iterationOutput",
+  remoteTerminalOpen: "remote.terminal.open",
+  remoteTerminalWrite: "remote.terminal.write",
+  remoteTerminalResize: "remote.terminal.resize",
+  remoteTerminalClose: "remote.terminal.close"
+};
+var WS_CHANNELS = {
+  terminalEvent: "terminal.event",
+  serverWelcome: "server.welcome",
+  serverConfigUpdated: "server.configUpdated",
+  remoteConnectionChanged: "remote.connectionChanged",
+  remoteEvent: "remote.event"
+};
+var tagRequestBody = (tag, schema) => schema.mapFields(Struct2.assign({ _tag: Schema24.tag(tag) }), { unsafePreserveChecks: true });
+var WebSocketRequestBody = Schema24.Union([
+  tagRequestBody(RIG_WS_METHODS.getSnapshot, RigGetSnapshotInput),
+  tagRequestBody(RIG_WS_METHODS.replayEvents, RigReplayEventsInput),
+  tagRequestBody(RIG_WS_METHODS.listWorkspaces, RigListWorkspacesInput),
+  tagRequestBody(RIG_WS_METHODS.getWorkspace, RigGetWorkspaceInput),
+  tagRequestBody(RIG_WS_METHODS.createAdhocRun, RigCreateAdhocRunInput),
+  tagRequestBody(RIG_WS_METHODS.createTaskRun, RigCreateTaskRunInput),
+  tagRequestBody(RIG_WS_METHODS.deleteRun, RigDeleteRunInput),
+  tagRequestBody(RIG_WS_METHODS.enqueueTask, RigEnqueueTaskInput),
+  tagRequestBody(RIG_WS_METHODS.resumeRun, RigResumeRunInput),
+  tagRequestBody(RIG_WS_METHODS.submitRunMessage, RigSubmitRunMessageInput),
+  tagRequestBody(RIG_WS_METHODS.interruptRun, RigInterruptRunInput),
+  tagRequestBody(RIG_WS_METHODS.stopRun, RigStopRunInput),
+  tagRequestBody(RIG_WS_METHODS.resolveApproval, RigResolveApprovalInput),
+  tagRequestBody(RIG_WS_METHODS.resolveUserInput, RigResolveUserInputInput),
+  tagRequestBody(RIG_WS_METHODS.getTaskArtifacts, RigGetTaskArtifactsInput),
+  tagRequestBody(WS_METHODS.projectsListDirectory, ProjectListDirectoryInput),
+  tagRequestBody(WS_METHODS.projectsSearchEntries, ProjectSearchEntriesInput),
+  tagRequestBody(WS_METHODS.projectsReadFile, ProjectReadFileInput),
+  tagRequestBody(WS_METHODS.projectsWriteFile, ProjectWriteFileInput),
+  tagRequestBody(WS_METHODS.shellOpenInEditor, OpenInEditorInput),
+  tagRequestBody(WS_METHODS.gitPull, GitPullInput),
+  tagRequestBody(WS_METHODS.gitStatus, GitStatusInput),
+  tagRequestBody(WS_METHODS.gitReadWorkingTreePatch, GitReadWorkingTreePatchInput),
+  tagRequestBody(WS_METHODS.gitRunStackedAction, GitRunStackedActionInput),
+  tagRequestBody(WS_METHODS.gitListBranches, GitListBranchesInput),
+  tagRequestBody(WS_METHODS.gitCreateWorktree, GitCreateWorktreeInput),
+  tagRequestBody(WS_METHODS.gitRemoveWorktree, GitRemoveWorktreeInput),
+  tagRequestBody(WS_METHODS.gitCreateBranch, GitCreateBranchInput),
+  tagRequestBody(WS_METHODS.gitCheckout, GitCheckoutInput),
+  tagRequestBody(WS_METHODS.gitInit, GitInitInput),
+  tagRequestBody(WS_METHODS.terminalOpen, TerminalOpenInput),
+  tagRequestBody(WS_METHODS.terminalWrite, TerminalWriteInput),
+  tagRequestBody(WS_METHODS.terminalResize, TerminalResizeInput),
+  tagRequestBody(WS_METHODS.terminalClear, TerminalClearInput),
+  tagRequestBody(WS_METHODS.terminalRestart, TerminalRestartInput),
+  tagRequestBody(WS_METHODS.terminalClose, TerminalCloseInput),
+  tagRequestBody(WS_METHODS.serverGetConfig, Schema24.Struct({})),
+  tagRequestBody(WS_METHODS.serverUpsertKeybinding, KeybindingRule),
+  tagRequestBody(WS_METHODS.remoteListEndpoints, Schema24.Struct({})),
+  tagRequestBody(WS_METHODS.remoteRegisterEndpoint, Schema24.Struct({
+    alias: TrimmedNonEmptyString,
+    host: TrimmedNonEmptyString,
+    port: Schema24.Int,
+    token: Schema24.optional(TrimmedNonEmptyString),
+    autoConnect: Schema24.optional(Schema24.Boolean)
+  })),
+  tagRequestBody(WS_METHODS.remoteRemoveEndpoint, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString
+  })),
+  tagRequestBody(WS_METHODS.remoteUpdateEndpoint, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString,
+    alias: Schema24.optional(TrimmedNonEmptyString),
+    host: Schema24.optional(TrimmedNonEmptyString),
+    port: Schema24.optional(Schema24.Int),
+    token: Schema24.optional(TrimmedNonEmptyString),
+    autoConnect: Schema24.optional(Schema24.Boolean)
+  })),
+  tagRequestBody(WS_METHODS.remoteTestEndpoint, Schema24.Struct({
+    host: TrimmedNonEmptyString,
+    port: Schema24.Int,
+    token: Schema24.optional(TrimmedNonEmptyString)
+  })),
+  tagRequestBody(WS_METHODS.remoteConnect, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString
+  })),
+  tagRequestBody(WS_METHODS.remoteDisconnect, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString
+  })),
+  tagRequestBody(WS_METHODS.remotePause, Schema24.Struct({ endpointId: TrimmedNonEmptyString })),
+  tagRequestBody(WS_METHODS.remoteResume, Schema24.Struct({ endpointId: TrimmedNonEmptyString })),
+  tagRequestBody(WS_METHODS.remoteStop, Schema24.Struct({ endpointId: TrimmedNonEmptyString })),
+  tagRequestBody(WS_METHODS.remoteContinue, Schema24.Struct({ endpointId: TrimmedNonEmptyString })),
+  tagRequestBody(WS_METHODS.remoteCreateRunForTask, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString,
+    taskId: TrimmedNonEmptyString,
+    runId: TrimmedNonEmptyString,
+    workspaceId: TrimmedNonEmptyString,
+    runtimeMode: Schema24.optional(Schema24.String),
+    interactionMode: Schema24.optional(Schema24.String)
+  })),
+  tagRequestBody(WS_METHODS.remoteRefreshTasks, Schema24.Struct({ endpointId: TrimmedNonEmptyString })),
+  tagRequestBody(WS_METHODS.remoteAddIterations, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString,
+    count: Schema24.Int
+  })),
+  tagRequestBody(WS_METHODS.remoteRemoveIterations, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString,
+    count: Schema24.Int
+  })),
+  tagRequestBody(WS_METHODS.remoteOrchestrateStart, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString,
+    maxWorkers: Schema24.optional(Schema24.Int),
+    maxIterations: Schema24.optional(Schema24.Int),
+    directMerge: Schema24.optional(Schema24.Boolean)
+  })),
+  tagRequestBody(WS_METHODS.remoteOrchestratePause, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString,
+    orchestrationId: TrimmedNonEmptyString
+  })),
+  tagRequestBody(WS_METHODS.remoteOrchestrateResume, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString,
+    orchestrationId: TrimmedNonEmptyString
+  })),
+  tagRequestBody(WS_METHODS.remoteOrchestrateStop, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString,
+    orchestrationId: TrimmedNonEmptyString
+  })),
+  tagRequestBody(WS_METHODS.remoteOrchestrateState, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString,
+    orchestrationId: TrimmedNonEmptyString
+  })),
+  tagRequestBody(WS_METHODS.remotePromptPreview, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString,
+    taskId: TrimmedNonEmptyString
+  })),
+  tagRequestBody(WS_METHODS.remoteIterationOutput, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString,
+    taskId: TrimmedNonEmptyString
+  })),
+  tagRequestBody(WS_METHODS.remoteTerminalOpen, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString,
+    threadId: Schema24.String,
+    terminalId: Schema24.String,
+    cwd: Schema24.optional(Schema24.String),
+    env: Schema24.optional(Schema24.Unknown)
+  })),
+  tagRequestBody(WS_METHODS.remoteTerminalWrite, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString,
+    threadId: Schema24.String,
+    terminalId: Schema24.String,
+    data: Schema24.String
+  })),
+  tagRequestBody(WS_METHODS.remoteTerminalResize, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString,
+    threadId: Schema24.String,
+    terminalId: Schema24.String,
+    cols: Schema24.Number,
+    rows: Schema24.Number
+  })),
+  tagRequestBody(WS_METHODS.remoteTerminalClose, Schema24.Struct({
+    endpointId: TrimmedNonEmptyString,
+    threadId: Schema24.String,
+    terminalId: Schema24.String
+  }))
+]);
+var WebSocketRequest = Schema24.Struct({
+  id: TrimmedNonEmptyString,
+  body: WebSocketRequestBody
+});
+var WebSocketResponse = Schema24.Struct({
+  id: TrimmedNonEmptyString,
+  result: Schema24.optional(Schema24.Unknown),
+  error: Schema24.optional(Schema24.Struct({
+    message: Schema24.String
+  }))
+});
+var WsPush = Schema24.Struct({
+  type: Schema24.Literal("push"),
+  channel: TrimmedNonEmptyString,
+  data: Schema24.Unknown
+});
+var EngineGetSnapshotResult = EngineReadModel;
+var EngineReplayEventsWsResult = EngineReplayEventsResult;
+var WsResponse = Schema24.Union([WebSocketResponse, WsPush]);
+var WsWelcomePayload = Schema24.Struct({
+  cwd: TrimmedNonEmptyString,
+  projectName: TrimmedNonEmptyString,
+  bootstrapProjectId: Schema24.optional(ProjectId),
+  bootstrapThreadId: Schema24.optional(ThreadId)
+});
+// packages/contracts/src/server.ts
+import { Schema as Schema25 } from "effect";
+var KeybindingsMalformedConfigIssue = Schema25.Struct({
+  kind: Schema25.Literal("keybindings.malformed-config"),
+  message: TrimmedNonEmptyString
+});
+var KeybindingsInvalidEntryIssue = Schema25.Struct({
+  kind: Schema25.Literal("keybindings.invalid-entry"),
+  message: TrimmedNonEmptyString,
+  index: Schema25.Number
+});
+var ServerConfigIssue = Schema25.Union([
+  KeybindingsMalformedConfigIssue,
+  KeybindingsInvalidEntryIssue
+]);
+var ServerConfigIssues = Schema25.Array(ServerConfigIssue);
+var ServerProviderStatusState = Schema25.Literals(["ready", "warning", "error"]);
+var ServerProviderAuthStatus = Schema25.Literals([
+  "authenticated",
+  "unauthenticated",
+  "unknown"
+]);
+var ServerProviderStatus = Schema25.Struct({
+  provider: ProviderKind,
+  status: ServerProviderStatusState,
+  available: Schema25.Boolean,
+  authStatus: ServerProviderAuthStatus,
+  checkedAt: IsoDateTime,
+  message: Schema25.optional(TrimmedNonEmptyString)
+});
+var ServerProviderStatuses = Schema25.Array(ServerProviderStatus);
+var ServerConfig = Schema25.Struct({
+  cwd: TrimmedNonEmptyString,
+  rigRoot: Schema25.NullOr(TrimmedNonEmptyString),
+  keybindingsConfigPath: TrimmedNonEmptyString,
+  keybindings: ResolvedKeybindingsConfig,
+  issues: ServerConfigIssues,
+  providers: ServerProviderStatuses,
+  availableEditors: Schema25.Array(EditorId)
+});
+var ServerUpsertKeybindingInput = KeybindingRule;
+var ServerUpsertKeybindingResult = Schema25.Struct({
+  keybindings: ResolvedKeybindingsConfig,
+  issues: ServerConfigIssues
+});
+var ServerConfigUpdatedPayload = Schema25.Struct({
+  issues: ServerConfigIssues,
+  providers: ServerProviderStatuses
+});
+// packages/contracts/src/serviceFabric.ts
+import { Schema as Schema26 } from "effect";
+var ServiceFabricWorkspaceInput = Schema26.Struct({
+  workspaceId: WorkspaceId
+});
+var ServiceFabricUpInput = Schema26.Struct({
+  workspaceId: WorkspaceId,
+  services: Schema26.optional(Schema26.Array(TrimmedNonEmptyString))
+});
+var ServiceFabricUpResult = Schema26.Struct({
+  plan: Schema26.Struct({
+    generatedAt: IsoDateTime,
+    serviceCount: Schema26.Number,
+    services: Schema26.Array(Schema26.Struct({
+      name: TrimmedNonEmptyString,
+      relativeRootPath: TrimmedNonEmptyString,
+      absoluteRootPath: TrimmedNonEmptyString,
+      port: Schema26.Number,
+      healthcheck: TrimmedNonEmptyString,
+      routePrefix: Schema26.NullOr(TrimmedNonEmptyString),
+      mode: Schema26.Literals(["stub", "process"]),
+      command: Schema26.NullOr(Schema26.String),
+      environment: Schema26.Unknown
+    })),
+    warnings: Schema26.Array(Schema26.String)
+  }),
+  state: Schema26.Struct({
+    generatedAt: IsoDateTime,
+    rootPath: TrimmedNonEmptyString,
+    services: Schema26.Array(Schema26.Struct({
+      name: TrimmedNonEmptyString,
+      pid: Schema26.Number,
+      mode: Schema26.Literals(["stub", "process"]),
+      port: Schema26.Number,
+      healthcheck: TrimmedNonEmptyString,
+      routePrefix: Schema26.NullOr(TrimmedNonEmptyString),
+      relativeRootPath: TrimmedNonEmptyString,
+      logPath: TrimmedNonEmptyString
+    }))
+  }),
+  summary: WorkspaceServiceFabricSummary
+});
+export {
+  WsWelcomePayload,
+  WsResponse,
+  WsPush,
+  WorktreeSummary,
+  WorktreeId,
+  WorkspaceUpdateRemoteHostStatusCommand,
+  WorkspaceTopologySummary,
+  WorkspaceTopologyStatus,
+  WorkspaceTopologyServiceSummary,
+  WorkspaceSyncServiceFabricCommand,
+  WorkspaceSyncRemoteFleetCommand,
+  WorkspaceSummary,
+  WorkspaceSourceKind,
+  WorkspaceServiceFabricSummary,
+  WorkspaceServiceFabricStatus,
+  WorkspaceServiceFabricServiceSummary,
+  WorkspaceRemoteHostSummary,
+  WorkspaceRemoteHostStatus,
+  WorkspaceRemoteFleetSummary,
+  WorkspaceRemoteFleetStatus,
+  WorkspaceRegisterRemoteHostCommand,
+  WorkspaceRegisterCommand,
+  WorkspaceIsolation,
+  WorkspaceImportRigCommand,
+  WorkspaceId,
+  WorkspaceHydrateImportedStateCommand,
+  WorkspaceConfig,
+  WorkspaceCompileTopologyCommand,
+  WebSocketResponse,
+  WebSocketRequest,
+  WS_METHODS,
+  WS_CHANNELS,
+  ValidatorRegistration,
+  ValidatorCategory,
+  ValidationSummary,
+  ValidationStatus,
+  ValidationResultId,
+  UserInputRequestSummary,
+  UserInputQuestion,
+  TurnId,
+  TurnCountRange,
+  TrimmedString,
+  TrimmedNonEmptyString,
+  ThreadTurnStartRequestedPayload,
+  ThreadTurnStartCommand,
+  ThreadTurnInterruptRequestedPayload,
+  ThreadTurnDiffCompletedPayload,
+  ThreadTurnDiff,
+  ThreadSessionStopRequestedPayload,
+  ThreadSessionSetPayload,
+  ThreadRuntimeModeSetPayload,
+  ThreadRevertedPayload,
+  ThreadProposedPlanUpsertedPayload,
+  ThreadMetaUpdatedPayload,
+  ThreadMessageSentPayload,
+  ThreadInteractionModeSetPayload,
+  ThreadId,
+  ThreadDeletedPayload,
+  ThreadCreatedPayload,
+  ThreadCheckpointRevertRequestedPayload,
+  ThreadApprovalResponseRequestedPayload,
+  ThreadActivityAppendedPayload,
+  TerminalWriteInput,
+  TerminalThreadInput,
+  TerminalSessionStatus,
+  TerminalSessionSnapshot,
+  TerminalRestartInput,
+  TerminalResizeInput,
+  TerminalOpenInput,
+  TerminalEvent,
+  TerminalCloseInput,
+  TerminalClearInput,
+  TaskSummary,
+  TaskStatus,
+  TaskSourceRegistration,
+  TaskSourceKind,
+  TaskSourceConfig,
+  TaskId,
+  TaskFieldExtension,
+  TaskEnqueueCommand,
+  SkillRegistration,
+  ServiceFabricWorkspaceInput,
+  ServiceFabricUpResult,
+  ServiceFabricUpInput,
+  ServerUpsertKeybindingResult,
+  ServerUpsertKeybindingInput,
+  ServerProviderStatusState,
+  ServerProviderStatus,
+  ServerProviderAuthStatus,
+  ServerConfigUpdatedPayload,
+  ServerConfigIssue,
+  ServerConfig,
+  ScopeSearchPrefix,
+  ScopeNormalizationRules,
+  SCRIPT_RUN_COMMAND_PATTERN,
+  RuntimeUpdateMetadataCommand,
+  RuntimeTaskId,
+  RuntimeSummary,
+  RuntimeStatus,
+  RuntimeStartActionCommand,
+  RuntimeSessionId,
+  RuntimeRequestUserInputCommand,
+  RuntimeRequestId,
+  RuntimeRequestApprovalCommand,
+  RuntimeRegisterArtifactCommand,
+  RuntimeRecordValidationCommand,
+  RuntimeRecordReviewCommand,
+  RuntimeRecordMessageCommand,
+  RuntimeRecordLogCommand,
+  RuntimePrepareCommand,
+  RuntimeMode,
+  RuntimeItemId,
+  RuntimeHarness,
+  RuntimeEventRaw,
+  RuntimeDetachCommand,
+  RuntimeConfig,
+  RuntimeCompleteActionCommand,
+  RuntimeAttachCommand,
+  RuntimeAdapterKind,
+  RunSummary,
+  RunSubmitUserMessageCommand,
+  RunStopCommand,
+  RunStatus,
+  RunSetStatusCommand,
+  RunSetRuntimeModeCommand,
+  RunSetInteractionModeCommand,
+  RunRespondUserInputCommand,
+  RunRespondApprovalCommand,
+  RunReleaseRemoteLeaseCommand,
+  RunMode,
+  RunMarkFailedCommand,
+  RunMarkCompletedCommand,
+  RunKind,
+  RunInterruptCommand,
+  RunId,
+  RunExecutionTarget,
+  RunCreateForTaskCommand,
+  RunCreateAdhocCommand,
+  RunClaimRemoteLeaseCommand,
+  RigSubmitRunMessageInput,
+  RigStopRunInput,
+  RigSnapshotInvalidatedPayload,
+  RigSnapshot,
+  RigRuntimeMode,
+  RigRunLogAppendedPayload,
+  RigResumeRunInput,
+  RigResolveUserInputInput,
+  RigResolveApprovalInput,
+  RigReplayEventsResult,
+  RigReplayEventsInput,
+  RigRawRunLogEntry,
+  RigPlugin,
+  RigMutationResult,
+  RigListWorkspacesResult,
+  RigListWorkspacesInput,
+  RigInterruptRunInput,
+  RigGetWorkspaceResult,
+  RigGetWorkspaceInput,
+  RigGetTaskArtifactsResult,
+  RigGetTaskArtifactsInput,
+  RigGetSnapshotInput,
+  RigGetRunLogsResult,
+  RigGetRunLogsInput,
+  RigEnqueueTaskInput,
+  RigDeleteRunInput,
+  RigCreateTaskRunInput,
+  RigCreateAdhocRunInput,
+  RigConfig,
+  ReviewSummary,
+  ReviewStatus,
+  ReviewResultId,
+  ReviewMode,
+  ReviewConfig,
+  ResolvedKeybindingsConfig,
+  ResolvedKeybindingRule,
+  RepoSourceRegistration,
+  RemoteUpdateEndpointCommand,
+  RemoteStopCommand,
+  RemoteRunnerRegisterInput,
+  RemoteRunnerLifecycleResult,
+  RemoteRunnerHeartbeatInput,
+  RemoteRunStartResult,
+  RemoteRunStartInput,
+  RemoteRunReleaseResult,
+  RemoteRunReleaseInput,
+  RemoteRunMutationResult,
+  RemoteRunMessageInput,
+  RemoteRunLogInput,
+  RemoteRunLeaseSummary,
+  RemoteRunFailInput,
+  RemoteRunExecutionBundle,
+  RemoteRunConversationEntry,
+  RemoteRunCompleteInput,
+  RemoteRunClaimResult,
+  RemoteRunClaimInput,
+  RemoteRunArtifactsResult,
+  RemoteRunArtifactSummary,
+  RemoteRunArtifactResult,
+  RemoteRunArtifactInput,
+  RemoteResumeCommand,
+  RemoteRemoveIterationsCommand,
+  RemoteRemoveEndpointCommand,
+  RemoteRegisterEndpointCommand,
+  RemoteRefreshTasksCommand,
+  RemotePauseCommand,
+  RemoteOrchestratorState,
+  RemoteOrchestrationSummary,
+  RemoteOrchestrateStopCommand,
+  RemoteOrchestrateStartCommand,
+  RemoteOrchestrateResumeCommand,
+  RemoteOrchestratePauseCommand,
+  RemoteIterationOutput,
+  RemoteGetPromptPreviewCommand,
+  RemoteGetIterationOutputCommand,
+  RemoteEndpointId,
+  RemoteEndpoint,
+  RemoteDisconnectCommand,
+  RemoteCreateRunForTaskCommand,
+  RemoteContinueCommand,
+  RemoteConnectionSummary,
+  RemoteConnectionStatusChanged,
+  RemoteConnectionStatus,
+  RemoteConnectCommand,
+  RemoteAddIterationsCommand,
+  RIG_WS_METHODS,
+  RIG_WS_CHANNELS,
+  REASONING_EFFORT_OPTIONS_BY_PROVIDER,
+  QueueEntry,
+  PullRequestConfig,
+  ProviderUserInputAnswers,
+  ProviderTurnStartResult,
+  ProviderStopSessionInput,
+  ProviderSessionStartInput,
+  ProviderSessionRuntimeStatus,
+  ProviderSession,
+  ProviderServiceTier,
+  ProviderSendTurnInput,
+  ProviderSandboxMode,
+  ProviderRuntimeTurnStatus,
+  ProviderRuntimeEventV2,
+  ProviderRuntimeEvent,
+  ProviderRespondToUserInputInput,
+  ProviderRespondToRequestInput,
+  ProviderRequestKind,
+  ProviderModelOptions,
+  ProviderKind,
+  ProviderItemId,
+  ProviderInterruptTurnInput,
+  ProviderInteractionMode,
+  ProviderEvent,
+  ProviderApprovalPolicy,
+  ProviderApprovalDecision,
+  ProjectionPendingApprovalStatus,
+  ProjectionPendingApprovalDecision,
+  ProjectWriteFileResult,
+  ProjectWriteFileInput,
+  ProjectSearchEntriesResult,
+  ProjectSearchEntriesInput,
+  ProjectScriptIcon,
+  ProjectScript,
+  ProjectReadFileResult,
+  ProjectReadFileInput,
+  ProjectMetaUpdatedPayload,
+  ProjectListDirectoryResult,
+  ProjectListDirectoryInput,
+  ProjectIdentity,
+  ProjectId,
+  ProjectEntry,
+  ProjectDirectoryEntry,
+  ProjectDeletedPayload,
+  ProjectCreatedPayload,
+  ProjectCreateCommand,
+  PositiveInt,
+  PolicyMode,
+  PolicyDecisionSummary,
+  PolicyDecision,
+  PluginContributes,
+  PlanningConfig,
+  PROVIDER_SEND_TURN_MAX_INPUT_CHARS,
+  PROVIDER_SEND_TURN_MAX_IMAGE_BYTES,
+  PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
+  PROJECT_READ_FILE_MAX_BYTES_VALUE,
+  OrchestrationThreadActivityTone,
+  OrchestrationThreadActivity,
+  OrchestrationThread,
+  OrchestrationSessionStatus,
+  OrchestrationSession,
+  OrchestrationRpcSchemas,
+  OrchestrationReplayEventsInput,
+  OrchestrationReadModel,
+  OrchestrationProposedPlanId,
+  OrchestrationProposedPlan,
+  OrchestrationProject,
+  OrchestrationPersistedEvent,
+  OrchestrationMessageRole,
+  OrchestrationMessage,
+  OrchestrationLatestTurn,
+  OrchestrationGetTurnDiffResult,
+  OrchestrationGetTurnDiffInput,
+  OrchestrationGetSnapshotInput,
+  OrchestrationGetFullThreadDiffResult,
+  OrchestrationGetFullThreadDiffInput,
+  OrchestrationEventType,
+  OrchestrationEventMetadata,
+  OrchestrationEvent,
+  OrchestrationCommandReceiptStatus,
+  OrchestrationCommand,
+  OrchestrationCheckpointSummary,
+  OrchestrationCheckpointStatus,
+  OrchestrationCheckpointFile,
+  OrchestrationAggregateKind,
+  OrchestrationActorKind,
+  OpenInEditorInput,
+  ORCHESTRATION_WS_METHODS,
+  ORCHESTRATION_WS_CHANNELS,
+  NonNegativeInt,
+  MessageId,
+  MergeConfig,
+  MODEL_SLUG_ALIASES_BY_PROVIDER,
+  MODEL_OPTIONS_BY_PROVIDER,
+  MAX_WHEN_EXPRESSION_DEPTH,
+  MAX_SCRIPT_ID_LENGTH,
+  MAX_KEYBINDING_VALUE_LENGTH,
+  MAX_KEYBINDINGS_COUNT,
+  KeybindingsConfig,
+  KeybindingWhenNode,
+  KeybindingShortcut,
+  KeybindingRule,
+  KeybindingCommand,
+  ItemLifecyclePayload,
+  IssueAnalysisConfig,
+  IsolationMode,
+  IsoDateTime,
+  HookRegistration,
+  HookMatcher,
+  HookEvent,
+  GraphUpdateTaskStatusCommand,
+  GraphSummary,
+  GraphId,
+  GitStatusResult,
+  GitStatusInput,
+  GitStackedAction,
+  GitRunStackedActionResult,
+  GitRunStackedActionInput,
+  GitRemoveWorktreeInput,
+  GitReadWorkingTreePatchResult,
+  GitReadWorkingTreePatchInput,
+  GitPullResult,
+  GitPullInput,
+  GitListBranchesResult,
+  GitListBranchesInput,
+  GitInitInput,
+  GitHubProjectStatusConfig,
+  GitHubConfig,
+  GitCreateWorktreeResult,
+  GitCreateWorktreeInput,
+  GitCreateBranchInput,
+  GitCheckoutInput,
+  GitBranch,
+  EventId,
+  EnrichedRemoteEvent,
+  EngineSandboxMode,
+  EngineRuntimeId,
+  EngineRuntimeDefaults,
+  EngineRunLog,
+  EngineRpcSchemas,
+  EngineReplayEventsWsResult,
+  EngineReplayEventsResult,
+  EngineReplayEventsInput,
+  EngineReadModel,
+  EngineMessageState,
+  EngineMessageRole,
+  EngineMessage,
+  EngineLogTone,
+  EngineGetTaskArtifactsResult,
+  EngineGetTaskArtifactsInput,
+  EngineGetSnapshotResult,
+  EngineGetSnapshotInput,
+  EngineEvent,
+  EngineDispatchResult,
+  EngineCommand,
+  EngineAction,
+  EditorId,
+  EDITORS,
+  DispatchResult,
+  DEFAULT_TERMINAL_ID,
+  DEFAULT_RUNTIME_MODE,
+  DEFAULT_REASONING_EFFORT_BY_PROVIDER,
+  DEFAULT_PROVIDER_KIND,
+  DEFAULT_PROVIDER_INTERACTION_MODE,
+  DEFAULT_MODEL_BY_PROVIDER,
+  CorrelationId,
+  ConversationSummary,
+  ConversationId,
+  CommandId,
+  CodexModelOptions,
+  ClientOrchestrationCommand,
+  CliCommandRegistration,
+  ClaudeModelOptions,
+  CheckpointRef,
+  ChatImageAttachment,
+  ChatAttachment,
+  CanonicalRequestType,
+  CanonicalItemType,
+  CODEX_REASONING_EFFORT_OPTIONS,
+  AutomationConfig,
+  AssistantDeliveryMode,
+  ArtifactSummary,
+  ArtifactId,
+  ApprovalSummary,
+  ApprovalStatus,
+  ApprovalRequestId,
+  AgentRoleRegistration,
+  ActionId
+};