@h-rig/contracts 0.0.6-alpha.157 → 0.0.6-alpha.159

package/dist/src/ws.js

@@ -1,3126 +0,0 @@
-// @bun
-// packages/contracts/src/ws.ts
-import { Schema as Schema20, Struct as Struct2 } from "effect";
-
-// packages/contracts/src/baseSchemas.ts
-import { Schema } from "effect";
-var TrimmedString = Schema.Trim;
-var TrimmedNonEmptyString = TrimmedString.check(Schema.isNonEmpty());
-var NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
-var PositiveInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1));
-var IsoDateTime = Schema.String;
-var makeEntityId = (brand) => TrimmedNonEmptyString.pipe(Schema.brand(brand));
-var ThreadId = makeEntityId("ThreadId");
-var ProjectId = makeEntityId("ProjectId");
-var WorkspaceId = makeEntityId("WorkspaceId");
-var GraphId = makeEntityId("GraphId");
-var TaskId = makeEntityId("TaskId");
-var RunId = makeEntityId("RunId");
-var SafePathSegment = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafePathSegment"));
-var SafeRunId = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(Schema.brand("SafeRunId"));
-var SafeGitRefComponent = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafeGitRefComponent"));
-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/engine.ts
-import { Schema as Schema13 } from "effect";
-
-// packages/contracts/src/conversation.ts
-import { Schema as Schema2 } from "effect";
-var EngineMessageRole = Schema2.Literals(["user", "assistant", "system"]);
-var EngineMessageState = Schema2.Literals([
-  "streaming",
-  "completed",
-  "interrupted",
-  "errored"
-]);
-var ConversationSummary = Schema2.Struct({
-  id: ConversationId,
-  runId: RunId,
-  title: TrimmedNonEmptyString,
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime
-});
-var EngineMessage = Schema2.Struct({
-  id: MessageId,
-  conversationId: ConversationId,
-  role: EngineMessageRole,
-  text: Schema2.String,
-  attachments: Schema2.Array(Schema2.Unknown),
-  state: EngineMessageState,
-  createdAt: IsoDateTime,
-  completedAt: Schema2.NullOr(IsoDateTime)
-});
-var EngineAction = Schema2.Struct({
-  id: ActionId,
-  runId: RunId,
-  messageId: Schema2.NullOr(MessageId),
-  actionType: TrimmedNonEmptyString,
-  title: TrimmedNonEmptyString,
-  detail: Schema2.NullOr(Schema2.String),
-  state: TrimmedNonEmptyString,
-  payload: Schema2.Unknown,
-  startedAt: IsoDateTime,
-  completedAt: Schema2.NullOr(IsoDateTime)
-});
-var EngineLogTone = Schema2.Literals(["thinking", "tool", "info", "error"]);
-var EngineRunLog = Schema2.Struct({
-  id: TrimmedNonEmptyString,
-  runId: RunId,
-  title: TrimmedNonEmptyString,
-  detail: Schema2.NullOr(Schema2.String),
-  tone: EngineLogTone,
-  status: Schema2.NullOr(TrimmedNonEmptyString),
-  payload: Schema2.Unknown,
-  createdAt: IsoDateTime
-});
-
-// packages/contracts/src/graph.ts
-import { Schema as Schema3 } from "effect";
-var TaskStatus = Schema3.Literals([
-  "draft",
-  "open",
-  "ready",
-  "queued",
-  "running",
-  "in_progress",
-  "under_review",
-  "blocked",
-  "unknown",
-  "completed",
-  "failed",
-  "cancelled",
-  "closed"
-]);
-var GraphSummary = Schema3.Struct({
-  id: GraphId,
-  workspaceId: WorkspaceId,
-  title: TrimmedNonEmptyString,
-  description: Schema3.NullOr(Schema3.String),
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime
-});
-var TaskSummary = Schema3.Struct({
-  id: TaskId,
-  workspaceId: WorkspaceId,
-  graphId: Schema3.NullOr(GraphId),
-  externalId: Schema3.NullOr(TrimmedNonEmptyString),
-  title: TrimmedNonEmptyString,
-  description: Schema3.String,
-  status: TaskStatus,
-  priority: Schema3.NullOr(PositiveInt),
-  role: Schema3.NullOr(TrimmedNonEmptyString),
-  scope: Schema3.Array(TrimmedNonEmptyString),
-  validationKeys: Schema3.Array(TrimmedNonEmptyString),
-  sourceIssueId: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
-  dependencies: Schema3.optional(Schema3.Array(TrimmedNonEmptyString)),
-  parentChildDeps: Schema3.optional(Schema3.Array(TrimmedNonEmptyString)),
-  metadata: Schema3.Unknown,
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime
-});
-var QueueEntry = Schema3.Struct({
-  taskId: TaskId,
-  score: NonNegativeInt,
-  unblockCount: NonNegativeInt,
-  position: NonNegativeInt
-});
-var DependencyEdgeType = Schema3.Literals(["blocks", "parent-child", "related"]);
-var DependencyEdge = Schema3.Struct({
-  fromTaskId: TaskId,
-  toTaskId: TaskId,
-  type: DependencyEdgeType
-});
-var BlockerClass = Schema3.Literals([
-  "not-blocked",
-  "task-blocked",
-  "human-decision",
-  "human-approval",
-  "external-input",
-  "unknown"
-]);
-var ActionRiskTier = Schema3.Literals(["t1-read", "t2-reversible", "t3-external", "t4-irreversible"]);
-var BlockerClassification = Schema3.Struct({
-  taskId: TaskId,
-  blockerClass: BlockerClass,
-  actionRiskTier: Schema3.NullOr(ActionRiskTier),
-  rationale: Schema3.String,
-  source: Schema3.Literals(["elimination", "label", "status", "llm"]),
-  autoApplied: Schema3.Boolean
-});
-var DependencyNode = Schema3.Struct({
-  taskId: TaskId,
-  title: TrimmedNonEmptyString,
-  status: TaskStatus,
-  priority: Schema3.NullOr(PositiveInt),
-  assignee: Schema3.NullOr(TrimmedNonEmptyString),
-  blockedBy: Schema3.Array(TaskId),
-  blocks: Schema3.Array(TaskId),
-  blockingDepth: NonNegativeInt,
-  blockerClass: Schema3.NullOr(BlockerClass),
-  actionRiskTier: Schema3.NullOr(ActionRiskTier),
-  epicKey: Schema3.NullOr(TrimmedNonEmptyString),
-  groupKey: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
-  externalId: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
-  sourceIssueId: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
-  scope: Schema3.optional(Schema3.Array(TrimmedNonEmptyString)),
-  validationKeys: Schema3.optional(Schema3.Array(TrimmedNonEmptyString))
-});
-var TaskGraphLane = Schema3.Struct({
-  key: TrimmedNonEmptyString,
-  label: TrimmedNonEmptyString,
-  rowIndex: NonNegativeInt,
-  x: Schema3.Number,
-  y: Schema3.Number,
-  width: NonNegativeInt,
-  height: NonNegativeInt,
-  color: Schema3.String,
-  taskCount: NonNegativeInt
-});
-var TaskGraphStage = Schema3.Struct({
-  index: NonNegativeInt,
-  label: TrimmedNonEmptyString,
-  x: Schema3.Number,
-  width: NonNegativeInt
-});
-var TaskGraphNode = Schema3.Struct({
-  id: TrimmedNonEmptyString,
-  taskId: TaskId,
-  task: Schema3.optional(TaskSummary),
-  rowKey: TrimmedNonEmptyString,
-  rowLabel: TrimmedNonEmptyString,
-  rowIndex: NonNegativeInt,
-  stage: NonNegativeInt,
-  x: Schema3.Number,
-  y: Schema3.Number,
-  width: NonNegativeInt,
-  height: NonNegativeInt,
-  color: Schema3.optional(Schema3.String),
-  taskCode: Schema3.optional(Schema3.NullOr(Schema3.String)),
-  strippedTitle: Schema3.optional(Schema3.String),
-  depsIn: Schema3.optional(NonNegativeInt),
-  depsOut: Schema3.optional(NonNegativeInt),
-  runCount: Schema3.optional(NonNegativeInt),
-  hasApprovals: Schema3.optional(Schema3.Boolean),
-  hasPendingUserInput: Schema3.optional(Schema3.Boolean),
-  hasRejectedReview: Schema3.optional(Schema3.Boolean),
-  hasFailedValidations: Schema3.optional(Schema3.Boolean),
-  artifactCount: Schema3.optional(NonNegativeInt)
-});
-var TaskGraphEdge = Schema3.Struct({
-  id: TrimmedNonEmptyString,
-  sourceId: TrimmedNonEmptyString,
-  targetId: TrimmedNonEmptyString,
-  color: Schema3.String,
-  kind: Schema3.Literals(["blocking", "parent-child"])
-});
-var TaskGraphLayout = Schema3.Struct({
-  lanes: Schema3.Array(TaskGraphLane),
-  stages: Schema3.Array(TaskGraphStage),
-  nodes: Schema3.Array(TaskGraphNode),
-  edges: Schema3.Array(TaskGraphEdge),
-  totalWidth: NonNegativeInt,
-  totalHeight: NonNegativeInt,
-  taskCount: NonNegativeInt
-});
-var DependencyGraphModel = Schema3.Struct({
-  graphId: GraphId,
-  nodes: Schema3.Array(DependencyNode),
-  edges: Schema3.Array(DependencyEdge),
-  layout: TaskGraphLayout,
-  cycles: Schema3.Array(Schema3.Array(TaskId)),
-  unresolvedRefs: Schema3.Array(TrimmedNonEmptyString),
-  degraded: Schema3.Boolean,
-  generatedAt: IsoDateTime
-});
-
-// packages/contracts/src/policy.ts
-import { Schema as Schema4 } from "effect";
-var PolicyDecision = Schema4.Literals(["allow", "warn", "block"]);
-var PolicyMode = Schema4.Literals(["off", "observe", "enforce"]);
-var PolicyDecisionSummary = Schema4.Struct({
-  id: TrimmedNonEmptyString,
-  runId: RunId,
-  actionId: Schema4.NullOr(ActionId),
-  decision: PolicyDecision,
-  mode: PolicyMode,
-  matchedRules: Schema4.Array(TrimmedNonEmptyString),
-  reason: Schema4.String,
-  createdAt: IsoDateTime
-});
-
-// packages/contracts/src/artifact.ts
-import { Schema as Schema5 } from "effect";
-var ArtifactSummary = Schema5.Struct({
-  id: ArtifactId,
-  runId: RunId,
-  taskId: Schema5.NullOr(TaskId),
-  kind: TrimmedNonEmptyString,
-  label: TrimmedNonEmptyString,
-  path: Schema5.NullOr(TrimmedNonEmptyString),
-  url: Schema5.NullOr(TrimmedNonEmptyString),
-  metadata: Schema5.Record(Schema5.String, Schema5.Unknown),
-  createdAt: IsoDateTime
-});
-
-// packages/contracts/src/orchestration.ts
-import { Option, Schema as Schema7, SchemaIssue, Struct } from "effect";
-
-// packages/contracts/src/model.ts
-import { Schema as Schema6 } from "effect";
-var CODEX_REASONING_EFFORT_OPTIONS = ["xhigh", "high", "medium", "low"];
-var CodexModelOptions = Schema6.Struct({
-  reasoningEffort: Schema6.optional(Schema6.Literals(CODEX_REASONING_EFFORT_OPTIONS)),
-  fastMode: Schema6.optional(Schema6.Boolean)
-});
-var ClaudeModelOptions = Schema6.Struct({});
-var ProviderModelOptions = Schema6.Struct({
-  codex: Schema6.optional(CodexModelOptions),
-  claude: Schema6.optional(ClaudeModelOptions)
-});
-
-// packages/contracts/src/orchestration.ts
-var ProviderKind = Schema7.Literals(["codex", "claude"]);
-var ProviderApprovalPolicy = Schema7.Literals([
-  "untrusted",
-  "on-failure",
-  "on-request",
-  "never"
-]);
-var ProviderSandboxMode = Schema7.Literals([
-  "read-only",
-  "workspace-write",
-  "danger-full-access"
-]);
-var ProviderServiceTier = Schema7.Literals(["fast", "flex"]);
-var RuntimeMode = Schema7.Literals(["approval-required", "full-access"]);
-var DEFAULT_RUNTIME_MODE = "full-access";
-var ProviderInteractionMode = Schema7.Literals(["default", "plan"]);
-var DEFAULT_PROVIDER_INTERACTION_MODE = "default";
-var ProviderRequestKind = Schema7.Literals(["command", "file-read", "file-change"]);
-var AssistantDeliveryMode = Schema7.Literals(["buffered", "streaming"]);
-var ProviderApprovalDecision = Schema7.Literals([
-  "accept",
-  "acceptForSession",
-  "decline",
-  "cancel"
-]);
-var ProviderUserInputAnswers = Schema7.Record(Schema7.String, Schema7.Unknown);
-var PROVIDER_SEND_TURN_MAX_IMAGE_BYTES = 10 * 1024 * 1024;
-var PROVIDER_SEND_TURN_MAX_IMAGE_DATA_URL_CHARS = 14000000;
-var CHAT_ATTACHMENT_ID_MAX_CHARS = 128;
-var ChatAttachmentId = TrimmedNonEmptyString.check(Schema7.isMaxLength(CHAT_ATTACHMENT_ID_MAX_CHARS), Schema7.isPattern(/^[a-z0-9_-]+$/i));
-var ChatImageAttachment = Schema7.Struct({
-  type: Schema7.Literal("image"),
-  id: ChatAttachmentId,
-  name: TrimmedNonEmptyString.check(Schema7.isMaxLength(255)),
-  mimeType: TrimmedNonEmptyString.check(Schema7.isMaxLength(100), Schema7.isPattern(/^image\//i)),
-  sizeBytes: NonNegativeInt.check(Schema7.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES))
-});
-var UploadChatImageAttachment = Schema7.Struct({
-  type: Schema7.Literal("image"),
-  name: TrimmedNonEmptyString.check(Schema7.isMaxLength(255)),
-  mimeType: TrimmedNonEmptyString.check(Schema7.isMaxLength(100), Schema7.isPattern(/^image\//i)),
-  sizeBytes: NonNegativeInt.check(Schema7.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES)),
-  dataUrl: TrimmedNonEmptyString.check(Schema7.isMaxLength(PROVIDER_SEND_TURN_MAX_IMAGE_DATA_URL_CHARS))
-});
-var ChatAttachment = Schema7.Union([ChatImageAttachment]);
-var UploadChatAttachment = Schema7.Union([UploadChatImageAttachment]);
-var ProjectScriptIcon = Schema7.Literals([
-  "play",
-  "test",
-  "lint",
-  "configure",
-  "build",
-  "debug"
-]);
-var ProjectScript = Schema7.Struct({
-  id: TrimmedNonEmptyString,
-  name: TrimmedNonEmptyString,
-  command: TrimmedNonEmptyString,
-  icon: ProjectScriptIcon,
-  runOnWorktreeCreate: Schema7.Boolean
-});
-var OrchestrationProject = Schema7.Struct({
-  id: ProjectId,
-  title: TrimmedNonEmptyString,
-  workspaceRoot: TrimmedNonEmptyString,
-  defaultModel: Schema7.NullOr(TrimmedNonEmptyString),
-  scripts: Schema7.Array(ProjectScript),
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime,
-  deletedAt: Schema7.NullOr(IsoDateTime)
-});
-var OrchestrationMessageRole = Schema7.Literals(["user", "assistant", "system"]);
-var OrchestrationMessage = Schema7.Struct({
-  id: MessageId,
-  role: OrchestrationMessageRole,
-  text: Schema7.String,
-  attachments: Schema7.optional(Schema7.Array(ChatAttachment)),
-  turnId: Schema7.NullOr(TurnId),
-  streaming: Schema7.Boolean,
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime
-});
-var OrchestrationProposedPlanId = TrimmedNonEmptyString;
-var OrchestrationProposedPlan = Schema7.Struct({
-  id: OrchestrationProposedPlanId,
-  turnId: Schema7.NullOr(TurnId),
-  planMarkdown: TrimmedNonEmptyString,
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime
-});
-var OrchestrationSessionStatus = Schema7.Literals([
-  "idle",
-  "starting",
-  "running",
-  "ready",
-  "interrupted",
-  "stopped",
-  "error"
-]);
-var OrchestrationSession = Schema7.Struct({
-  threadId: ThreadId,
-  status: OrchestrationSessionStatus,
-  providerName: Schema7.NullOr(TrimmedNonEmptyString),
-  runtimeMode: RuntimeMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
-  activeTurnId: Schema7.NullOr(TurnId),
-  lastError: Schema7.NullOr(TrimmedNonEmptyString),
-  updatedAt: IsoDateTime
-});
-var OrchestrationCheckpointFile = Schema7.Struct({
-  path: TrimmedNonEmptyString,
-  kind: TrimmedNonEmptyString,
-  additions: NonNegativeInt,
-  deletions: NonNegativeInt
-});
-var OrchestrationCheckpointStatus = Schema7.Literals(["ready", "missing", "error"]);
-var OrchestrationCheckpointSummary = Schema7.Struct({
-  turnId: TurnId,
-  checkpointTurnCount: NonNegativeInt,
-  checkpointRef: CheckpointRef,
-  status: OrchestrationCheckpointStatus,
-  files: Schema7.Array(OrchestrationCheckpointFile),
-  assistantMessageId: Schema7.NullOr(MessageId),
-  completedAt: IsoDateTime
-});
-var OrchestrationThreadActivityTone = Schema7.Literals([
-  "info",
-  "tool",
-  "approval",
-  "error"
-]);
-var OrchestrationThreadActivity = Schema7.Struct({
-  id: EventId,
-  tone: OrchestrationThreadActivityTone,
-  kind: TrimmedNonEmptyString,
-  summary: TrimmedNonEmptyString,
-  payload: Schema7.Unknown,
-  turnId: Schema7.NullOr(TurnId),
-  sequence: Schema7.optional(NonNegativeInt),
-  createdAt: IsoDateTime
-});
-var OrchestrationLatestTurnState = Schema7.Literals([
-  "running",
-  "interrupted",
-  "completed",
-  "error"
-]);
-var OrchestrationLatestTurn = Schema7.Struct({
-  turnId: TurnId,
-  state: OrchestrationLatestTurnState,
-  requestedAt: IsoDateTime,
-  startedAt: Schema7.NullOr(IsoDateTime),
-  completedAt: Schema7.NullOr(IsoDateTime),
-  assistantMessageId: Schema7.NullOr(MessageId)
-});
-var OrchestrationThread = Schema7.Struct({
-  id: ThreadId,
-  projectId: ProjectId,
-  title: TrimmedNonEmptyString,
-  model: TrimmedNonEmptyString,
-  runtimeMode: RuntimeMode,
-  interactionMode: ProviderInteractionMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  branch: Schema7.NullOr(TrimmedNonEmptyString),
-  worktreePath: Schema7.NullOr(TrimmedNonEmptyString),
-  latestTurn: Schema7.NullOr(OrchestrationLatestTurn),
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime,
-  deletedAt: Schema7.NullOr(IsoDateTime),
-  messages: Schema7.Array(OrchestrationMessage),
-  proposedPlans: Schema7.Array(OrchestrationProposedPlan).pipe(Schema7.withDecodingDefault(() => [])),
-  activities: Schema7.Array(OrchestrationThreadActivity),
-  checkpoints: Schema7.Array(OrchestrationCheckpointSummary),
-  session: Schema7.NullOr(OrchestrationSession)
-});
-var OrchestrationReadModel = Schema7.Struct({
-  snapshotSequence: NonNegativeInt,
-  projects: Schema7.Array(OrchestrationProject),
-  threads: Schema7.Array(OrchestrationThread),
-  updatedAt: IsoDateTime
-});
-var ProjectCreateCommand = Schema7.Struct({
-  type: Schema7.Literal("project.create"),
-  commandId: CommandId,
-  projectId: ProjectId,
-  title: TrimmedNonEmptyString,
-  workspaceRoot: TrimmedNonEmptyString,
-  defaultModel: Schema7.optional(TrimmedNonEmptyString),
-  createdAt: IsoDateTime
-});
-var ProjectMetaUpdateCommand = Schema7.Struct({
-  type: Schema7.Literal("project.meta.update"),
-  commandId: CommandId,
-  projectId: ProjectId,
-  title: Schema7.optional(TrimmedNonEmptyString),
-  workspaceRoot: Schema7.optional(TrimmedNonEmptyString),
-  defaultModel: Schema7.optional(TrimmedNonEmptyString),
-  scripts: Schema7.optional(Schema7.Array(ProjectScript))
-});
-var ProjectDeleteCommand = Schema7.Struct({
-  type: Schema7.Literal("project.delete"),
-  commandId: CommandId,
-  projectId: ProjectId
-});
-var ThreadCreateCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.create"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  projectId: ProjectId,
-  title: TrimmedNonEmptyString,
-  model: TrimmedNonEmptyString,
-  runtimeMode: RuntimeMode,
-  interactionMode: ProviderInteractionMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  branch: Schema7.NullOr(TrimmedNonEmptyString),
-  worktreePath: Schema7.NullOr(TrimmedNonEmptyString),
-  createdAt: IsoDateTime
-});
-var ThreadDeleteCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.delete"),
-  commandId: CommandId,
-  threadId: ThreadId
-});
-var ThreadMetaUpdateCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.meta.update"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  title: Schema7.optional(TrimmedNonEmptyString),
-  model: Schema7.optional(TrimmedNonEmptyString),
-  branch: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
-  worktreePath: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString))
-});
-var ThreadRuntimeModeSetCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.runtime-mode.set"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  runtimeMode: RuntimeMode,
-  createdAt: IsoDateTime
-});
-var ThreadInteractionModeSetCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.interaction-mode.set"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  interactionMode: ProviderInteractionMode,
-  createdAt: IsoDateTime
-});
-var ThreadTurnStartCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.turn.start"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  message: Schema7.Struct({
-    messageId: MessageId,
-    role: Schema7.Literal("user"),
-    text: Schema7.String,
-    attachments: Schema7.Array(ChatAttachment)
-  }),
-  provider: Schema7.optional(ProviderKind),
-  model: Schema7.optional(TrimmedNonEmptyString),
-  serviceTier: Schema7.optional(Schema7.NullOr(ProviderServiceTier)),
-  modelOptions: Schema7.optional(ProviderModelOptions),
-  assistantDeliveryMode: Schema7.optional(AssistantDeliveryMode),
-  runtimeMode: RuntimeMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
-  interactionMode: ProviderInteractionMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  createdAt: IsoDateTime
-});
-var ClientThreadTurnStartCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.turn.start"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  message: Schema7.Struct({
-    messageId: MessageId,
-    role: Schema7.Literal("user"),
-    text: Schema7.String,
-    attachments: Schema7.Array(UploadChatAttachment)
-  }),
-  provider: Schema7.optional(ProviderKind),
-  model: Schema7.optional(TrimmedNonEmptyString),
-  serviceTier: Schema7.optional(Schema7.NullOr(ProviderServiceTier)),
-  modelOptions: Schema7.optional(ProviderModelOptions),
-  assistantDeliveryMode: Schema7.optional(AssistantDeliveryMode),
-  runtimeMode: RuntimeMode,
-  interactionMode: ProviderInteractionMode,
-  createdAt: IsoDateTime
-});
-var ThreadTurnInterruptCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.turn.interrupt"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  turnId: Schema7.optional(TurnId),
-  createdAt: IsoDateTime
-});
-var ThreadApprovalRespondCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.approval.respond"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  requestId: ApprovalRequestId,
-  decision: ProviderApprovalDecision,
-  createdAt: IsoDateTime
-});
-var ThreadUserInputRespondCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.user-input.respond"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  requestId: ApprovalRequestId,
-  answers: ProviderUserInputAnswers,
-  createdAt: IsoDateTime
-});
-var ThreadCheckpointRevertCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.checkpoint.revert"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  turnCount: NonNegativeInt,
-  createdAt: IsoDateTime
-});
-var ThreadSessionStopCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.session.stop"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  createdAt: IsoDateTime
-});
-var DispatchableClientOrchestrationCommand = Schema7.Union([
-  ProjectCreateCommand,
-  ProjectMetaUpdateCommand,
-  ProjectDeleteCommand,
-  ThreadCreateCommand,
-  ThreadDeleteCommand,
-  ThreadMetaUpdateCommand,
-  ThreadRuntimeModeSetCommand,
-  ThreadInteractionModeSetCommand,
-  ThreadTurnStartCommand,
-  ThreadTurnInterruptCommand,
-  ThreadApprovalRespondCommand,
-  ThreadUserInputRespondCommand,
-  ThreadCheckpointRevertCommand,
-  ThreadSessionStopCommand
-]);
-var ClientOrchestrationCommand = Schema7.Union([
-  ProjectCreateCommand,
-  ProjectMetaUpdateCommand,
-  ProjectDeleteCommand,
-  ThreadCreateCommand,
-  ThreadDeleteCommand,
-  ThreadMetaUpdateCommand,
-  ThreadRuntimeModeSetCommand,
-  ThreadInteractionModeSetCommand,
-  ClientThreadTurnStartCommand,
-  ThreadTurnInterruptCommand,
-  ThreadApprovalRespondCommand,
-  ThreadUserInputRespondCommand,
-  ThreadCheckpointRevertCommand,
-  ThreadSessionStopCommand
-]);
-var ThreadSessionSetCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.session.set"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  session: OrchestrationSession,
-  createdAt: IsoDateTime
-});
-var ThreadMessageAssistantDeltaCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.message.assistant.delta"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  messageId: MessageId,
-  delta: Schema7.String,
-  turnId: Schema7.optional(TurnId),
-  createdAt: IsoDateTime
-});
-var ThreadMessageAssistantCompleteCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.message.assistant.complete"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  messageId: MessageId,
-  turnId: Schema7.optional(TurnId),
-  createdAt: IsoDateTime
-});
-var ThreadProposedPlanUpsertCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.proposed-plan.upsert"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  proposedPlan: OrchestrationProposedPlan,
-  createdAt: IsoDateTime
-});
-var ThreadTurnDiffCompleteCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.turn.diff.complete"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  turnId: TurnId,
-  completedAt: IsoDateTime,
-  checkpointRef: CheckpointRef,
-  status: OrchestrationCheckpointStatus,
-  files: Schema7.Array(OrchestrationCheckpointFile),
-  assistantMessageId: Schema7.optional(MessageId),
-  checkpointTurnCount: NonNegativeInt,
-  createdAt: IsoDateTime
-});
-var ThreadActivityAppendCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.activity.append"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  activity: OrchestrationThreadActivity,
-  createdAt: IsoDateTime
-});
-var ThreadRevertCompleteCommand = Schema7.Struct({
-  type: Schema7.Literal("thread.revert.complete"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  turnCount: NonNegativeInt,
-  createdAt: IsoDateTime
-});
-var InternalOrchestrationCommand = Schema7.Union([
-  ThreadSessionSetCommand,
-  ThreadMessageAssistantDeltaCommand,
-  ThreadMessageAssistantCompleteCommand,
-  ThreadProposedPlanUpsertCommand,
-  ThreadTurnDiffCompleteCommand,
-  ThreadActivityAppendCommand,
-  ThreadRevertCompleteCommand
-]);
-var OrchestrationCommand = Schema7.Union([
-  DispatchableClientOrchestrationCommand,
-  InternalOrchestrationCommand
-]);
-var OrchestrationEventType = Schema7.Literals([
-  "project.created",
-  "project.meta-updated",
-  "project.deleted",
-  "thread.created",
-  "thread.deleted",
-  "thread.meta-updated",
-  "thread.runtime-mode-set",
-  "thread.interaction-mode-set",
-  "thread.message-sent",
-  "thread.turn-start-requested",
-  "thread.turn-interrupt-requested",
-  "thread.approval-response-requested",
-  "thread.user-input-response-requested",
-  "thread.checkpoint-revert-requested",
-  "thread.reverted",
-  "thread.session-stop-requested",
-  "thread.session-set",
-  "thread.proposed-plan-upserted",
-  "thread.turn-diff-completed",
-  "thread.activity-appended"
-]);
-var OrchestrationAggregateKind = Schema7.Literals(["project", "thread"]);
-var OrchestrationActorKind = Schema7.Literals(["client", "server", "provider"]);
-var ProjectCreatedPayload = Schema7.Struct({
-  projectId: ProjectId,
-  title: TrimmedNonEmptyString,
-  workspaceRoot: TrimmedNonEmptyString,
-  defaultModel: Schema7.NullOr(TrimmedNonEmptyString),
-  scripts: Schema7.Array(ProjectScript),
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime
-});
-var ProjectMetaUpdatedPayload = Schema7.Struct({
-  projectId: ProjectId,
-  title: Schema7.optional(TrimmedNonEmptyString),
-  workspaceRoot: Schema7.optional(TrimmedNonEmptyString),
-  defaultModel: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
-  scripts: Schema7.optional(Schema7.Array(ProjectScript)),
-  updatedAt: IsoDateTime
-});
-var ProjectDeletedPayload = Schema7.Struct({
-  projectId: ProjectId,
-  deletedAt: IsoDateTime
-});
-var ThreadCreatedPayload = Schema7.Struct({
-  threadId: ThreadId,
-  projectId: ProjectId,
-  title: TrimmedNonEmptyString,
-  model: TrimmedNonEmptyString,
-  runtimeMode: RuntimeMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
-  interactionMode: ProviderInteractionMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  branch: Schema7.NullOr(TrimmedNonEmptyString),
-  worktreePath: Schema7.NullOr(TrimmedNonEmptyString),
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime
-});
-var ThreadDeletedPayload = Schema7.Struct({
-  threadId: ThreadId,
-  deletedAt: IsoDateTime
-});
-var ThreadMetaUpdatedPayload = Schema7.Struct({
-  threadId: ThreadId,
-  title: Schema7.optional(TrimmedNonEmptyString),
-  model: Schema7.optional(TrimmedNonEmptyString),
-  branch: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
-  worktreePath: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
-  updatedAt: IsoDateTime
-});
-var ThreadRuntimeModeSetPayload = Schema7.Struct({
-  threadId: ThreadId,
-  runtimeMode: RuntimeMode,
-  updatedAt: IsoDateTime
-});
-var ThreadInteractionModeSetPayload = Schema7.Struct({
-  threadId: ThreadId,
-  interactionMode: ProviderInteractionMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  updatedAt: IsoDateTime
-});
-var ThreadMessageSentPayload = Schema7.Struct({
-  threadId: ThreadId,
-  messageId: MessageId,
-  role: OrchestrationMessageRole,
-  text: Schema7.String,
-  attachments: Schema7.optional(Schema7.Array(ChatAttachment)),
-  turnId: Schema7.NullOr(TurnId),
-  streaming: Schema7.Boolean,
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime
-});
-var ThreadTurnStartRequestedPayload = Schema7.Struct({
-  threadId: ThreadId,
-  messageId: MessageId,
-  provider: Schema7.optional(ProviderKind),
-  model: Schema7.optional(TrimmedNonEmptyString),
-  serviceTier: Schema7.optional(Schema7.NullOr(ProviderServiceTier)),
-  modelOptions: Schema7.optional(ProviderModelOptions),
-  assistantDeliveryMode: Schema7.optional(AssistantDeliveryMode),
-  runtimeMode: RuntimeMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
-  interactionMode: ProviderInteractionMode.pipe(Schema7.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  createdAt: IsoDateTime
-});
-var ThreadTurnInterruptRequestedPayload = Schema7.Struct({
-  threadId: ThreadId,
-  turnId: Schema7.optional(TurnId),
-  createdAt: IsoDateTime
-});
-var ThreadApprovalResponseRequestedPayload = Schema7.Struct({
-  threadId: ThreadId,
-  requestId: ApprovalRequestId,
-  decision: ProviderApprovalDecision,
-  createdAt: IsoDateTime
-});
-var ThreadUserInputResponseRequestedPayload = Schema7.Struct({
-  threadId: ThreadId,
-  requestId: ApprovalRequestId,
-  answers: ProviderUserInputAnswers,
-  createdAt: IsoDateTime
-});
-var ThreadCheckpointRevertRequestedPayload = Schema7.Struct({
-  threadId: ThreadId,
-  turnCount: NonNegativeInt,
-  createdAt: IsoDateTime
-});
-var ThreadRevertedPayload = Schema7.Struct({
-  threadId: ThreadId,
-  turnCount: NonNegativeInt
-});
-var ThreadSessionStopRequestedPayload = Schema7.Struct({
-  threadId: ThreadId,
-  createdAt: IsoDateTime
-});
-var ThreadSessionSetPayload = Schema7.Struct({
-  threadId: ThreadId,
-  session: OrchestrationSession
-});
-var ThreadProposedPlanUpsertedPayload = Schema7.Struct({
-  threadId: ThreadId,
-  proposedPlan: OrchestrationProposedPlan
-});
-var ThreadTurnDiffCompletedPayload = Schema7.Struct({
-  threadId: ThreadId,
-  turnId: TurnId,
-  checkpointTurnCount: NonNegativeInt,
-  checkpointRef: CheckpointRef,
-  status: OrchestrationCheckpointStatus,
-  files: Schema7.Array(OrchestrationCheckpointFile),
-  assistantMessageId: Schema7.NullOr(MessageId),
-  completedAt: IsoDateTime
-});
-var ThreadActivityAppendedPayload = Schema7.Struct({
-  threadId: ThreadId,
-  activity: OrchestrationThreadActivity
-});
-var OrchestrationEventMetadata = Schema7.Struct({
-  providerTurnId: Schema7.optional(TrimmedNonEmptyString),
-  providerItemId: Schema7.optional(ProviderItemId),
-  adapterKey: Schema7.optional(TrimmedNonEmptyString),
-  requestId: Schema7.optional(ApprovalRequestId),
-  ingestedAt: Schema7.optional(IsoDateTime)
-});
-var EventBaseFields = {
-  sequence: NonNegativeInt,
-  eventId: EventId,
-  aggregateKind: OrchestrationAggregateKind,
-  aggregateId: Schema7.Union([ProjectId, ThreadId]),
-  occurredAt: IsoDateTime,
-  commandId: Schema7.NullOr(CommandId),
-  causationEventId: Schema7.NullOr(EventId),
-  correlationId: Schema7.NullOr(CommandId),
-  metadata: OrchestrationEventMetadata
-};
-var PersistedEventBaseFields = {
-  sequence: NonNegativeInt,
-  eventId: EventId,
-  aggregateKind: OrchestrationAggregateKind,
-  streamId: Schema7.Union([ProjectId, ThreadId]),
-  streamVersion: NonNegativeInt,
-  occurredAt: IsoDateTime,
-  commandId: Schema7.NullOr(CommandId),
-  causationEventId: Schema7.NullOr(EventId),
-  correlationId: Schema7.NullOr(CommandId),
-  actorKind: OrchestrationActorKind,
-  metadata: OrchestrationEventMetadata
-};
-var OrchestrationEvent = Schema7.Union([
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("project.created"),
-    payload: ProjectCreatedPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("project.meta-updated"),
-    payload: ProjectMetaUpdatedPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("project.deleted"),
-    payload: ProjectDeletedPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("thread.created"),
-    payload: ThreadCreatedPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("thread.deleted"),
-    payload: ThreadDeletedPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("thread.meta-updated"),
-    payload: ThreadMetaUpdatedPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("thread.runtime-mode-set"),
-    payload: ThreadRuntimeModeSetPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("thread.interaction-mode-set"),
-    payload: ThreadInteractionModeSetPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("thread.message-sent"),
-    payload: ThreadMessageSentPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("thread.turn-start-requested"),
-    payload: ThreadTurnStartRequestedPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("thread.turn-interrupt-requested"),
-    payload: ThreadTurnInterruptRequestedPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("thread.approval-response-requested"),
-    payload: ThreadApprovalResponseRequestedPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("thread.user-input-response-requested"),
-    payload: ThreadUserInputResponseRequestedPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("thread.checkpoint-revert-requested"),
-    payload: ThreadCheckpointRevertRequestedPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("thread.reverted"),
-    payload: ThreadRevertedPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("thread.session-stop-requested"),
-    payload: ThreadSessionStopRequestedPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("thread.session-set"),
-    payload: ThreadSessionSetPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("thread.proposed-plan-upserted"),
-    payload: ThreadProposedPlanUpsertedPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("thread.turn-diff-completed"),
-    payload: ThreadTurnDiffCompletedPayload
-  }),
-  Schema7.Struct({
-    ...EventBaseFields,
-    type: Schema7.Literal("thread.activity-appended"),
-    payload: ThreadActivityAppendedPayload
-  })
-]);
-var OrchestrationPersistedEvent = Schema7.Union([
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("project.created"),
-    payload: ProjectCreatedPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("project.meta-updated"),
-    payload: ProjectMetaUpdatedPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("project.deleted"),
-    payload: ProjectDeletedPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("thread.created"),
-    payload: ThreadCreatedPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("thread.deleted"),
-    payload: ThreadDeletedPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("thread.meta-updated"),
-    payload: ThreadMetaUpdatedPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("thread.runtime-mode-set"),
-    payload: ThreadRuntimeModeSetPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("thread.interaction-mode-set"),
-    payload: ThreadInteractionModeSetPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("thread.message-sent"),
-    payload: ThreadMessageSentPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("thread.turn-start-requested"),
-    payload: ThreadTurnStartRequestedPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("thread.turn-interrupt-requested"),
-    payload: ThreadTurnInterruptRequestedPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("thread.approval-response-requested"),
-    payload: ThreadApprovalResponseRequestedPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("thread.user-input-response-requested"),
-    payload: ThreadUserInputResponseRequestedPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("thread.checkpoint-revert-requested"),
-    payload: ThreadCheckpointRevertRequestedPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("thread.reverted"),
-    payload: ThreadRevertedPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("thread.session-stop-requested"),
-    payload: ThreadSessionStopRequestedPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("thread.session-set"),
-    payload: ThreadSessionSetPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("thread.proposed-plan-upserted"),
-    payload: ThreadProposedPlanUpsertedPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("thread.turn-diff-completed"),
-    payload: ThreadTurnDiffCompletedPayload
-  }),
-  Schema7.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema7.Literal("thread.activity-appended"),
-    payload: ThreadActivityAppendedPayload
-  })
-]);
-var OrchestrationCommandReceiptStatus = Schema7.Literals(["accepted", "rejected"]);
-var TurnCountRange = Schema7.Struct({
-  fromTurnCount: NonNegativeInt,
-  toTurnCount: NonNegativeInt
-}).check(Schema7.makeFilter((input) => input.fromTurnCount <= input.toTurnCount || new SchemaIssue.InvalidValue(Option.some(input.fromTurnCount), {
-  message: "fromTurnCount must be less than or equal to toTurnCount"
-}), { identifier: "OrchestrationTurnDiffRange" }));
-var ThreadTurnDiff = TurnCountRange.mapFields(Struct.assign({
-  threadId: ThreadId,
-  diff: Schema7.String
-}), { unsafePreserveChecks: true });
-var ProviderSessionRuntimeStatus = Schema7.Literals([
-  "starting",
-  "running",
-  "stopped",
-  "error"
-]);
-var ProjectionThreadTurnStatus = Schema7.Literals([
-  "running",
-  "completed",
-  "interrupted",
-  "error"
-]);
-var ProjectionCheckpointRow = Schema7.Struct({
-  threadId: ThreadId,
-  turnId: TurnId,
-  checkpointTurnCount: NonNegativeInt,
-  checkpointRef: CheckpointRef,
-  status: OrchestrationCheckpointStatus,
-  files: Schema7.Array(OrchestrationCheckpointFile),
-  assistantMessageId: Schema7.NullOr(MessageId),
-  completedAt: IsoDateTime
-});
-var ProjectionPendingApprovalStatus = Schema7.Literals(["pending", "resolved"]);
-var ProjectionPendingApprovalDecision = Schema7.NullOr(ProviderApprovalDecision);
-var DispatchResult = Schema7.Struct({
-  sequence: NonNegativeInt
-});
-var OrchestrationGetSnapshotInput = Schema7.Struct({});
-var OrchestrationGetTurnDiffInput = TurnCountRange.mapFields(Struct.assign({ threadId: ThreadId }), { unsafePreserveChecks: true });
-var OrchestrationGetFullThreadDiffInput = Schema7.Struct({
-  threadId: ThreadId,
-  toTurnCount: NonNegativeInt
-});
-var OrchestrationReplayEventsInput = Schema7.Struct({
-  fromSequenceExclusive: NonNegativeInt
-});
-var OrchestrationReplayEventsResult = Schema7.Array(OrchestrationEvent);
-
-// packages/contracts/src/review.ts
-import { Schema as Schema8 } from "effect";
-var ReviewMode = Schema8.Literals(["off", "advisory", "required"]);
-var ReviewStatus = Schema8.Literals(["pending", "running", "approved", "rejected", "error"]);
-var ReviewSummary = Schema8.Struct({
-  id: ReviewResultId,
-  runId: RunId,
-  taskId: Schema8.NullOr(TaskId),
-  provider: TrimmedNonEmptyString,
-  mode: ReviewMode,
-  status: ReviewStatus,
-  summary: Schema8.NullOr(Schema8.String),
-  output: Schema8.Unknown,
-  createdAt: IsoDateTime,
-  completedAt: Schema8.NullOr(IsoDateTime)
-});
-
-// packages/contracts/src/runtime.ts
-import { Schema as Schema9 } from "effect";
-var RunKind = Schema9.Literals(["adhoc", "task", "batch", "validation", "review"]);
-var RunMode = Schema9.Literals(["interactive", "autonomous", "supervised"]);
-var RunStatus = Schema9.Literals([
-  "created",
-  "queued",
-  "preparing",
-  "running",
-  "waiting-approval",
-  "waiting-user-input",
-  "paused",
-  "validating",
-  "reviewing",
-  "closing-out",
-  "needs-attention",
-  "completed",
-  "failed",
-  "stopped"
-]);
-var EngineSandboxMode = Schema9.Literals([
-  "read-only",
-  "workspace-write",
-  "danger-full-access"
-]);
-var IsolationMode = Schema9.Literals(["none", "env", "worktree"]);
-var RuntimeStatus = Schema9.Literals([
-  "prepared",
-  "starting",
-  "running",
-  "interrupted",
-  "exited",
-  "failed",
-  "destroyed"
-]);
-var RunExecutionTarget = Schema9.Literals(["local", "remote"]);
-var RunSummary = Schema9.Struct({
-  id: RunId,
-  workspaceId: WorkspaceId,
-  taskId: Schema9.NullOr(TaskId),
-  title: TrimmedNonEmptyString,
-  runKind: RunKind,
-  mode: RunMode,
-  runtimeMode: RuntimeMode,
-  interactionMode: ProviderInteractionMode,
-  status: RunStatus,
-  runtimeAdapter: Schema9.Literal("pi"),
-  model: Schema9.NullOr(TrimmedNonEmptyString),
-  initialPrompt: Schema9.NullOr(Schema9.String),
-  executionTarget: Schema9.optional(RunExecutionTarget),
-  remoteHostId: Schema9.optional(Schema9.NullOr(TrimmedNonEmptyString)),
-  remoteLeaseId: Schema9.optional(Schema9.NullOr(TrimmedNonEmptyString)),
-  remoteLeaseClaimedAt: Schema9.optional(Schema9.NullOr(IsoDateTime)),
-  activeRuntimeId: Schema9.NullOr(EngineRuntimeId),
-  latestMessageId: Schema9.NullOr(TrimmedNonEmptyString),
-  pendingApprovalCount: NonNegativeInt,
-  pendingUserInputCount: NonNegativeInt,
-  branch: Schema9.NullOr(TrimmedNonEmptyString),
-  worktreePath: Schema9.NullOr(TrimmedNonEmptyString),
-  errorText: Schema9.NullOr(Schema9.String),
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime,
-  startedAt: Schema9.NullOr(IsoDateTime),
-  completedAt: Schema9.NullOr(IsoDateTime)
-});
-var RuntimeSummary = Schema9.Struct({
-  id: EngineRuntimeId,
-  workspaceId: WorkspaceId,
-  runId: RunId,
-  adapterKind: Schema9.Literal("pi"),
-  executionTarget: Schema9.optional(RunExecutionTarget),
-  remoteHostId: Schema9.optional(Schema9.NullOr(TrimmedNonEmptyString)),
-  status: RuntimeStatus,
-  sandboxMode: EngineSandboxMode,
-  isolationMode: IsolationMode,
-  workspaceDir: Schema9.NullOr(TrimmedNonEmptyString),
-  homeDir: Schema9.NullOr(TrimmedNonEmptyString),
-  tmpDir: Schema9.NullOr(TrimmedNonEmptyString),
-  cacheDir: Schema9.NullOr(TrimmedNonEmptyString),
-  logsDir: Schema9.NullOr(TrimmedNonEmptyString),
-  stateDir: Schema9.NullOr(TrimmedNonEmptyString),
-  sessionDir: Schema9.NullOr(TrimmedNonEmptyString),
-  sessionLogPath: Schema9.NullOr(TrimmedNonEmptyString),
-  pid: Schema9.NullOr(NonNegativeInt),
-  startedAt: Schema9.NullOr(IsoDateTime),
-  updatedAt: IsoDateTime,
-  exitedAt: Schema9.NullOr(IsoDateTime)
-});
-var ApprovalStatus = Schema9.Literals(["pending", "resolved"]);
-var ApprovalSummary = Schema9.Struct({
-  id: TrimmedNonEmptyString,
-  runId: RunId,
-  actionId: Schema9.NullOr(TrimmedNonEmptyString),
-  requestKind: TrimmedNonEmptyString,
-  status: ApprovalStatus,
-  payload: Schema9.Unknown,
-  createdAt: IsoDateTime,
-  resolvedAt: Schema9.NullOr(IsoDateTime)
-});
-var UserInputRequestSummary = Schema9.Struct({
-  id: TrimmedNonEmptyString,
-  runId: RunId,
-  status: ApprovalStatus,
-  payload: Schema9.Unknown,
-  createdAt: IsoDateTime,
-  resolvedAt: Schema9.NullOr(IsoDateTime)
-});
-var WorktreeSummary = Schema9.Struct({
-  id: WorktreeId,
-  workspaceId: WorkspaceId,
-  runId: RunId,
-  taskId: Schema9.NullOr(TaskId),
-  branchName: TrimmedNonEmptyString,
-  path: TrimmedNonEmptyString,
-  status: TrimmedNonEmptyString,
-  createdAt: IsoDateTime,
-  cleanedAt: Schema9.NullOr(IsoDateTime)
-});
-
-// packages/contracts/src/validation.ts
-import { Schema as Schema10 } from "effect";
-var ValidationStatus = Schema10.Literals([
-  "pending",
-  "running",
-  "passed",
-  "failed",
-  "skipped"
-]);
-var ValidationSummary = Schema10.Struct({
-  id: ValidationResultId,
-  runId: RunId,
-  taskId: Schema10.NullOr(TaskId),
-  validatorKey: TrimmedNonEmptyString,
-  status: ValidationStatus,
-  output: Schema10.Unknown,
-  startedAt: IsoDateTime,
-  completedAt: Schema10.NullOr(IsoDateTime)
-});
-
-// packages/contracts/src/remote.ts
-import { Schema as Schema12 } from "effect";
-
-// packages/contracts/src/workspace.ts
-import { Schema as Schema11 } from "effect";
-var WorkspaceSourceKind = Schema11.Literals(["native", "rig-import", "manual", "remote"]);
-var WorkspaceTopologyStatus = Schema11.Literals(["empty", "ready", "degraded"]);
-var WorkspaceRemoteFleetStatus = Schema11.Literals(["empty", "ready", "degraded"]);
-var WorkspaceServiceFabricStatus = Schema11.Literals([
-  "empty",
-  "booting",
-  "ready",
-  "degraded",
-  "stopped"
-]);
-var WorkspaceRemoteHostStatus = Schema11.Literals([
-  "registering",
-  "ready",
-  "busy",
-  "degraded",
-  "draining",
-  "offline",
-  "quarantined"
-]);
-var WorkspaceTopologyServiceSummary = Schema11.Struct({
-  name: TrimmedNonEmptyString,
-  relativeRootPath: TrimmedNonEmptyString,
-  runtime: TrimmedNonEmptyString,
-  port: Schema11.NullOr(Schema11.Number),
-  healthcheck: Schema11.NullOr(TrimmedNonEmptyString),
-  sourceOfTruth: Schema11.Struct({
-    code: Schema11.NullOr(TrimmedNonEmptyString),
-    tests: Schema11.NullOr(TrimmedNonEmptyString),
-    infra: Schema11.NullOr(TrimmedNonEmptyString),
-    deploy: Schema11.NullOr(TrimmedNonEmptyString),
-    dependencies: Schema11.NullOr(TrimmedNonEmptyString)
-  }),
-  splitReadyChecklist: Schema11.Array(TrimmedNonEmptyString)
-});
-var WorkspaceTopologySummary = Schema11.Struct({
-  compiledAt: IsoDateTime,
-  status: WorkspaceTopologyStatus,
-  manifestCount: Schema11.Number,
-  serviceCount: Schema11.Number,
-  services: Schema11.Array(WorkspaceTopologyServiceSummary),
-  warnings: Schema11.Array(Schema11.String)
-});
-var WorkspaceRemoteHostSummary = Schema11.Struct({
-  id: TrimmedNonEmptyString,
-  name: TrimmedNonEmptyString,
-  baseUrl: TrimmedNonEmptyString,
-  workspacePath: Schema11.NullOr(TrimmedNonEmptyString),
-  transport: TrimmedNonEmptyString,
-  hostname: Schema11.NullOr(TrimmedNonEmptyString),
-  region: Schema11.NullOr(TrimmedNonEmptyString),
-  labels: Schema11.Array(TrimmedNonEmptyString),
-  capabilities: Schema11.Array(TrimmedNonEmptyString),
-  runtimeAdapters: Schema11.Array(Schema11.Literal("pi")),
-  status: WorkspaceRemoteHostStatus,
-  currentLeaseCount: Schema11.Number,
-  lastHeartbeatAt: Schema11.NullOr(IsoDateTime),
-  registeredAt: IsoDateTime,
-  manifestPath: TrimmedNonEmptyString
-});
-var WorkspaceRemoteFleetSummary = Schema11.Struct({
-  updatedAt: IsoDateTime,
-  status: WorkspaceRemoteFleetStatus,
-  manifestCount: Schema11.Number,
-  hostCount: Schema11.Number,
-  onlineHostCount: Schema11.Number,
-  hosts: Schema11.Array(WorkspaceRemoteHostSummary),
-  warnings: Schema11.Array(Schema11.String)
-});
-var WorkspaceServiceFabricServiceSummary = Schema11.Struct({
-  name: TrimmedNonEmptyString,
-  relativeRootPath: TrimmedNonEmptyString,
-  mode: Schema11.Literals(["stub", "process"]),
-  port: Schema11.Number,
-  healthcheck: TrimmedNonEmptyString,
-  routePrefix: Schema11.NullOr(TrimmedNonEmptyString),
-  status: Schema11.Literals(["planned", "booting", "healthy", "degraded", "failed", "stopped"]),
-  pid: Schema11.NullOr(Schema11.Number),
-  logPath: Schema11.NullOr(TrimmedNonEmptyString)
-});
-var WorkspaceServiceFabricSummary = Schema11.Struct({
-  updatedAt: IsoDateTime,
-  status: WorkspaceServiceFabricStatus,
-  serviceCount: Schema11.Number,
-  healthyServiceCount: Schema11.Number,
-  stateDir: TrimmedNonEmptyString,
-  services: Schema11.Array(WorkspaceServiceFabricServiceSummary),
-  warnings: Schema11.Array(Schema11.String)
-});
-var WorkspaceSummary = Schema11.Struct({
-  id: WorkspaceId,
-  title: TrimmedNonEmptyString,
-  rootPath: TrimmedNonEmptyString,
-  sourceKind: WorkspaceSourceKind,
-  defaultRuntimeAdapter: Schema11.optional(Schema11.Literal("pi")),
-  defaultProvider: Schema11.optional(ProviderKind),
-  defaultModel: Schema11.NullOr(TrimmedNonEmptyString),
-  topology: Schema11.optional(WorkspaceTopologySummary),
-  remoteFleet: Schema11.optional(WorkspaceRemoteFleetSummary),
-  serviceFabric: Schema11.optional(WorkspaceServiceFabricSummary),
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime
-});
-
-// packages/contracts/src/remote.ts
-var RemoteRuntimeAdapter = Schema12.Literal("pi");
-var RemoteEndpoint = Schema12.Struct({
-  id: RemoteEndpointId,
-  alias: TrimmedNonEmptyString,
-  host: TrimmedNonEmptyString,
-  port: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1)).check(Schema12.isLessThanOrEqualTo(65535)),
-  token: Schema12.String,
-  tokenConfigured: Schema12.optional(Schema12.Boolean),
-  autoConnect: Schema12.optional(Schema12.Boolean),
-  addedAt: IsoDateTime,
-  lastConnectedAt: Schema12.NullOr(IsoDateTime)
-});
-var RemoteConnectionStatus = Schema12.Literals([
-  "disconnected",
-  "connecting",
-  "authenticating",
-  "connected",
-  "reconnecting",
-  "error"
-]);
-var RemoteConnectionSummary = Schema12.Struct({
-  endpointId: RemoteEndpointId,
-  status: RemoteConnectionStatus,
-  error: Schema12.NullOr(Schema12.String),
-  connectedAt: Schema12.NullOr(IsoDateTime),
-  tokenExpiresAt: Schema12.NullOr(IsoDateTime),
-  latencyMs: Schema12.NullOr(Schema12.Number),
-  subscribedEvents: Schema12.Array(Schema12.String)
-});
-var RemoteConnectionStatusChanged = Schema12.Struct({
-  endpointId: Schema12.String,
-  endpointAlias: Schema12.String,
-  status: RemoteConnectionStatus,
-  previousStatus: RemoteConnectionStatus,
-  error: Schema12.NullOr(Schema12.String),
-  connectedAt: Schema12.NullOr(Schema12.String),
-  latencyMs: Schema12.NullOr(Schema12.Number),
-  timestamp: Schema12.String
-});
-var EnrichedRemoteEvent = Schema12.Struct({
-  endpointId: Schema12.String,
-  endpointAlias: Schema12.String,
-  receivedAt: Schema12.String,
-  originalTimestamp: Schema12.optional(Schema12.NullOr(Schema12.String)),
-  event: Schema12.Unknown
-});
-var RemoteOrchestratorState = Schema12.Struct({
-  activeTaskId: Schema12.NullOr(Schema12.String),
-  activeIteration: Schema12.NullOr(Schema12.Number),
-  maxIterations: Schema12.Number,
-  isPaused: Schema12.Boolean,
-  isRunning: Schema12.Boolean,
-  totalCompleted: NonNegativeInt,
-  totalFailed: NonNegativeInt,
-  lastActivity: Schema12.NullOr(IsoDateTime)
-});
-var RemoteOrchestrationSummary = Schema12.Struct({
-  orchestrationId: TrimmedNonEmptyString,
-  endpointId: RemoteEndpointId,
-  status: Schema12.Literals(["running", "paused", "stopped", "completed"]),
-  totalTasks: NonNegativeInt,
-  totalGroups: NonNegativeInt,
-  maxParallelism: NonNegativeInt,
-  startedAt: IsoDateTime
-});
-var RemoteIterationOutput = Schema12.Struct({
-  taskId: Schema12.optional(Schema12.String),
-  iteration: Schema12.optional(Schema12.Number),
-  output: Schema12.optional(Schema12.String),
-  startedAt: Schema12.optional(IsoDateTime),
-  endedAt: Schema12.optional(IsoDateTime),
-  durationMs: Schema12.optional(Schema12.Number),
-  isRunning: Schema12.optional(Schema12.Boolean)
-});
-var RemoteRunnerRegisterInput = Schema12.Struct({
-  workspaceId: WorkspaceId,
-  hostId: TrimmedNonEmptyString,
-  name: TrimmedNonEmptyString,
-  baseUrl: TrimmedNonEmptyString,
-  workspacePath: Schema12.optional(TrimmedNonEmptyString),
-  transport: Schema12.optional(TrimmedNonEmptyString),
-  hostname: Schema12.optional(TrimmedNonEmptyString),
-  region: Schema12.optional(TrimmedNonEmptyString),
-  labels: Schema12.optional(Schema12.Array(TrimmedNonEmptyString)),
-  capabilities: Schema12.optional(Schema12.Array(TrimmedNonEmptyString)),
-  runtimeAdapters: Schema12.optional(Schema12.Array(RemoteRuntimeAdapter)),
-  status: Schema12.optional(WorkspaceRemoteHostStatus),
-  currentLeaseCount: Schema12.optional(Schema12.Number)
-});
-var RemoteRunnerHeartbeatInput = Schema12.Struct({
-  workspaceId: WorkspaceId,
-  hostId: TrimmedNonEmptyString,
-  status: WorkspaceRemoteHostStatus,
-  currentLeaseCount: Schema12.optional(Schema12.Number),
-  observedAt: Schema12.optional(IsoDateTime)
-});
-var RemoteRunnerLifecycleResult = Schema12.Struct({
-  ok: Schema12.Boolean,
-  workspaceId: WorkspaceId,
-  hostId: TrimmedNonEmptyString,
-  acceptedAt: IsoDateTime,
-  heartbeatIntervalMs: Schema12.Number
-});
-var RemoteRunClaimInput = Schema12.Struct({
-  workspaceId: WorkspaceId,
-  hostId: TrimmedNonEmptyString,
-  runtimeAdapters: Schema12.optional(Schema12.Array(RemoteRuntimeAdapter))
-});
-var RemoteRunLeaseSummary = Schema12.Struct({
-  leaseId: TrimmedNonEmptyString,
-  runId: TrimmedNonEmptyString,
-  workspaceId: WorkspaceId,
-  title: TrimmedNonEmptyString,
-  runtimeAdapter: RemoteRuntimeAdapter,
-  model: Schema12.NullOr(TrimmedNonEmptyString),
-  runtimeMode: RuntimeMode,
-  interactionMode: ProviderInteractionMode,
-  executionTarget: RunExecutionTarget,
-  remoteHostId: Schema12.NullOr(TrimmedNonEmptyString),
-  claimedAt: IsoDateTime
-});
-var RemoteRunConversationEntry = Schema12.Struct({
-  role: Schema12.Literals(["user", "assistant", "system"]),
-  text: Schema12.String,
-  createdAt: IsoDateTime
-});
-var RemoteRunExecutionBundle = Schema12.Struct({
-  workspaceId: WorkspaceId,
-  runId: TrimmedNonEmptyString,
-  leaseId: TrimmedNonEmptyString,
-  workspacePath: Schema12.NullOr(TrimmedNonEmptyString),
-  runtimeAdapter: RemoteRuntimeAdapter,
-  model: Schema12.NullOr(TrimmedNonEmptyString),
-  runtimeMode: RuntimeMode,
-  interactionMode: ProviderInteractionMode,
-  prompt: Schema12.String,
-  conversation: Schema12.Array(RemoteRunConversationEntry),
-  taskId: Schema12.NullOr(TrimmedNonEmptyString),
-  taskTitle: Schema12.NullOr(TrimmedNonEmptyString)
-});
-var RemoteRunClaimResult = Schema12.Struct({
-  ok: Schema12.Boolean,
-  workspaceId: WorkspaceId,
-  hostId: TrimmedNonEmptyString,
-  acceptedAt: IsoDateTime,
-  lease: Schema12.NullOr(RemoteRunLeaseSummary),
-  bundle: Schema12.NullOr(RemoteRunExecutionBundle)
-});
-var RemoteRunReleaseInput = Schema12.Struct({
-  workspaceId: WorkspaceId,
-  hostId: TrimmedNonEmptyString,
-  runId: TrimmedNonEmptyString,
-  leaseId: TrimmedNonEmptyString,
-  status: Schema12.optional(WorkspaceRemoteHostStatus)
-});
-var RemoteRunReleaseResult = Schema12.Struct({
-  ok: Schema12.Boolean,
-  workspaceId: WorkspaceId,
-  hostId: TrimmedNonEmptyString,
-  runId: TrimmedNonEmptyString,
-  leaseId: TrimmedNonEmptyString,
-  acceptedAt: IsoDateTime
-});
-var RemoteRunStartInput = Schema12.Struct({
-  workspaceId: WorkspaceId,
-  hostId: TrimmedNonEmptyString,
-  runId: TrimmedNonEmptyString,
-  leaseId: TrimmedNonEmptyString
-});
-var RemoteRunStartResult = Schema12.Struct({
-  ok: Schema12.Boolean,
-  workspaceId: WorkspaceId,
-  hostId: TrimmedNonEmptyString,
-  runId: TrimmedNonEmptyString,
-  leaseId: TrimmedNonEmptyString,
-  runtimeId: TrimmedNonEmptyString,
-  acceptedAt: IsoDateTime
-});
-var RemoteRunLogInput = Schema12.Struct({
-  workspaceId: WorkspaceId,
-  hostId: TrimmedNonEmptyString,
-  runId: TrimmedNonEmptyString,
-  leaseId: TrimmedNonEmptyString,
-  title: TrimmedNonEmptyString,
-  detail: Schema12.optional(Schema12.String),
-  tone: Schema12.optional(EngineLogTone),
-  status: Schema12.optional(TrimmedNonEmptyString),
-  payload: Schema12.optional(Schema12.Unknown)
-});
-var RemoteRunMessageInput = Schema12.Struct({
-  workspaceId: WorkspaceId,
-  hostId: TrimmedNonEmptyString,
-  runId: TrimmedNonEmptyString,
-  leaseId: TrimmedNonEmptyString,
-  messageId: Schema12.optional(TrimmedNonEmptyString),
-  text: Schema12.String,
-  state: Schema12.optional(Schema12.Literals(["streaming", "completed"]))
-});
-var RemoteRunMutationResult = Schema12.Struct({
-  ok: Schema12.Boolean,
-  workspaceId: WorkspaceId,
-  hostId: TrimmedNonEmptyString,
-  runId: TrimmedNonEmptyString,
-  leaseId: TrimmedNonEmptyString,
-  acceptedAt: IsoDateTime
-});
-var RemoteRunCompleteInput = Schema12.Struct({
-  workspaceId: WorkspaceId,
-  hostId: TrimmedNonEmptyString,
-  runId: TrimmedNonEmptyString,
-  leaseId: TrimmedNonEmptyString
-});
-var RemoteRunFailInput = Schema12.Struct({
-  workspaceId: WorkspaceId,
-  hostId: TrimmedNonEmptyString,
-  runId: TrimmedNonEmptyString,
-  leaseId: TrimmedNonEmptyString,
-  errorText: Schema12.optional(Schema12.String)
-});
-var RemoteRunArtifactInput = Schema12.Struct({
-  workspaceId: WorkspaceId,
-  hostId: TrimmedNonEmptyString,
-  runId: TrimmedNonEmptyString,
-  leaseId: TrimmedNonEmptyString,
-  kind: TrimmedNonEmptyString,
-  label: TrimmedNonEmptyString,
-  filename: TrimmedNonEmptyString,
-  contentType: TrimmedNonEmptyString,
-  contentBase64: TrimmedNonEmptyString
-});
-var RemoteRunArtifactResult = Schema12.Struct({
-  ok: Schema12.Boolean,
-  workspaceId: WorkspaceId,
-  hostId: TrimmedNonEmptyString,
-  runId: TrimmedNonEmptyString,
-  leaseId: TrimmedNonEmptyString,
-  acceptedAt: IsoDateTime,
-  artifactPath: TrimmedNonEmptyString
-});
-var RemoteRunArtifactSummary = Schema12.Struct({
-  workspaceId: WorkspaceId,
-  runId: TrimmedNonEmptyString,
-  hostId: TrimmedNonEmptyString,
-  leaseId: TrimmedNonEmptyString,
-  kind: TrimmedNonEmptyString,
-  label: TrimmedNonEmptyString,
-  filename: TrimmedNonEmptyString,
-  contentType: TrimmedNonEmptyString,
-  uploadedAt: IsoDateTime,
-  byteSize: Schema12.Number,
-  artifactPath: TrimmedNonEmptyString,
-  downloadPath: TrimmedNonEmptyString
-});
-var RemoteRunArtifactsResult = Schema12.Struct({
-  workspaceId: WorkspaceId,
-  runId: TrimmedNonEmptyString,
-  artifacts: Schema12.Array(RemoteRunArtifactSummary)
-});
-
-// packages/contracts/src/engine.ts
-var EngineEvent = Schema13.Struct({
-  id: EventId,
-  sequence: NonNegativeInt,
-  createdAt: IsoDateTime,
-  type: TrimmedNonEmptyString,
-  aggregateId: TrimmedNonEmptyString,
-  payload: Schema13.Unknown
-});
-var EngineReadModel = Schema13.Struct({
-  snapshotSequence: NonNegativeInt,
-  workspaces: Schema13.Array(WorkspaceSummary),
-  graphs: Schema13.Array(GraphSummary),
-  tasks: Schema13.Array(TaskSummary),
-  runs: Schema13.Array(RunSummary),
-  runtimes: Schema13.Array(RuntimeSummary),
-  conversations: Schema13.Array(ConversationSummary),
-  messages: Schema13.Array(EngineMessage),
-  actions: Schema13.Array(EngineAction),
-  logs: Schema13.Array(EngineRunLog),
-  approvals: Schema13.Array(ApprovalSummary),
-  userInputs: Schema13.optional(Schema13.Array(UserInputRequestSummary)),
-  validations: Schema13.Array(ValidationSummary),
-  reviews: Schema13.Array(ReviewSummary),
-  artifacts: Schema13.Array(ArtifactSummary),
-  policyDecisions: Schema13.Array(PolicyDecisionSummary),
-  queue: Schema13.Array(QueueEntry),
-  worktrees: Schema13.Array(WorktreeSummary),
-  remoteEndpoints: Schema13.Array(RemoteEndpoint),
-  remoteConnections: Schema13.Array(RemoteConnectionSummary),
-  remoteOrchestrations: Schema13.Array(RemoteOrchestrationSummary),
-  updatedAt: IsoDateTime
-});
-var RuntimeAdapterKind = Schema13.Literal("pi");
-var WorkspaceRegisterCommand = Schema13.Struct({
-  type: Schema13.Literal("workspace.register"),
-  commandId: CommandId,
-  workspaceId: WorkspaceId,
-  title: TrimmedNonEmptyString,
-  rootPath: TrimmedNonEmptyString,
-  defaultModel: Schema13.optional(TrimmedNonEmptyString),
-  createdAt: IsoDateTime
-});
-var WorkspaceImportRigCommand = Schema13.Struct({
-  type: Schema13.Literal("workspace.importRig"),
-  commandId: CommandId,
-  workspaceId: WorkspaceId,
-  rootPath: TrimmedNonEmptyString,
-  title: Schema13.optional(TrimmedNonEmptyString),
-  createdAt: IsoDateTime
-});
-var RunCreateAdhocCommand = Schema13.Struct({
-  type: Schema13.Literal("run.createAdhoc"),
-  commandId: CommandId,
-  runId: RunId,
-  workspaceId: WorkspaceId,
-  title: TrimmedNonEmptyString,
-  runtimeAdapter: Schema13.optional(RuntimeAdapterKind),
-  model: Schema13.optional(TrimmedNonEmptyString),
-  executionTarget: Schema13.optional(RunExecutionTarget),
-  remoteHostId: Schema13.optional(TrimmedNonEmptyString),
-  runtimeMode: RuntimeMode.pipe(Schema13.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
-  interactionMode: ProviderInteractionMode.pipe(Schema13.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  initialPrompt: Schema13.optional(Schema13.String),
-  createdAt: IsoDateTime
-});
-var RunCreateForTaskCommand = Schema13.Struct({
-  type: Schema13.Literal("run.createForTask"),
-  commandId: CommandId,
-  runId: RunId,
-  workspaceId: WorkspaceId,
-  taskId: TaskId,
-  runtimeAdapter: Schema13.optional(RuntimeAdapterKind),
-  model: Schema13.optional(TrimmedNonEmptyString),
-  executionTarget: Schema13.optional(RunExecutionTarget),
-  remoteHostId: Schema13.optional(TrimmedNonEmptyString),
-  runtimeMode: RuntimeMode.pipe(Schema13.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
-  interactionMode: ProviderInteractionMode.pipe(Schema13.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  createdAt: IsoDateTime
-});
-var RunSubmitUserMessageCommand = Schema13.Struct({
-  type: Schema13.Literal("run.submitUserMessage"),
-  commandId: CommandId,
-  runId: RunId,
-  messageId: MessageId,
-  text: Schema13.String,
-  attachments: Schema13.optional(Schema13.Array(Schema13.Unknown)),
-  createdAt: IsoDateTime
-});
-var RunInterruptCommand = Schema13.Struct({
-  type: Schema13.Literal("run.interrupt"),
-  commandId: CommandId,
-  runId: RunId,
-  createdAt: IsoDateTime
-});
-var RunStopCommand = Schema13.Struct({
-  type: Schema13.Literal("run.stop"),
-  commandId: CommandId,
-  runId: RunId,
-  createdAt: IsoDateTime
-});
-var RunSetRuntimeModeCommand = Schema13.Struct({
-  type: Schema13.Literal("run.setRuntimeMode"),
-  commandId: CommandId,
-  runId: RunId,
-  runtimeMode: RuntimeMode,
-  createdAt: IsoDateTime
-});
-var RunSetInteractionModeCommand = Schema13.Struct({
-  type: Schema13.Literal("run.setInteractionMode"),
-  commandId: CommandId,
-  runId: RunId,
-  interactionMode: ProviderInteractionMode,
-  createdAt: IsoDateTime
-});
-var RunRespondApprovalCommand = Schema13.Struct({
-  type: Schema13.Literal("run.respondApproval"),
-  commandId: CommandId,
-  runId: RunId,
-  requestId: ApprovalRequestId,
-  decision: ProviderApprovalDecision,
-  createdAt: IsoDateTime
-});
-var RunRespondUserInputCommand = Schema13.Struct({
-  type: Schema13.Literal("run.respondUserInput"),
-  commandId: CommandId,
-  runId: RunId,
-  requestId: ApprovalRequestId,
-  answers: ProviderUserInputAnswers,
-  createdAt: IsoDateTime
-});
-var RuntimePrepareCommand = Schema13.Struct({
-  type: Schema13.Literal("runtime.prepare"),
-  commandId: CommandId,
-  runId: RunId,
-  workspaceId: WorkspaceId,
-  adapter: RuntimeAdapterKind,
-  executionTarget: Schema13.optional(RunExecutionTarget),
-  remoteHostId: Schema13.optional(TrimmedNonEmptyString),
-  model: Schema13.optional(TrimmedNonEmptyString),
-  createdAt: IsoDateTime
-});
-var RuntimeAttachCommand = Schema13.Struct({
-  type: Schema13.Literal("runtime.attach"),
-  commandId: CommandId,
-  runId: RunId,
-  runtimeId: EngineRuntimeId,
-  createdAt: IsoDateTime
-});
-var RuntimeDetachCommand = Schema13.Struct({
-  type: Schema13.Literal("runtime.detach"),
-  commandId: CommandId,
-  runId: RunId,
-  reason: TrimmedNonEmptyString,
-  createdAt: IsoDateTime
-});
-var GraphUpdateTaskStatusCommand = Schema13.Struct({
-  type: Schema13.Literal("graph.updateTaskStatus"),
-  commandId: CommandId,
-  taskId: TaskId,
-  status: TaskStatus,
-  createdAt: IsoDateTime
-});
-var TaskEnqueueCommand = Schema13.Struct({
-  type: Schema13.Literal("task.enqueue"),
-  commandId: CommandId,
-  taskId: TaskId,
-  score: NonNegativeInt,
-  createdAt: IsoDateTime
-});
-var WorkspaceHydrateImportedStateCommand = Schema13.Struct({
-  type: Schema13.Literal("workspace.hydrateImportedState"),
-  commandId: CommandId,
-  workspaceId: WorkspaceId,
-  rootPath: Schema13.optional(Schema13.String),
-  graph: GraphSummary,
-  tasks: Schema13.Array(TaskSummary),
-  runs: Schema13.Array(RunSummary),
-  runtimes: Schema13.Array(RuntimeSummary),
-  actions: Schema13.Array(EngineAction),
-  logs: Schema13.optional(Schema13.Array(EngineRunLog)),
-  validations: Schema13.Array(ValidationSummary),
-  reviews: Schema13.Array(ReviewSummary),
-  artifacts: Schema13.Array(ArtifactSummary),
-  policyDecisions: Schema13.Array(PolicyDecisionSummary),
-  queue: Schema13.Array(QueueEntry),
-  createdAt: IsoDateTime
-});
-var WorkspaceCompileTopologyCommand = Schema13.Struct({
-  type: Schema13.Literal("workspace.compileTopology"),
-  commandId: CommandId,
-  workspaceId: WorkspaceId,
-  rootPath: TrimmedNonEmptyString,
-  topology: WorkspaceTopologySummary,
-  createdAt: IsoDateTime
-});
-var WorkspaceSyncRemoteFleetCommand = Schema13.Struct({
-  type: Schema13.Literal("workspace.syncRemoteFleet"),
-  commandId: CommandId,
-  workspaceId: WorkspaceId,
-  rootPath: TrimmedNonEmptyString,
-  remoteFleet: WorkspaceRemoteFleetSummary,
-  createdAt: IsoDateTime
-});
-var WorkspaceSyncServiceFabricCommand = Schema13.Struct({
-  type: Schema13.Literal("workspace.syncServiceFabric"),
-  commandId: CommandId,
-  workspaceId: WorkspaceId,
-  rootPath: TrimmedNonEmptyString,
-  serviceFabric: WorkspaceServiceFabricSummary,
-  createdAt: IsoDateTime
-});
-var WorkspaceRegisterRemoteHostCommand = Schema13.Struct({
-  type: Schema13.Literal("workspace.registerRemoteHost"),
-  commandId: CommandId,
-  workspaceId: WorkspaceId,
-  host: Schema13.Struct({
-    id: TrimmedNonEmptyString,
-    name: TrimmedNonEmptyString,
-    baseUrl: TrimmedNonEmptyString,
-    workspacePath: Schema13.NullOr(TrimmedNonEmptyString),
-    transport: TrimmedNonEmptyString,
-    hostname: Schema13.NullOr(TrimmedNonEmptyString),
-    region: Schema13.NullOr(TrimmedNonEmptyString),
-    labels: Schema13.Array(TrimmedNonEmptyString),
-    capabilities: Schema13.Array(TrimmedNonEmptyString),
-    runtimeAdapters: Schema13.Array(RuntimeAdapterKind),
-    status: Schema13.Literals([
-      "registering",
-      "ready",
-      "busy",
-      "degraded",
-      "draining",
-      "offline",
-      "quarantined"
-    ]),
-    currentLeaseCount: Schema13.Number,
-    lastHeartbeatAt: Schema13.NullOr(IsoDateTime),
-    registeredAt: IsoDateTime,
-    manifestPath: TrimmedNonEmptyString
-  }),
-  createdAt: IsoDateTime
-});
-var WorkspaceUpdateRemoteHostStatusCommand = Schema13.Struct({
-  type: Schema13.Literal("workspace.updateRemoteHostStatus"),
-  commandId: CommandId,
-  workspaceId: WorkspaceId,
-  hostId: TrimmedNonEmptyString,
-  status: Schema13.Literals([
-    "registering",
-    "ready",
-    "busy",
-    "degraded",
-    "draining",
-    "offline",
-    "quarantined"
-  ]),
-  currentLeaseCount: Schema13.optional(Schema13.Number),
-  lastHeartbeatAt: Schema13.optional(IsoDateTime),
-  createdAt: IsoDateTime
-});
-var RunClaimRemoteLeaseCommand = Schema13.Struct({
-  type: Schema13.Literal("run.claimRemoteLease"),
-  commandId: CommandId,
-  runId: RunId,
-  hostId: TrimmedNonEmptyString,
-  leaseId: TrimmedNonEmptyString,
-  createdAt: IsoDateTime
-});
-var RunReleaseRemoteLeaseCommand = Schema13.Struct({
-  type: Schema13.Literal("run.releaseRemoteLease"),
-  commandId: CommandId,
-  runId: RunId,
-  leaseId: TrimmedNonEmptyString,
-  createdAt: IsoDateTime
-});
-var RuntimeRecordMessageCommand = Schema13.Struct({
-  type: Schema13.Literal("runtime.recordMessage"),
-  commandId: CommandId,
-  runId: RunId,
-  messageId: MessageId,
-  role: EngineMessageRole,
-  text: Schema13.String,
-  state: EngineMessageState,
-  attachments: Schema13.optional(Schema13.Array(Schema13.Unknown)),
-  createdAt: IsoDateTime,
-  completedAt: Schema13.optional(IsoDateTime)
-});
-var RuntimeStartActionCommand = Schema13.Struct({
-  type: Schema13.Literal("runtime.startAction"),
-  commandId: CommandId,
-  runId: RunId,
-  actionId: ActionId,
-  messageId: Schema13.optional(MessageId),
-  actionType: TrimmedNonEmptyString,
-  title: TrimmedNonEmptyString,
-  detail: Schema13.optional(Schema13.String),
-  payload: Schema13.Unknown,
-  createdAt: IsoDateTime
-});
-var RuntimeCompleteActionCommand = Schema13.Struct({
-  type: Schema13.Literal("runtime.completeAction"),
-  commandId: CommandId,
-  runId: RunId,
-  actionId: ActionId,
-  state: TrimmedNonEmptyString,
-  detail: Schema13.optional(Schema13.String),
-  payload: Schema13.Unknown,
-  createdAt: IsoDateTime
-});
-var RuntimeRecordLogCommand = Schema13.Struct({
-  type: Schema13.Literal("runtime.recordLog"),
-  commandId: CommandId,
-  runId: RunId,
-  logId: TrimmedNonEmptyString,
-  title: TrimmedNonEmptyString,
-  detail: Schema13.optional(Schema13.String),
-  tone: EngineLogTone,
-  status: Schema13.optional(TrimmedNonEmptyString),
-  payload: Schema13.optional(Schema13.Unknown),
-  createdAt: IsoDateTime
-});
-var RuntimeUpdateMetadataCommand = Schema13.Struct({
-  type: Schema13.Literal("runtime.updateMetadata"),
-  commandId: CommandId,
-  runId: RunId,
-  runtimeId: EngineRuntimeId,
-  sandboxMode: Schema13.optional(EngineSandboxMode),
-  isolationMode: Schema13.optional(IsolationMode),
-  workspaceDir: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
-  homeDir: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
-  tmpDir: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
-  cacheDir: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
-  logsDir: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
-  stateDir: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
-  sessionDir: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
-  sessionLogPath: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
-  pid: Schema13.optional(NonNegativeInt),
-  worktreePath: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
-  branch: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
-  createdAt: IsoDateTime
-});
-var RuntimeRequestApprovalCommand = Schema13.Struct({
-  type: Schema13.Literal("runtime.requestApproval"),
-  commandId: CommandId,
-  runId: RunId,
-  requestId: ApprovalRequestId,
-  requestKind: TrimmedNonEmptyString,
-  actionId: Schema13.optional(ActionId),
-  payload: Schema13.Unknown,
-  createdAt: IsoDateTime
-});
-var RuntimeRequestUserInputCommand = Schema13.Struct({
-  type: Schema13.Literal("runtime.requestUserInput"),
-  commandId: CommandId,
-  runId: RunId,
-  requestId: ApprovalRequestId,
-  payload: Schema13.Unknown,
-  createdAt: IsoDateTime
-});
-var RunMarkCompletedCommand = Schema13.Struct({
-  type: Schema13.Literal("run.markCompleted"),
-  commandId: CommandId,
-  runId: RunId,
-  createdAt: IsoDateTime
-});
-var RunMarkFailedCommand = Schema13.Struct({
-  type: Schema13.Literal("run.markFailed"),
-  commandId: CommandId,
-  runId: RunId,
-  errorText: Schema13.optional(Schema13.String),
-  createdAt: IsoDateTime
-});
-var RunSetStatusCommand = Schema13.Struct({
-  type: Schema13.Literal("run.setStatus"),
-  commandId: CommandId,
-  runId: RunId,
-  status: Schema13.Literals(["created", "queued", "preparing", "running", "validating", "reviewing", "paused"]),
-  createdAt: IsoDateTime
-});
-var RuntimeRecordValidationCommand = Schema13.Struct({
-  type: Schema13.Literal("runtime.recordValidation"),
-  commandId: CommandId,
-  runId: RunId,
-  taskId: Schema13.optional(Schema13.NullOr(TaskId)),
-  validationId: ValidationResultId,
-  validatorKey: TrimmedNonEmptyString,
-  status: Schema13.Literals(["pending", "running", "passed", "failed", "skipped"]),
-  output: Schema13.Unknown,
-  startedAt: IsoDateTime,
-  completedAt: Schema13.optional(Schema13.NullOr(IsoDateTime)),
-  createdAt: IsoDateTime
-});
-var RuntimeRecordReviewCommand = Schema13.Struct({
-  type: Schema13.Literal("runtime.recordReview"),
-  commandId: CommandId,
-  runId: RunId,
-  taskId: Schema13.optional(Schema13.NullOr(TaskId)),
-  reviewId: ReviewResultId,
-  provider: TrimmedNonEmptyString,
-  mode: Schema13.Literals(["off", "advisory", "required"]),
-  status: Schema13.Literals(["pending", "running", "approved", "rejected", "error"]),
-  summary: Schema13.optional(Schema13.NullOr(Schema13.String)),
-  output: Schema13.Unknown,
-  createdAt: IsoDateTime,
-  completedAt: Schema13.optional(Schema13.NullOr(IsoDateTime))
-});
-var RuntimeRegisterArtifactCommand = Schema13.Struct({
-  type: Schema13.Literal("runtime.registerArtifact"),
-  commandId: CommandId,
-  runId: RunId,
-  taskId: Schema13.optional(Schema13.NullOr(TaskId)),
-  artifactId: ArtifactId,
-  kind: TrimmedNonEmptyString,
-  label: TrimmedNonEmptyString,
-  path: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
-  url: Schema13.optional(Schema13.NullOr(TrimmedNonEmptyString)),
-  metadata: Schema13.optional(Schema13.Record(Schema13.String, Schema13.Unknown)),
-  createdAt: IsoDateTime
-});
-var RemoteRegisterEndpointCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.registerEndpoint"),
-  commandId: CommandId,
-  endpoint: RemoteEndpoint,
-  createdAt: IsoDateTime
-});
-var RemoteRemoveEndpointCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.removeEndpoint"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  createdAt: IsoDateTime
-});
-var RemoteUpdateEndpointCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.updateEndpoint"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  updates: Schema13.Unknown,
-  createdAt: IsoDateTime
-});
-var RemoteConnectCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.connect"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  createdAt: IsoDateTime
-});
-var RemoteDisconnectCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.disconnect"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  createdAt: IsoDateTime
-});
-var RemotePauseCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.pause"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  createdAt: IsoDateTime
-});
-var RemoteResumeCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.resume"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  createdAt: IsoDateTime
-});
-var RemoteStopCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.stop"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  createdAt: IsoDateTime
-});
-var RemoteContinueCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.continue"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  createdAt: IsoDateTime
-});
-var RemoteCreateRunForTaskCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.createRunForTask"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  taskId: TrimmedNonEmptyString,
-  runId: TrimmedNonEmptyString,
-  workspaceId: TrimmedNonEmptyString,
-  runtimeMode: Schema13.optional(Schema13.String),
-  interactionMode: Schema13.optional(Schema13.String),
-  createdAt: IsoDateTime
-});
-var RemoteRefreshTasksCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.refreshTasks"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  createdAt: IsoDateTime
-});
-var RemoteAddIterationsCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.addIterations"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  count: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1)),
-  createdAt: IsoDateTime
-});
-var RemoteRemoveIterationsCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.removeIterations"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  count: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1)),
-  createdAt: IsoDateTime
-});
-var RemoteOrchestrateStartCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.orchestrate.start"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  maxWorkers: Schema13.optional(Schema13.Int),
-  maxIterations: Schema13.optional(Schema13.Int),
-  directMerge: Schema13.optional(Schema13.Boolean),
-  createdAt: IsoDateTime
-});
-var RemoteOrchestratePauseCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.orchestrate.pause"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  orchestrationId: TrimmedNonEmptyString,
-  createdAt: IsoDateTime
-});
-var RemoteOrchestrateResumeCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.orchestrate.resume"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  orchestrationId: TrimmedNonEmptyString,
-  createdAt: IsoDateTime
-});
-var RemoteOrchestrateStopCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.orchestrate.stop"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  orchestrationId: TrimmedNonEmptyString,
-  createdAt: IsoDateTime
-});
-var RemoteGetPromptPreviewCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.getPromptPreview"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  taskId: TrimmedNonEmptyString,
-  createdAt: IsoDateTime
-});
-var RemoteGetIterationOutputCommand = Schema13.Struct({
-  type: Schema13.Literal("remote.getIterationOutput"),
-  commandId: CommandId,
-  endpointId: RemoteEndpointId,
-  taskId: TrimmedNonEmptyString,
-  createdAt: IsoDateTime
-});
-var EngineCommand = Schema13.Union([
-  WorkspaceRegisterCommand,
-  WorkspaceImportRigCommand,
-  WorkspaceHydrateImportedStateCommand,
-  WorkspaceCompileTopologyCommand,
-  WorkspaceSyncRemoteFleetCommand,
-  WorkspaceSyncServiceFabricCommand,
-  WorkspaceRegisterRemoteHostCommand,
-  WorkspaceUpdateRemoteHostStatusCommand,
-  RunClaimRemoteLeaseCommand,
-  RunReleaseRemoteLeaseCommand,
-  RunCreateAdhocCommand,
-  RunCreateForTaskCommand,
-  RunMarkCompletedCommand,
-  RunMarkFailedCommand,
-  RunSetStatusCommand,
-  RunSubmitUserMessageCommand,
-  RunInterruptCommand,
-  RunStopCommand,
-  RunSetRuntimeModeCommand,
-  RunSetInteractionModeCommand,
-  RunRespondApprovalCommand,
-  RunRespondUserInputCommand,
-  RuntimePrepareCommand,
-  RuntimeAttachCommand,
-  RuntimeDetachCommand,
-  RuntimeRecordMessageCommand,
-  RuntimeStartActionCommand,
-  RuntimeCompleteActionCommand,
-  RuntimeRecordLogCommand,
-  RuntimeUpdateMetadataCommand,
-  RuntimeRequestApprovalCommand,
-  RuntimeRequestUserInputCommand,
-  RuntimeRecordValidationCommand,
-  RuntimeRecordReviewCommand,
-  RuntimeRegisterArtifactCommand,
-  GraphUpdateTaskStatusCommand,
-  TaskEnqueueCommand,
-  RemoteRegisterEndpointCommand,
-  RemoteRemoveEndpointCommand,
-  RemoteUpdateEndpointCommand,
-  RemoteConnectCommand,
-  RemoteDisconnectCommand,
-  RemotePauseCommand,
-  RemoteResumeCommand,
-  RemoteStopCommand,
-  RemoteContinueCommand,
-  RemoteCreateRunForTaskCommand,
-  RemoteRefreshTasksCommand,
-  RemoteAddIterationsCommand,
-  RemoteRemoveIterationsCommand,
-  RemoteOrchestrateStartCommand,
-  RemoteOrchestratePauseCommand,
-  RemoteOrchestrateResumeCommand,
-  RemoteOrchestrateStopCommand,
-  RemoteGetPromptPreviewCommand,
-  RemoteGetIterationOutputCommand
-]);
-var EngineDispatchResult = Schema13.Struct({
-  sequence: NonNegativeInt
-});
-var EngineGetSnapshotInput = Schema13.Struct({});
-var EngineReplayEventsInput = Schema13.Struct({
-  fromSequenceExclusive: NonNegativeInt
-});
-var EngineReplayEventsResult = Schema13.Array(EngineEvent);
-var EngineGetTaskArtifactsInput = Schema13.Struct({
-  taskId: TaskId
-});
-var EngineGetTaskArtifactsResult = Schema13.Array(ArtifactSummary);
-var EngineRuntimeDefaults = Schema13.Struct({
-  runtimeAdapter: RuntimeAdapterKind,
-  runMode: RunMode,
-  sandboxMode: EngineSandboxMode,
-  isolationMode: IsolationMode
-});
-
-// packages/contracts/src/rig.ts
-import { Schema as Schema14 } 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",
-  queueRunSteering: "rig.queueRunSteering",
-  interruptRun: "rig.interruptRun",
-  stopRun: "rig.stopRun",
-  resolveApproval: "rig.resolveApproval",
-  resolveUserInput: "rig.resolveUserInput",
-  getTaskArtifacts: "rig.getTaskArtifacts",
-  ackRunSteering: "rig.ackRunSteering"
-};
-var RigSnapshotInvalidatedPayload = Schema14.Struct({
-  sequence: NonNegativeInt,
-  updatedAt: IsoDateTime,
-  reason: Schema14.optional(TrimmedNonEmptyString)
-});
-var RigGetSnapshotInput = Schema14.Struct({});
-var RigReplayEventsInput = Schema14.Struct({
-  fromSequenceExclusive: NonNegativeInt
-});
-var RigReplayEventsResult = Schema14.Array(EngineEvent);
-var RigListWorkspacesInput = Schema14.Struct({});
-var RigListWorkspacesResult = Schema14.Array(WorkspaceSummary);
-var RigGetWorkspaceInput = Schema14.Struct({
-  workspaceId: WorkspaceId
-});
-var RigGetWorkspaceResult = Schema14.Struct({
-  workspace: Schema14.NullOr(WorkspaceSummary),
-  tasks: Schema14.Array(TaskSummary),
-  runs: Schema14.Array(RunSummary),
-  approvals: Schema14.Array(ApprovalSummary),
-  userInputs: Schema14.Array(UserInputRequestSummary),
-  artifacts: Schema14.Array(ArtifactSummary),
-  updatedAt: IsoDateTime
-});
-var RigRawRunLogEntry = Schema14.Record(Schema14.String, Schema14.Unknown);
-var RigGetRunLogsInput = Schema14.Struct({
-  runId: RunId,
-  limit: Schema14.optional(PositiveInt.check(Schema14.isLessThanOrEqualTo(500))),
-  cursor: Schema14.optional(Schema14.String)
-});
-var RigGetRunLogsResult = Schema14.Struct({
-  entries: Schema14.Array(RigRawRunLogEntry),
-  nextCursor: Schema14.NullOr(Schema14.String),
-  hasMore: Schema14.Boolean
-});
-var RigRunLogAppendedPayload = Schema14.Struct({
-  runId: RunId,
-  entry: RigRawRunLogEntry
-});
-var RigQueuedRunSteeringMessage = Schema14.Struct({
-  id: TrimmedNonEmptyString,
-  runId: RunId,
-  message: TrimmedNonEmptyString,
-  actor: TrimmedNonEmptyString,
-  createdAt: IsoDateTime,
-  delivered: Schema14.Boolean
-});
-var RigRunSteeringQueuedPayload = Schema14.Struct({
-  runId: RunId,
-  message: RigQueuedRunSteeringMessage
-});
-var RigAckRunSteeringInput = Schema14.Struct({
-  runId: RunId,
-  ids: Schema14.Array(TrimmedNonEmptyString)
-});
-var RigAckRunSteeringResult = Schema14.Struct({
-  runId: RunId,
-  delivered: Schema14.Array(TrimmedNonEmptyString)
-});
-var RigCreateAdhocRunInput = Schema14.Struct({
-  commandId: CommandId,
-  runId: RunId,
-  workspaceId: WorkspaceId,
-  title: Schema14.String,
-  runtimeAdapter: Schema14.optional(RuntimeAdapterKind),
-  model: Schema14.optional(Schema14.String),
-  runtimeMode: RuntimeMode.pipe(Schema14.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
-  interactionMode: ProviderInteractionMode.pipe(Schema14.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  executionTarget: Schema14.optional(RunExecutionTarget),
-  remoteHostId: Schema14.optional(Schema14.String),
-  initialPrompt: Schema14.optional(Schema14.String),
-  baselineMode: Schema14.optional(Schema14.Literals(["head", "dirty-snapshot"])),
-  prMode: Schema14.optional(Schema14.Literals(["auto", "ask", "off"])),
-  initiatedBy: Schema14.optional(Schema14.String),
-  createdAt: IsoDateTime
-});
-var RigCreateTaskRunInput = Schema14.Struct({
-  commandId: CommandId,
-  runId: RunId,
-  workspaceId: WorkspaceId,
-  taskId: TaskId,
-  runtimeAdapter: Schema14.optional(RuntimeAdapterKind),
-  model: Schema14.optional(Schema14.String),
-  runtimeMode: RuntimeMode.pipe(Schema14.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
-  interactionMode: ProviderInteractionMode.pipe(Schema14.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  executionTarget: Schema14.optional(RunExecutionTarget),
-  remoteHostId: Schema14.optional(Schema14.String),
-  initialPrompt: Schema14.optional(Schema14.String),
-  baselineMode: Schema14.optional(Schema14.Literals(["head", "dirty-snapshot"])),
-  prMode: Schema14.optional(Schema14.Literals(["auto", "ask", "off"])),
-  initiatedBy: Schema14.optional(Schema14.String),
-  createdAt: IsoDateTime
-});
-var RigEnqueueTaskInput = Schema14.Struct({
-  commandId: CommandId,
-  taskId: TaskId,
-  score: Schema14.optional(Schema14.Number),
-  createdAt: IsoDateTime
-});
-var RigDeleteRunInput = Schema14.Struct({
-  commandId: CommandId,
-  runId: RunId,
-  purgeTaskArtifacts: Schema14.optional(Schema14.Boolean),
-  createdAt: IsoDateTime
-});
-var RigResumeRunInput = Schema14.Struct({
-  commandId: CommandId,
-  runId: RunId,
-  promptOverride: Schema14.optional(Schema14.String),
-  createdAt: IsoDateTime
-});
-var RigSubmitRunMessageInput = Schema14.Struct({
-  commandId: CommandId,
-  runId: RunId,
-  messageId: MessageId,
-  text: Schema14.String,
-  attachments: Schema14.optional(Schema14.Array(Schema14.Unknown)),
-  createdAt: IsoDateTime
-});
-var RigQueueRunSteeringInput = Schema14.Struct({
-  commandId: CommandId,
-  runId: RunId,
-  message: TrimmedNonEmptyString,
-  actor: Schema14.optional(Schema14.String),
-  createdAt: IsoDateTime
-});
-var RigQueueRunSteeringResult = Schema14.Struct({
-  sequence: NonNegativeInt,
-  runId: RunId,
-  queued: Schema14.Boolean,
-  message: RigQueuedRunSteeringMessage
-});
-var RigInterruptRunInput = Schema14.Struct({
-  commandId: CommandId,
-  runId: RunId,
-  createdAt: IsoDateTime
-});
-var RigStopRunInput = Schema14.Struct({
-  commandId: CommandId,
-  runId: RunId,
-  createdAt: IsoDateTime
-});
-var RigResolveApprovalInput = Schema14.Struct({
-  commandId: CommandId,
-  runId: RunId,
-  requestId: ApprovalRequestId,
-  decision: ProviderApprovalDecision,
-  createdAt: IsoDateTime
-});
-var RigResolveUserInputInput = Schema14.Struct({
-  commandId: CommandId,
-  runId: RunId,
-  requestId: ApprovalRequestId,
-  answers: ProviderUserInputAnswers,
-  createdAt: IsoDateTime
-});
-var RigGetTaskArtifactsInput = Schema14.Struct({
-  taskId: TaskId
-});
-var RigGetTaskArtifactsResult = Schema14.Array(ArtifactSummary);
-var RigMutationResult = Schema14.Struct({
-  sequence: NonNegativeInt
-});
-
-// packages/contracts/src/git.ts
-import { Schema as Schema15 } from "effect";
-var TrimmedNonEmptyStringSchema = TrimmedNonEmptyString;
-var GitStackedAction = Schema15.Literals(["commit", "commit_push", "commit_push_pr"]);
-var GitCommitStepStatus = Schema15.Literals(["created", "skipped_no_changes"]);
-var GitPushStepStatus = Schema15.Literals([
-  "pushed",
-  "skipped_not_requested",
-  "skipped_up_to_date"
-]);
-var GitBranchStepStatus = Schema15.Literals(["created", "skipped_not_requested"]);
-var GitPrStepStatus = Schema15.Literals([
-  "created",
-  "opened_existing",
-  "skipped_not_requested"
-]);
-var GitStatusPrState = Schema15.Literals(["open", "closed", "merged"]);
-var GitBranch = Schema15.Struct({
-  name: TrimmedNonEmptyStringSchema,
-  isRemote: Schema15.optional(Schema15.Boolean),
-  remoteName: Schema15.optional(TrimmedNonEmptyStringSchema),
-  current: Schema15.Boolean,
-  isDefault: Schema15.Boolean,
-  worktreePath: TrimmedNonEmptyStringSchema.pipe(Schema15.NullOr)
-});
-var GitWorktree = Schema15.Struct({
-  path: TrimmedNonEmptyStringSchema,
-  branch: TrimmedNonEmptyStringSchema
-});
-var GitStatusInput = Schema15.Struct({
-  cwd: TrimmedNonEmptyStringSchema
-});
-var GitPullInput = Schema15.Struct({
-  cwd: TrimmedNonEmptyStringSchema
-});
-var GitReadWorkingTreePatchInput = Schema15.Struct({
-  cwd: TrimmedNonEmptyStringSchema,
-  relativePath: Schema15.optional(TrimmedNonEmptyStringSchema)
-});
-var GitRunStackedActionInput = Schema15.Struct({
-  cwd: TrimmedNonEmptyStringSchema,
-  action: GitStackedAction,
-  commitMessage: Schema15.optional(TrimmedNonEmptyStringSchema.check(Schema15.isMaxLength(1e4))),
-  featureBranch: Schema15.optional(Schema15.Boolean)
-});
-var GitListBranchesInput = Schema15.Struct({
-  cwd: TrimmedNonEmptyStringSchema
-});
-var GitCreateWorktreeInput = Schema15.Struct({
-  cwd: TrimmedNonEmptyStringSchema,
-  branch: TrimmedNonEmptyStringSchema,
-  newBranch: TrimmedNonEmptyStringSchema,
-  path: Schema15.NullOr(TrimmedNonEmptyStringSchema)
-});
-var GitRemoveWorktreeInput = Schema15.Struct({
-  cwd: TrimmedNonEmptyStringSchema,
-  path: TrimmedNonEmptyStringSchema,
-  force: Schema15.optional(Schema15.Boolean)
-});
-var GitCreateBranchInput = Schema15.Struct({
-  cwd: TrimmedNonEmptyStringSchema,
-  branch: TrimmedNonEmptyStringSchema
-});
-var GitCheckoutInput = Schema15.Struct({
-  cwd: TrimmedNonEmptyStringSchema,
-  branch: TrimmedNonEmptyStringSchema
-});
-var GitInitInput = Schema15.Struct({
-  cwd: TrimmedNonEmptyStringSchema
-});
-var GitStatusPr = Schema15.Struct({
-  number: PositiveInt,
-  title: TrimmedNonEmptyStringSchema,
-  url: Schema15.String,
-  baseBranch: TrimmedNonEmptyStringSchema,
-  headBranch: TrimmedNonEmptyStringSchema,
-  state: GitStatusPrState
-});
-var GitStatusResult = Schema15.Struct({
-  branch: TrimmedNonEmptyStringSchema.pipe(Schema15.NullOr),
-  hasWorkingTreeChanges: Schema15.Boolean,
-  workingTree: Schema15.Struct({
-    files: Schema15.Array(Schema15.Struct({
-      path: TrimmedNonEmptyStringSchema,
-      insertions: NonNegativeInt,
-      deletions: NonNegativeInt
-    })),
-    insertions: NonNegativeInt,
-    deletions: NonNegativeInt
-  }),
-  hasUpstream: Schema15.Boolean,
-  aheadCount: NonNegativeInt,
-  behindCount: NonNegativeInt,
-  pr: Schema15.NullOr(GitStatusPr)
-});
-var GitListBranchesResult = Schema15.Struct({
-  branches: Schema15.Array(GitBranch),
-  isRepo: Schema15.Boolean
-});
-var GitCreateWorktreeResult = Schema15.Struct({
-  worktree: GitWorktree
-});
-var GitRunStackedActionResult = Schema15.Struct({
-  action: GitStackedAction,
-  branch: Schema15.Struct({
-    status: GitBranchStepStatus,
-    name: Schema15.optional(TrimmedNonEmptyStringSchema)
-  }),
-  commit: Schema15.Struct({
-    status: GitCommitStepStatus,
-    commitSha: Schema15.optional(TrimmedNonEmptyStringSchema),
-    subject: Schema15.optional(TrimmedNonEmptyStringSchema)
-  }),
-  push: Schema15.Struct({
-    status: GitPushStepStatus,
-    branch: Schema15.optional(TrimmedNonEmptyStringSchema),
-    upstreamBranch: Schema15.optional(TrimmedNonEmptyStringSchema),
-    setUpstream: Schema15.optional(Schema15.Boolean)
-  }),
-  pr: Schema15.Struct({
-    status: GitPrStepStatus,
-    url: Schema15.optional(Schema15.String),
-    number: Schema15.optional(PositiveInt),
-    baseBranch: Schema15.optional(TrimmedNonEmptyStringSchema),
-    headBranch: Schema15.optional(TrimmedNonEmptyStringSchema),
-    title: Schema15.optional(TrimmedNonEmptyStringSchema)
-  })
-});
-var GitPullResult = Schema15.Struct({
-  status: Schema15.Literals(["pulled", "skipped_up_to_date"]),
-  branch: TrimmedNonEmptyStringSchema,
-  upstreamBranch: TrimmedNonEmptyStringSchema.pipe(Schema15.NullOr)
-});
-var GitReadWorkingTreePatchResult = Schema15.Struct({
-  diff: Schema15.String
-});
-
-// packages/contracts/src/terminal.ts
-import { Schema as Schema16 } from "effect";
-var DEFAULT_TERMINAL_ID = "default";
-var TrimmedNonEmptyStringSchema2 = TrimmedNonEmptyString;
-var TerminalColsSchema = Schema16.Int.check(Schema16.isGreaterThanOrEqualTo(20)).check(Schema16.isLessThanOrEqualTo(400));
-var TerminalRowsSchema = Schema16.Int.check(Schema16.isGreaterThanOrEqualTo(5)).check(Schema16.isLessThanOrEqualTo(200));
-var TerminalIdSchema = TrimmedNonEmptyStringSchema2.check(Schema16.isMaxLength(128));
-var TerminalEnvKeySchema = Schema16.String.check(Schema16.isPattern(/^[A-Za-z_][A-Za-z0-9_]*$/)).check(Schema16.isMaxLength(128));
-var TerminalEnvValueSchema = Schema16.String.check(Schema16.isMaxLength(8192));
-var TerminalEnvSchema = Schema16.Record(TerminalEnvKeySchema, TerminalEnvValueSchema).check(Schema16.isMaxProperties(128));
-var TerminalIdWithDefaultSchema = TerminalIdSchema.pipe(Schema16.withDecodingDefault(() => DEFAULT_TERMINAL_ID));
-var TerminalThreadInput = Schema16.Struct({
-  threadId: TrimmedNonEmptyStringSchema2
-});
-var TerminalSessionInput = Schema16.Struct({
-  ...TerminalThreadInput.fields,
-  terminalId: TerminalIdWithDefaultSchema
-});
-var TerminalOpenInput = Schema16.Struct({
-  ...TerminalSessionInput.fields,
-  cwd: TrimmedNonEmptyStringSchema2,
-  cols: Schema16.optional(TerminalColsSchema),
-  rows: Schema16.optional(TerminalRowsSchema),
-  env: Schema16.optional(TerminalEnvSchema)
-});
-var TerminalWriteInput = Schema16.Struct({
-  ...TerminalSessionInput.fields,
-  data: Schema16.String.check(Schema16.isNonEmpty()).check(Schema16.isMaxLength(65536))
-});
-var TerminalResizeInput = Schema16.Struct({
-  ...TerminalSessionInput.fields,
-  cols: TerminalColsSchema,
-  rows: TerminalRowsSchema
-});
-var TerminalClearInput = TerminalSessionInput;
-var TerminalRestartInput = Schema16.Struct({
-  ...TerminalThreadInput.fields,
-  cwd: TrimmedNonEmptyStringSchema2,
-  cols: TerminalColsSchema,
-  rows: TerminalRowsSchema,
-  env: Schema16.optional(TerminalEnvSchema)
-});
-var TerminalCloseInput = Schema16.Struct({
-  ...TerminalThreadInput.fields,
-  terminalId: Schema16.optional(TerminalIdSchema),
-  deleteHistory: Schema16.optional(Schema16.Boolean)
-});
-var TerminalSessionStatus = Schema16.Literals(["starting", "running", "exited", "error"]);
-var TerminalSessionSnapshot = Schema16.Struct({
-  threadId: Schema16.String.check(Schema16.isNonEmpty()),
-  terminalId: Schema16.String.check(Schema16.isNonEmpty()),
-  cwd: Schema16.String.check(Schema16.isNonEmpty()),
-  status: TerminalSessionStatus,
-  pid: Schema16.NullOr(Schema16.Int.check(Schema16.isGreaterThan(0))),
-  history: Schema16.String,
-  exitCode: Schema16.NullOr(Schema16.Int),
-  exitSignal: Schema16.NullOr(Schema16.String),
-  updatedAt: Schema16.String
-});
-var TerminalEventBaseSchema = Schema16.Struct({
-  threadId: Schema16.String.check(Schema16.isNonEmpty()),
-  terminalId: Schema16.String.check(Schema16.isNonEmpty()),
-  createdAt: Schema16.String
-});
-var TerminalStartedEvent = Schema16.Struct({
-  ...TerminalEventBaseSchema.fields,
-  type: Schema16.Literal("started"),
-  snapshot: TerminalSessionSnapshot
-});
-var TerminalOutputEvent = Schema16.Struct({
-  ...TerminalEventBaseSchema.fields,
-  type: Schema16.Literal("output"),
-  data: Schema16.String
-});
-var TerminalExitedEvent = Schema16.Struct({
-  ...TerminalEventBaseSchema.fields,
-  type: Schema16.Literal("exited"),
-  exitCode: Schema16.NullOr(Schema16.Int),
-  exitSignal: Schema16.NullOr(Schema16.String)
-});
-var TerminalErrorEvent = Schema16.Struct({
-  ...TerminalEventBaseSchema.fields,
-  type: Schema16.Literal("error"),
-  message: Schema16.String.check(Schema16.isNonEmpty())
-});
-var TerminalClearedEvent = Schema16.Struct({
-  ...TerminalEventBaseSchema.fields,
-  type: Schema16.Literal("cleared")
-});
-var TerminalRestartedEvent = Schema16.Struct({
-  ...TerminalEventBaseSchema.fields,
-  type: Schema16.Literal("restarted"),
-  snapshot: TerminalSessionSnapshot
-});
-var TerminalActivityEvent = Schema16.Struct({
-  ...TerminalEventBaseSchema.fields,
-  type: Schema16.Literal("activity"),
-  hasRunningSubprocess: Schema16.Boolean
-});
-var TerminalEvent = Schema16.Union([
-  TerminalStartedEvent,
-  TerminalOutputEvent,
-  TerminalExitedEvent,
-  TerminalErrorEvent,
-  TerminalClearedEvent,
-  TerminalRestartedEvent,
-  TerminalActivityEvent
-]);
-
-// packages/contracts/src/keybindings.ts
-import { Schema as Schema17 } from "effect";
-var MAX_KEYBINDING_VALUE_LENGTH = 64;
-var MAX_KEYBINDING_WHEN_LENGTH = 256;
-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 = Schema17.TemplateLiteral([
-  Schema17.Literal("script."),
-  Schema17.NonEmptyString.check(Schema17.isMaxLength(MAX_SCRIPT_ID_LENGTH), Schema17.isPattern(/^[a-z0-9][a-z0-9-]*$/)),
-  Schema17.Literal(".run")
-]);
-var KeybindingCommand = Schema17.Union([
-  Schema17.Literals(STATIC_KEYBINDING_COMMANDS),
-  SCRIPT_RUN_COMMAND_PATTERN
-]);
-var KeybindingValue = TrimmedString.check(Schema17.isMinLength(1), Schema17.isMaxLength(MAX_KEYBINDING_VALUE_LENGTH));
-var KeybindingWhen = TrimmedString.check(Schema17.isMinLength(1), Schema17.isMaxLength(MAX_KEYBINDING_WHEN_LENGTH));
-var KeybindingRule = Schema17.Struct({
-  key: KeybindingValue,
-  command: KeybindingCommand,
-  when: Schema17.optional(KeybindingWhen)
-});
-var KeybindingsConfig = Schema17.Array(KeybindingRule).check(Schema17.isMaxLength(MAX_KEYBINDINGS_COUNT));
-var KeybindingShortcut = Schema17.Struct({
-  key: KeybindingValue,
-  metaKey: Schema17.Boolean,
-  ctrlKey: Schema17.Boolean,
-  shiftKey: Schema17.Boolean,
-  altKey: Schema17.Boolean,
-  modKey: Schema17.Boolean
-});
-var KeybindingWhenNode = Schema17.Union([
-  Schema17.Struct({
-    type: Schema17.Literal("identifier"),
-    name: Schema17.NonEmptyString
-  }),
-  Schema17.Struct({
-    type: Schema17.Literal("not"),
-    node: Schema17.suspend(() => KeybindingWhenNode)
-  }),
-  Schema17.Struct({
-    type: Schema17.Literal("and"),
-    left: Schema17.suspend(() => KeybindingWhenNode),
-    right: Schema17.suspend(() => KeybindingWhenNode)
-  }),
-  Schema17.Struct({
-    type: Schema17.Literal("or"),
-    left: Schema17.suspend(() => KeybindingWhenNode),
-    right: Schema17.suspend(() => KeybindingWhenNode)
-  })
-]);
-var ResolvedKeybindingRule = Schema17.Struct({
-  command: KeybindingCommand,
-  shortcut: KeybindingShortcut,
-  whenAst: Schema17.optional(KeybindingWhenNode)
-}).annotate({ parseOptions: { onExcessProperty: "ignore" } });
-var ResolvedKeybindingsConfig = Schema17.Array(ResolvedKeybindingRule).check(Schema17.isMaxLength(MAX_KEYBINDINGS_COUNT));
-
-// packages/contracts/src/project.ts
-import { Schema as Schema18 } 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 = Schema18.Struct({
-  cwd: TrimmedNonEmptyString,
-  query: TrimmedNonEmptyString.check(Schema18.isMaxLength(256)),
-  limit: PositiveInt.check(Schema18.isLessThanOrEqualTo(PROJECT_SEARCH_ENTRIES_MAX_LIMIT))
-});
-var ProjectEntryKind = Schema18.Literals(["file", "directory"]);
-var ProjectEntry = Schema18.Struct({
-  path: TrimmedNonEmptyString,
-  kind: ProjectEntryKind,
-  parentPath: Schema18.optional(TrimmedNonEmptyString)
-});
-var ProjectSearchEntriesResult = Schema18.Struct({
-  entries: Schema18.Array(ProjectEntry),
-  truncated: Schema18.Boolean
-});
-var ProjectListDirectoryInput = Schema18.Struct({
-  cwd: TrimmedNonEmptyString,
-  relativePath: TrimmedNonEmptyString.check(Schema18.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH)),
-  limit: PositiveInt.check(Schema18.isLessThanOrEqualTo(PROJECT_LIST_DIRECTORY_MAX_LIMIT))
-});
-var ProjectDirectoryEntry = Schema18.Struct({
-  name: TrimmedNonEmptyString,
-  relativePath: TrimmedNonEmptyString,
-  kind: ProjectEntryKind,
-  sizeBytes: Schema18.optional(NonNegativeInt),
-  modifiedAt: Schema18.optional(Schema18.String)
-});
-var ProjectListDirectoryResult = Schema18.Struct({
-  entries: Schema18.Array(ProjectDirectoryEntry),
-  truncated: Schema18.Boolean
-});
-var ProjectWriteFileInput = Schema18.Struct({
-  cwd: TrimmedNonEmptyString,
-  relativePath: TrimmedNonEmptyString.check(Schema18.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH)),
-  contents: Schema18.String
-});
-var ProjectWriteFileResult = Schema18.Struct({
-  relativePath: TrimmedNonEmptyString
-});
-var ProjectReadFileInput = Schema18.Struct({
-  cwd: TrimmedNonEmptyString,
-  relativePath: TrimmedNonEmptyString.check(Schema18.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH))
-});
-var ProjectReadFileResult = Schema18.Struct({
-  relativePath: TrimmedNonEmptyString,
-  contents: Schema18.String,
-  truncated: Schema18.Boolean,
-  sizeBytes: NonNegativeInt,
-  maxBytes: PositiveInt
-});
-
-// packages/contracts/src/editor.ts
-import { Schema as Schema19 } 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 = Schema19.Literals(EDITORS.map((e) => e.id));
-var OpenInEditorInput = Schema19.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: Schema20.tag(tag) }), { unsafePreserveChecks: true });
-var WebSocketRequestBody = Schema20.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.queueRunSteering, RigQueueRunSteeringInput),
-  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(RIG_WS_METHODS.ackRunSteering, RigAckRunSteeringInput),
-  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, Schema20.Struct({})),
-  tagRequestBody(WS_METHODS.serverUpsertKeybinding, KeybindingRule),
-  tagRequestBody(WS_METHODS.remoteListEndpoints, Schema20.Struct({})),
-  tagRequestBody(WS_METHODS.remoteRegisterEndpoint, Schema20.Struct({
-    alias: TrimmedNonEmptyString,
-    host: TrimmedNonEmptyString,
-    port: Schema20.Int,
-    token: Schema20.optional(TrimmedNonEmptyString),
-    autoConnect: Schema20.optional(Schema20.Boolean)
-  })),
-  tagRequestBody(WS_METHODS.remoteRemoveEndpoint, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString
-  })),
-  tagRequestBody(WS_METHODS.remoteUpdateEndpoint, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString,
-    alias: Schema20.optional(TrimmedNonEmptyString),
-    host: Schema20.optional(TrimmedNonEmptyString),
-    port: Schema20.optional(Schema20.Int),
-    token: Schema20.optional(TrimmedNonEmptyString),
-    autoConnect: Schema20.optional(Schema20.Boolean)
-  })),
-  tagRequestBody(WS_METHODS.remoteTestEndpoint, Schema20.Struct({
-    host: TrimmedNonEmptyString,
-    port: Schema20.Int,
-    token: Schema20.optional(TrimmedNonEmptyString)
-  })),
-  tagRequestBody(WS_METHODS.remoteConnect, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString
-  })),
-  tagRequestBody(WS_METHODS.remoteDisconnect, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString
-  })),
-  tagRequestBody(WS_METHODS.remotePause, Schema20.Struct({ endpointId: TrimmedNonEmptyString })),
-  tagRequestBody(WS_METHODS.remoteResume, Schema20.Struct({ endpointId: TrimmedNonEmptyString })),
-  tagRequestBody(WS_METHODS.remoteStop, Schema20.Struct({ endpointId: TrimmedNonEmptyString })),
-  tagRequestBody(WS_METHODS.remoteContinue, Schema20.Struct({ endpointId: TrimmedNonEmptyString })),
-  tagRequestBody(WS_METHODS.remoteCreateRunForTask, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString,
-    taskId: TrimmedNonEmptyString,
-    runId: TrimmedNonEmptyString,
-    workspaceId: TrimmedNonEmptyString,
-    runtimeMode: Schema20.optional(Schema20.String),
-    interactionMode: Schema20.optional(Schema20.String)
-  })),
-  tagRequestBody(WS_METHODS.remoteRefreshTasks, Schema20.Struct({ endpointId: TrimmedNonEmptyString })),
-  tagRequestBody(WS_METHODS.remoteAddIterations, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString,
-    count: Schema20.Int
-  })),
-  tagRequestBody(WS_METHODS.remoteRemoveIterations, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString,
-    count: Schema20.Int
-  })),
-  tagRequestBody(WS_METHODS.remoteOrchestrateStart, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString,
-    maxWorkers: Schema20.optional(Schema20.Int),
-    maxIterations: Schema20.optional(Schema20.Int),
-    directMerge: Schema20.optional(Schema20.Boolean)
-  })),
-  tagRequestBody(WS_METHODS.remoteOrchestratePause, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString,
-    orchestrationId: TrimmedNonEmptyString
-  })),
-  tagRequestBody(WS_METHODS.remoteOrchestrateResume, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString,
-    orchestrationId: TrimmedNonEmptyString
-  })),
-  tagRequestBody(WS_METHODS.remoteOrchestrateStop, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString,
-    orchestrationId: TrimmedNonEmptyString
-  })),
-  tagRequestBody(WS_METHODS.remoteOrchestrateState, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString,
-    orchestrationId: TrimmedNonEmptyString
-  })),
-  tagRequestBody(WS_METHODS.remotePromptPreview, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString,
-    taskId: TrimmedNonEmptyString
-  })),
-  tagRequestBody(WS_METHODS.remoteIterationOutput, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString,
-    taskId: TrimmedNonEmptyString
-  })),
-  tagRequestBody(WS_METHODS.remoteTerminalOpen, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString,
-    threadId: Schema20.String,
-    terminalId: Schema20.String,
-    cwd: Schema20.optional(Schema20.String),
-    env: Schema20.optional(Schema20.Unknown)
-  })),
-  tagRequestBody(WS_METHODS.remoteTerminalWrite, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString,
-    threadId: Schema20.String,
-    terminalId: Schema20.String,
-    data: Schema20.String
-  })),
-  tagRequestBody(WS_METHODS.remoteTerminalResize, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString,
-    threadId: Schema20.String,
-    terminalId: Schema20.String,
-    cols: Schema20.Number,
-    rows: Schema20.Number
-  })),
-  tagRequestBody(WS_METHODS.remoteTerminalClose, Schema20.Struct({
-    endpointId: TrimmedNonEmptyString,
-    threadId: Schema20.String,
-    terminalId: Schema20.String
-  }))
-]);
-var WebSocketRequest = Schema20.Struct({
-  id: TrimmedNonEmptyString,
-  body: WebSocketRequestBody
-});
-var WebSocketResponse = Schema20.Struct({
-  id: TrimmedNonEmptyString,
-  result: Schema20.optional(Schema20.Unknown),
-  error: Schema20.optional(Schema20.Struct({
-    message: Schema20.String
-  }))
-});
-var WsPush = Schema20.Struct({
-  type: Schema20.Literal("push"),
-  channel: TrimmedNonEmptyString,
-  data: Schema20.Unknown
-});
-var EngineGetSnapshotResult = EngineReadModel;
-var EngineReplayEventsWsResult = EngineReplayEventsResult;
-var WsResponse = Schema20.Union([WebSocketResponse, WsPush]);
-var WsWelcomePayload = Schema20.Struct({
-  cwd: TrimmedNonEmptyString,
-  projectName: TrimmedNonEmptyString,
-  bootstrapProjectId: Schema20.optional(ProjectId),
-  bootstrapThreadId: Schema20.optional(ThreadId)
-});
-export {
-  WsWelcomePayload,
-  WsResponse,
-  WsPush,
-  WebSocketResponse,
-  WebSocketRequest,
-  WS_METHODS,
-  WS_CHANNELS,
-  EngineReplayEventsWsResult,
-  EngineGetSnapshotResult
-};