@h-rig/contracts 0.0.6-alpha.18 → 0.0.6-alpha.181

package/dist/src/remote.js

@@ -1,6 +1,6 @@
 // @bun
 // packages/contracts/src/remote.ts
-import { Schema as Schema7 } from "effect";
+import { Schema as Schema6 } from "effect";
 
 // packages/contracts/src/baseSchemas.ts
 import { Schema } from "effect";
@@ -16,6 +16,9 @@ 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");
@@ -87,905 +90,69 @@ var EngineRunLog = Schema2.Struct({
 });
 
 // packages/contracts/src/orchestration.ts
-import { Option, Schema as Schema4, SchemaIssue, Struct } from "effect";
-
-// packages/contracts/src/model.ts
 import { Schema as Schema3 } from "effect";
-var CODEX_REASONING_EFFORT_OPTIONS = ["xhigh", "high", "medium", "low"];
-var CodexModelOptions = Schema3.Struct({
-  reasoningEffort: Schema3.optional(Schema3.Literals(CODEX_REASONING_EFFORT_OPTIONS)),
-  fastMode: Schema3.optional(Schema3.Boolean)
-});
-var ClaudeModelOptions = Schema3.Struct({});
-var ProviderModelOptions = Schema3.Struct({
-  codex: Schema3.optional(CodexModelOptions),
-  claude: Schema3.optional(ClaudeModelOptions)
-});
-
-// packages/contracts/src/orchestration.ts
-var ProviderKind = Schema4.Literals(["codex", "claude"]);
-var ProviderApprovalPolicy = Schema4.Literals([
+var ProviderKind = Schema3.Literals(["codex", "claude"]);
+var ProviderApprovalPolicy = Schema3.Literals([
   "untrusted",
   "on-failure",
   "on-request",
   "never"
 ]);
-var ProviderSandboxMode = Schema4.Literals([
+var ProviderSandboxMode = Schema3.Literals([
   "read-only",
   "workspace-write",
   "danger-full-access"
 ]);
-var ProviderServiceTier = Schema4.Literals(["fast", "flex"]);
-var RuntimeMode = Schema4.Literals(["approval-required", "full-access"]);
-var DEFAULT_RUNTIME_MODE = "full-access";
-var ProviderInteractionMode = Schema4.Literals(["default", "plan"]);
-var DEFAULT_PROVIDER_INTERACTION_MODE = "default";
-var ProviderRequestKind = Schema4.Literals(["command", "file-read", "file-change"]);
-var AssistantDeliveryMode = Schema4.Literals(["buffered", "streaming"]);
-var ProviderApprovalDecision = Schema4.Literals([
+var ProviderServiceTier = Schema3.Literals(["fast", "flex"]);
+var RuntimeMode = Schema3.Literals(["approval-required", "full-access"]);
+var ProviderInteractionMode = Schema3.Literals(["default", "plan"]);
+var ProviderRequestKind = Schema3.Literals(["command", "file-read", "file-change"]);
+var ProviderApprovalDecision = Schema3.Literals([
   "accept",
   "acceptForSession",
   "decline",
   "cancel"
 ]);
-var ProviderUserInputAnswers = Schema4.Record(Schema4.String, Schema4.Unknown);
+var ProviderUserInputAnswers = Schema3.Record(Schema3.String, Schema3.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(Schema4.isMaxLength(CHAT_ATTACHMENT_ID_MAX_CHARS), Schema4.isPattern(/^[a-z0-9_-]+$/i));
-var ChatImageAttachment = Schema4.Struct({
-  type: Schema4.Literal("image"),
+var ChatAttachmentId = TrimmedNonEmptyString.check(Schema3.isMaxLength(CHAT_ATTACHMENT_ID_MAX_CHARS), Schema3.isPattern(/^[a-z0-9_-]+$/i));
+var ChatImageAttachment = Schema3.Struct({
+  type: Schema3.Literal("image"),
   id: ChatAttachmentId,
-  name: TrimmedNonEmptyString.check(Schema4.isMaxLength(255)),
-  mimeType: TrimmedNonEmptyString.check(Schema4.isMaxLength(100), Schema4.isPattern(/^image\//i)),
-  sizeBytes: NonNegativeInt.check(Schema4.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES))
-});
-var UploadChatImageAttachment = Schema4.Struct({
-  type: Schema4.Literal("image"),
-  name: TrimmedNonEmptyString.check(Schema4.isMaxLength(255)),
-  mimeType: TrimmedNonEmptyString.check(Schema4.isMaxLength(100), Schema4.isPattern(/^image\//i)),
-  sizeBytes: NonNegativeInt.check(Schema4.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES)),
-  dataUrl: TrimmedNonEmptyString.check(Schema4.isMaxLength(PROVIDER_SEND_TURN_MAX_IMAGE_DATA_URL_CHARS))
-});
-var ChatAttachment = Schema4.Union([ChatImageAttachment]);
-var UploadChatAttachment = Schema4.Union([UploadChatImageAttachment]);
-var ProjectScriptIcon = Schema4.Literals([
-  "play",
-  "test",
-  "lint",
-  "configure",
-  "build",
-  "debug"
-]);
-var ProjectScript = Schema4.Struct({
-  id: TrimmedNonEmptyString,
-  name: TrimmedNonEmptyString,
-  command: TrimmedNonEmptyString,
-  icon: ProjectScriptIcon,
-  runOnWorktreeCreate: Schema4.Boolean
-});
-var OrchestrationProject = Schema4.Struct({
-  id: ProjectId,
-  title: TrimmedNonEmptyString,
-  workspaceRoot: TrimmedNonEmptyString,
-  defaultModel: Schema4.NullOr(TrimmedNonEmptyString),
-  scripts: Schema4.Array(ProjectScript),
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime,
-  deletedAt: Schema4.NullOr(IsoDateTime)
-});
-var OrchestrationMessageRole = Schema4.Literals(["user", "assistant", "system"]);
-var OrchestrationMessage = Schema4.Struct({
-  id: MessageId,
-  role: OrchestrationMessageRole,
-  text: Schema4.String,
-  attachments: Schema4.optional(Schema4.Array(ChatAttachment)),
-  turnId: Schema4.NullOr(TurnId),
-  streaming: Schema4.Boolean,
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime
-});
-var OrchestrationProposedPlanId = TrimmedNonEmptyString;
-var OrchestrationProposedPlan = Schema4.Struct({
-  id: OrchestrationProposedPlanId,
-  turnId: Schema4.NullOr(TurnId),
-  planMarkdown: TrimmedNonEmptyString,
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime
-});
-var OrchestrationSessionStatus = Schema4.Literals([
-  "idle",
-  "starting",
-  "running",
-  "ready",
-  "interrupted",
-  "stopped",
-  "error"
-]);
-var OrchestrationSession = Schema4.Struct({
-  threadId: ThreadId,
-  status: OrchestrationSessionStatus,
-  providerName: Schema4.NullOr(TrimmedNonEmptyString),
-  runtimeMode: RuntimeMode.pipe(Schema4.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
-  activeTurnId: Schema4.NullOr(TurnId),
-  lastError: Schema4.NullOr(TrimmedNonEmptyString),
-  updatedAt: IsoDateTime
-});
-var OrchestrationCheckpointFile = Schema4.Struct({
-  path: TrimmedNonEmptyString,
-  kind: TrimmedNonEmptyString,
-  additions: NonNegativeInt,
-  deletions: NonNegativeInt
-});
-var OrchestrationCheckpointStatus = Schema4.Literals(["ready", "missing", "error"]);
-var OrchestrationCheckpointSummary = Schema4.Struct({
-  turnId: TurnId,
-  checkpointTurnCount: NonNegativeInt,
-  checkpointRef: CheckpointRef,
-  status: OrchestrationCheckpointStatus,
-  files: Schema4.Array(OrchestrationCheckpointFile),
-  assistantMessageId: Schema4.NullOr(MessageId),
-  completedAt: IsoDateTime
-});
-var OrchestrationThreadActivityTone = Schema4.Literals([
-  "info",
-  "tool",
-  "approval",
-  "error"
-]);
-var OrchestrationThreadActivity = Schema4.Struct({
-  id: EventId,
-  tone: OrchestrationThreadActivityTone,
-  kind: TrimmedNonEmptyString,
-  summary: TrimmedNonEmptyString,
-  payload: Schema4.Unknown,
-  turnId: Schema4.NullOr(TurnId),
-  sequence: Schema4.optional(NonNegativeInt),
-  createdAt: IsoDateTime
-});
-var OrchestrationLatestTurnState = Schema4.Literals([
-  "running",
-  "interrupted",
-  "completed",
-  "error"
-]);
-var OrchestrationLatestTurn = Schema4.Struct({
-  turnId: TurnId,
-  state: OrchestrationLatestTurnState,
-  requestedAt: IsoDateTime,
-  startedAt: Schema4.NullOr(IsoDateTime),
-  completedAt: Schema4.NullOr(IsoDateTime),
-  assistantMessageId: Schema4.NullOr(MessageId)
-});
-var OrchestrationThread = Schema4.Struct({
-  id: ThreadId,
-  projectId: ProjectId,
-  title: TrimmedNonEmptyString,
-  model: TrimmedNonEmptyString,
-  runtimeMode: RuntimeMode,
-  interactionMode: ProviderInteractionMode.pipe(Schema4.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  branch: Schema4.NullOr(TrimmedNonEmptyString),
-  worktreePath: Schema4.NullOr(TrimmedNonEmptyString),
-  latestTurn: Schema4.NullOr(OrchestrationLatestTurn),
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime,
-  deletedAt: Schema4.NullOr(IsoDateTime),
-  messages: Schema4.Array(OrchestrationMessage),
-  proposedPlans: Schema4.Array(OrchestrationProposedPlan).pipe(Schema4.withDecodingDefault(() => [])),
-  activities: Schema4.Array(OrchestrationThreadActivity),
-  checkpoints: Schema4.Array(OrchestrationCheckpointSummary),
-  session: Schema4.NullOr(OrchestrationSession)
-});
-var OrchestrationReadModel = Schema4.Struct({
-  snapshotSequence: NonNegativeInt,
-  projects: Schema4.Array(OrchestrationProject),
-  threads: Schema4.Array(OrchestrationThread),
-  updatedAt: IsoDateTime
-});
-var ProjectCreateCommand = Schema4.Struct({
-  type: Schema4.Literal("project.create"),
-  commandId: CommandId,
-  projectId: ProjectId,
-  title: TrimmedNonEmptyString,
-  workspaceRoot: TrimmedNonEmptyString,
-  defaultModel: Schema4.optional(TrimmedNonEmptyString),
-  createdAt: IsoDateTime
-});
-var ProjectMetaUpdateCommand = Schema4.Struct({
-  type: Schema4.Literal("project.meta.update"),
-  commandId: CommandId,
-  projectId: ProjectId,
-  title: Schema4.optional(TrimmedNonEmptyString),
-  workspaceRoot: Schema4.optional(TrimmedNonEmptyString),
-  defaultModel: Schema4.optional(TrimmedNonEmptyString),
-  scripts: Schema4.optional(Schema4.Array(ProjectScript))
-});
-var ProjectDeleteCommand = Schema4.Struct({
-  type: Schema4.Literal("project.delete"),
-  commandId: CommandId,
-  projectId: ProjectId
-});
-var ThreadCreateCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.create"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  projectId: ProjectId,
-  title: TrimmedNonEmptyString,
-  model: TrimmedNonEmptyString,
-  runtimeMode: RuntimeMode,
-  interactionMode: ProviderInteractionMode.pipe(Schema4.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  branch: Schema4.NullOr(TrimmedNonEmptyString),
-  worktreePath: Schema4.NullOr(TrimmedNonEmptyString),
-  createdAt: IsoDateTime
-});
-var ThreadDeleteCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.delete"),
-  commandId: CommandId,
-  threadId: ThreadId
-});
-var ThreadMetaUpdateCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.meta.update"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  title: Schema4.optional(TrimmedNonEmptyString),
-  model: Schema4.optional(TrimmedNonEmptyString),
-  branch: Schema4.optional(Schema4.NullOr(TrimmedNonEmptyString)),
-  worktreePath: Schema4.optional(Schema4.NullOr(TrimmedNonEmptyString))
-});
-var ThreadRuntimeModeSetCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.runtime-mode.set"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  runtimeMode: RuntimeMode,
-  createdAt: IsoDateTime
+  name: TrimmedNonEmptyString.check(Schema3.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema3.isMaxLength(100), Schema3.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema3.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES))
 });
-var ThreadInteractionModeSetCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.interaction-mode.set"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  interactionMode: ProviderInteractionMode,
-  createdAt: IsoDateTime
-});
-var ThreadTurnStartCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.turn.start"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  message: Schema4.Struct({
-    messageId: MessageId,
-    role: Schema4.Literal("user"),
-    text: Schema4.String,
-    attachments: Schema4.Array(ChatAttachment)
-  }),
-  provider: Schema4.optional(ProviderKind),
-  model: Schema4.optional(TrimmedNonEmptyString),
-  serviceTier: Schema4.optional(Schema4.NullOr(ProviderServiceTier)),
-  modelOptions: Schema4.optional(ProviderModelOptions),
-  assistantDeliveryMode: Schema4.optional(AssistantDeliveryMode),
-  runtimeMode: RuntimeMode.pipe(Schema4.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
-  interactionMode: ProviderInteractionMode.pipe(Schema4.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  createdAt: IsoDateTime
-});
-var ClientThreadTurnStartCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.turn.start"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  message: Schema4.Struct({
-    messageId: MessageId,
-    role: Schema4.Literal("user"),
-    text: Schema4.String,
-    attachments: Schema4.Array(UploadChatAttachment)
-  }),
-  provider: Schema4.optional(ProviderKind),
-  model: Schema4.optional(TrimmedNonEmptyString),
-  serviceTier: Schema4.optional(Schema4.NullOr(ProviderServiceTier)),
-  modelOptions: Schema4.optional(ProviderModelOptions),
-  assistantDeliveryMode: Schema4.optional(AssistantDeliveryMode),
-  runtimeMode: RuntimeMode,
-  interactionMode: ProviderInteractionMode,
-  createdAt: IsoDateTime
-});
-var ThreadTurnInterruptCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.turn.interrupt"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  turnId: Schema4.optional(TurnId),
-  createdAt: IsoDateTime
-});
-var ThreadApprovalRespondCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.approval.respond"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  requestId: ApprovalRequestId,
-  decision: ProviderApprovalDecision,
-  createdAt: IsoDateTime
-});
-var ThreadUserInputRespondCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.user-input.respond"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  requestId: ApprovalRequestId,
-  answers: ProviderUserInputAnswers,
-  createdAt: IsoDateTime
-});
-var ThreadCheckpointRevertCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.checkpoint.revert"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  turnCount: NonNegativeInt,
-  createdAt: IsoDateTime
-});
-var ThreadSessionStopCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.session.stop"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  createdAt: IsoDateTime
-});
-var DispatchableClientOrchestrationCommand = Schema4.Union([
-  ProjectCreateCommand,
-  ProjectMetaUpdateCommand,
-  ProjectDeleteCommand,
-  ThreadCreateCommand,
-  ThreadDeleteCommand,
-  ThreadMetaUpdateCommand,
-  ThreadRuntimeModeSetCommand,
-  ThreadInteractionModeSetCommand,
-  ThreadTurnStartCommand,
-  ThreadTurnInterruptCommand,
-  ThreadApprovalRespondCommand,
-  ThreadUserInputRespondCommand,
-  ThreadCheckpointRevertCommand,
-  ThreadSessionStopCommand
-]);
-var ClientOrchestrationCommand = Schema4.Union([
-  ProjectCreateCommand,
-  ProjectMetaUpdateCommand,
-  ProjectDeleteCommand,
-  ThreadCreateCommand,
-  ThreadDeleteCommand,
-  ThreadMetaUpdateCommand,
-  ThreadRuntimeModeSetCommand,
-  ThreadInteractionModeSetCommand,
-  ClientThreadTurnStartCommand,
-  ThreadTurnInterruptCommand,
-  ThreadApprovalRespondCommand,
-  ThreadUserInputRespondCommand,
-  ThreadCheckpointRevertCommand,
-  ThreadSessionStopCommand
-]);
-var ThreadSessionSetCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.session.set"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  session: OrchestrationSession,
-  createdAt: IsoDateTime
-});
-var ThreadMessageAssistantDeltaCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.message.assistant.delta"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  messageId: MessageId,
-  delta: Schema4.String,
-  turnId: Schema4.optional(TurnId),
-  createdAt: IsoDateTime
-});
-var ThreadMessageAssistantCompleteCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.message.assistant.complete"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  messageId: MessageId,
-  turnId: Schema4.optional(TurnId),
-  createdAt: IsoDateTime
-});
-var ThreadProposedPlanUpsertCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.proposed-plan.upsert"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  proposedPlan: OrchestrationProposedPlan,
-  createdAt: IsoDateTime
-});
-var ThreadTurnDiffCompleteCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.turn.diff.complete"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  turnId: TurnId,
-  completedAt: IsoDateTime,
-  checkpointRef: CheckpointRef,
-  status: OrchestrationCheckpointStatus,
-  files: Schema4.Array(OrchestrationCheckpointFile),
-  assistantMessageId: Schema4.optional(MessageId),
-  checkpointTurnCount: NonNegativeInt,
-  createdAt: IsoDateTime
-});
-var ThreadActivityAppendCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.activity.append"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  activity: OrchestrationThreadActivity,
-  createdAt: IsoDateTime
-});
-var ThreadRevertCompleteCommand = Schema4.Struct({
-  type: Schema4.Literal("thread.revert.complete"),
-  commandId: CommandId,
-  threadId: ThreadId,
-  turnCount: NonNegativeInt,
-  createdAt: IsoDateTime
-});
-var InternalOrchestrationCommand = Schema4.Union([
-  ThreadSessionSetCommand,
-  ThreadMessageAssistantDeltaCommand,
-  ThreadMessageAssistantCompleteCommand,
-  ThreadProposedPlanUpsertCommand,
-  ThreadTurnDiffCompleteCommand,
-  ThreadActivityAppendCommand,
-  ThreadRevertCompleteCommand
-]);
-var OrchestrationCommand = Schema4.Union([
-  DispatchableClientOrchestrationCommand,
-  InternalOrchestrationCommand
-]);
-var OrchestrationEventType = Schema4.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 = Schema4.Literals(["project", "thread"]);
-var OrchestrationActorKind = Schema4.Literals(["client", "server", "provider"]);
-var ProjectCreatedPayload = Schema4.Struct({
-  projectId: ProjectId,
-  title: TrimmedNonEmptyString,
-  workspaceRoot: TrimmedNonEmptyString,
-  defaultModel: Schema4.NullOr(TrimmedNonEmptyString),
-  scripts: Schema4.Array(ProjectScript),
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime
-});
-var ProjectMetaUpdatedPayload = Schema4.Struct({
-  projectId: ProjectId,
-  title: Schema4.optional(TrimmedNonEmptyString),
-  workspaceRoot: Schema4.optional(TrimmedNonEmptyString),
-  defaultModel: Schema4.optional(Schema4.NullOr(TrimmedNonEmptyString)),
-  scripts: Schema4.optional(Schema4.Array(ProjectScript)),
-  updatedAt: IsoDateTime
-});
-var ProjectDeletedPayload = Schema4.Struct({
-  projectId: ProjectId,
-  deletedAt: IsoDateTime
-});
-var ThreadCreatedPayload = Schema4.Struct({
-  threadId: ThreadId,
-  projectId: ProjectId,
-  title: TrimmedNonEmptyString,
-  model: TrimmedNonEmptyString,
-  runtimeMode: RuntimeMode.pipe(Schema4.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
-  interactionMode: ProviderInteractionMode.pipe(Schema4.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  branch: Schema4.NullOr(TrimmedNonEmptyString),
-  worktreePath: Schema4.NullOr(TrimmedNonEmptyString),
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime
-});
-var ThreadDeletedPayload = Schema4.Struct({
-  threadId: ThreadId,
-  deletedAt: IsoDateTime
-});
-var ThreadMetaUpdatedPayload = Schema4.Struct({
-  threadId: ThreadId,
-  title: Schema4.optional(TrimmedNonEmptyString),
-  model: Schema4.optional(TrimmedNonEmptyString),
-  branch: Schema4.optional(Schema4.NullOr(TrimmedNonEmptyString)),
-  worktreePath: Schema4.optional(Schema4.NullOr(TrimmedNonEmptyString)),
-  updatedAt: IsoDateTime
-});
-var ThreadRuntimeModeSetPayload = Schema4.Struct({
-  threadId: ThreadId,
-  runtimeMode: RuntimeMode,
-  updatedAt: IsoDateTime
-});
-var ThreadInteractionModeSetPayload = Schema4.Struct({
-  threadId: ThreadId,
-  interactionMode: ProviderInteractionMode.pipe(Schema4.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  updatedAt: IsoDateTime
-});
-var ThreadMessageSentPayload = Schema4.Struct({
-  threadId: ThreadId,
-  messageId: MessageId,
-  role: OrchestrationMessageRole,
-  text: Schema4.String,
-  attachments: Schema4.optional(Schema4.Array(ChatAttachment)),
-  turnId: Schema4.NullOr(TurnId),
-  streaming: Schema4.Boolean,
-  createdAt: IsoDateTime,
-  updatedAt: IsoDateTime
-});
-var ThreadTurnStartRequestedPayload = Schema4.Struct({
-  threadId: ThreadId,
-  messageId: MessageId,
-  provider: Schema4.optional(ProviderKind),
-  model: Schema4.optional(TrimmedNonEmptyString),
-  serviceTier: Schema4.optional(Schema4.NullOr(ProviderServiceTier)),
-  modelOptions: Schema4.optional(ProviderModelOptions),
-  assistantDeliveryMode: Schema4.optional(AssistantDeliveryMode),
-  runtimeMode: RuntimeMode.pipe(Schema4.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
-  interactionMode: ProviderInteractionMode.pipe(Schema4.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  createdAt: IsoDateTime
-});
-var ThreadTurnInterruptRequestedPayload = Schema4.Struct({
-  threadId: ThreadId,
-  turnId: Schema4.optional(TurnId),
-  createdAt: IsoDateTime
-});
-var ThreadApprovalResponseRequestedPayload = Schema4.Struct({
-  threadId: ThreadId,
-  requestId: ApprovalRequestId,
-  decision: ProviderApprovalDecision,
-  createdAt: IsoDateTime
-});
-var ThreadUserInputResponseRequestedPayload = Schema4.Struct({
-  threadId: ThreadId,
-  requestId: ApprovalRequestId,
-  answers: ProviderUserInputAnswers,
-  createdAt: IsoDateTime
-});
-var ThreadCheckpointRevertRequestedPayload = Schema4.Struct({
-  threadId: ThreadId,
-  turnCount: NonNegativeInt,
-  createdAt: IsoDateTime
-});
-var ThreadRevertedPayload = Schema4.Struct({
-  threadId: ThreadId,
-  turnCount: NonNegativeInt
-});
-var ThreadSessionStopRequestedPayload = Schema4.Struct({
-  threadId: ThreadId,
-  createdAt: IsoDateTime
-});
-var ThreadSessionSetPayload = Schema4.Struct({
-  threadId: ThreadId,
-  session: OrchestrationSession
-});
-var ThreadProposedPlanUpsertedPayload = Schema4.Struct({
-  threadId: ThreadId,
-  proposedPlan: OrchestrationProposedPlan
-});
-var ThreadTurnDiffCompletedPayload = Schema4.Struct({
-  threadId: ThreadId,
-  turnId: TurnId,
-  checkpointTurnCount: NonNegativeInt,
-  checkpointRef: CheckpointRef,
-  status: OrchestrationCheckpointStatus,
-  files: Schema4.Array(OrchestrationCheckpointFile),
-  assistantMessageId: Schema4.NullOr(MessageId),
-  completedAt: IsoDateTime
-});
-var ThreadActivityAppendedPayload = Schema4.Struct({
-  threadId: ThreadId,
-  activity: OrchestrationThreadActivity
-});
-var OrchestrationEventMetadata = Schema4.Struct({
-  providerTurnId: Schema4.optional(TrimmedNonEmptyString),
-  providerItemId: Schema4.optional(ProviderItemId),
-  adapterKey: Schema4.optional(TrimmedNonEmptyString),
-  requestId: Schema4.optional(ApprovalRequestId),
-  ingestedAt: Schema4.optional(IsoDateTime)
-});
-var EventBaseFields = {
-  sequence: NonNegativeInt,
-  eventId: EventId,
-  aggregateKind: OrchestrationAggregateKind,
-  aggregateId: Schema4.Union([ProjectId, ThreadId]),
-  occurredAt: IsoDateTime,
-  commandId: Schema4.NullOr(CommandId),
-  causationEventId: Schema4.NullOr(EventId),
-  correlationId: Schema4.NullOr(CommandId),
-  metadata: OrchestrationEventMetadata
-};
-var PersistedEventBaseFields = {
-  sequence: NonNegativeInt,
-  eventId: EventId,
-  aggregateKind: OrchestrationAggregateKind,
-  streamId: Schema4.Union([ProjectId, ThreadId]),
-  streamVersion: NonNegativeInt,
-  occurredAt: IsoDateTime,
-  commandId: Schema4.NullOr(CommandId),
-  causationEventId: Schema4.NullOr(EventId),
-  correlationId: Schema4.NullOr(CommandId),
-  actorKind: OrchestrationActorKind,
-  metadata: OrchestrationEventMetadata
-};
-var OrchestrationEvent = Schema4.Union([
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("project.created"),
-    payload: ProjectCreatedPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("project.meta-updated"),
-    payload: ProjectMetaUpdatedPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("project.deleted"),
-    payload: ProjectDeletedPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("thread.created"),
-    payload: ThreadCreatedPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("thread.deleted"),
-    payload: ThreadDeletedPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("thread.meta-updated"),
-    payload: ThreadMetaUpdatedPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("thread.runtime-mode-set"),
-    payload: ThreadRuntimeModeSetPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("thread.interaction-mode-set"),
-    payload: ThreadInteractionModeSetPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("thread.message-sent"),
-    payload: ThreadMessageSentPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("thread.turn-start-requested"),
-    payload: ThreadTurnStartRequestedPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("thread.turn-interrupt-requested"),
-    payload: ThreadTurnInterruptRequestedPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("thread.approval-response-requested"),
-    payload: ThreadApprovalResponseRequestedPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("thread.user-input-response-requested"),
-    payload: ThreadUserInputResponseRequestedPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("thread.checkpoint-revert-requested"),
-    payload: ThreadCheckpointRevertRequestedPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("thread.reverted"),
-    payload: ThreadRevertedPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("thread.session-stop-requested"),
-    payload: ThreadSessionStopRequestedPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("thread.session-set"),
-    payload: ThreadSessionSetPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("thread.proposed-plan-upserted"),
-    payload: ThreadProposedPlanUpsertedPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("thread.turn-diff-completed"),
-    payload: ThreadTurnDiffCompletedPayload
-  }),
-  Schema4.Struct({
-    ...EventBaseFields,
-    type: Schema4.Literal("thread.activity-appended"),
-    payload: ThreadActivityAppendedPayload
-  })
-]);
-var OrchestrationPersistedEvent = Schema4.Union([
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("project.created"),
-    payload: ProjectCreatedPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("project.meta-updated"),
-    payload: ProjectMetaUpdatedPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("project.deleted"),
-    payload: ProjectDeletedPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("thread.created"),
-    payload: ThreadCreatedPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("thread.deleted"),
-    payload: ThreadDeletedPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("thread.meta-updated"),
-    payload: ThreadMetaUpdatedPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("thread.runtime-mode-set"),
-    payload: ThreadRuntimeModeSetPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("thread.interaction-mode-set"),
-    payload: ThreadInteractionModeSetPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("thread.message-sent"),
-    payload: ThreadMessageSentPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("thread.turn-start-requested"),
-    payload: ThreadTurnStartRequestedPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("thread.turn-interrupt-requested"),
-    payload: ThreadTurnInterruptRequestedPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("thread.approval-response-requested"),
-    payload: ThreadApprovalResponseRequestedPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("thread.user-input-response-requested"),
-    payload: ThreadUserInputResponseRequestedPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("thread.checkpoint-revert-requested"),
-    payload: ThreadCheckpointRevertRequestedPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("thread.reverted"),
-    payload: ThreadRevertedPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("thread.session-stop-requested"),
-    payload: ThreadSessionStopRequestedPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("thread.session-set"),
-    payload: ThreadSessionSetPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("thread.proposed-plan-upserted"),
-    payload: ThreadProposedPlanUpsertedPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("thread.turn-diff-completed"),
-    payload: ThreadTurnDiffCompletedPayload
-  }),
-  Schema4.Struct({
-    ...PersistedEventBaseFields,
-    eventType: Schema4.Literal("thread.activity-appended"),
-    payload: ThreadActivityAppendedPayload
-  })
-]);
-var OrchestrationCommandReceiptStatus = Schema4.Literals(["accepted", "rejected"]);
-var TurnCountRange = Schema4.Struct({
-  fromTurnCount: NonNegativeInt,
-  toTurnCount: NonNegativeInt
-}).check(Schema4.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: Schema4.String
-}), { unsafePreserveChecks: true });
-var ProviderSessionRuntimeStatus = Schema4.Literals([
-  "starting",
-  "running",
-  "stopped",
-  "error"
-]);
-var ProjectionThreadTurnStatus = Schema4.Literals([
-  "running",
-  "completed",
-  "interrupted",
-  "error"
-]);
-var ProjectionCheckpointRow = Schema4.Struct({
-  threadId: ThreadId,
-  turnId: TurnId,
-  checkpointTurnCount: NonNegativeInt,
-  checkpointRef: CheckpointRef,
-  status: OrchestrationCheckpointStatus,
-  files: Schema4.Array(OrchestrationCheckpointFile),
-  assistantMessageId: Schema4.NullOr(MessageId),
-  completedAt: IsoDateTime
-});
-var ProjectionPendingApprovalStatus = Schema4.Literals(["pending", "resolved"]);
-var ProjectionPendingApprovalDecision = Schema4.NullOr(ProviderApprovalDecision);
-var DispatchResult = Schema4.Struct({
-  sequence: NonNegativeInt
-});
-var OrchestrationGetSnapshotInput = Schema4.Struct({});
-var OrchestrationGetTurnDiffInput = TurnCountRange.mapFields(Struct.assign({ threadId: ThreadId }), { unsafePreserveChecks: true });
-var OrchestrationGetFullThreadDiffInput = Schema4.Struct({
-  threadId: ThreadId,
-  toTurnCount: NonNegativeInt
-});
-var OrchestrationReplayEventsInput = Schema4.Struct({
-  fromSequenceExclusive: NonNegativeInt
-});
-var OrchestrationReplayEventsResult = Schema4.Array(OrchestrationEvent);
+var ChatAttachment = Schema3.Union([ChatImageAttachment]);
 
 // packages/contracts/src/runtime.ts
-import { Schema as Schema5 } from "effect";
-var RunKind = Schema5.Literals(["adhoc", "task", "batch", "validation", "review"]);
-var RunMode = Schema5.Literals(["interactive", "autonomous", "supervised"]);
-var RunStatus = Schema5.Literals([
+import { Schema as Schema4 } from "effect";
+var RunKind = Schema4.Literals(["adhoc", "task", "batch", "validation", "review"]);
+var RunMode = Schema4.Literals(["interactive", "autonomous", "supervised"]);
+var RunStatus = Schema4.Literals([
   "created",
   "queued",
   "preparing",
   "running",
   "waiting-approval",
   "waiting-user-input",
+  "paused",
   "validating",
   "reviewing",
+  "closing-out",
+  "needs-attention",
   "completed",
   "failed",
-  "cancelled",
-  "paused"
+  "stopped"
 ]);
-var EngineSandboxMode = Schema5.Literals([
+var EngineSandboxMode = Schema4.Literals([
   "read-only",
   "workspace-write",
   "danger-full-access"
 ]);
-var IsolationMode = Schema5.Literals(["none", "env", "worktree"]);
-var RuntimeStatus = Schema5.Literals([
+var IsolationMode = Schema4.Literals(["none", "env", "worktree"]);
+var RuntimeStatus = Schema4.Literals([
   "prepared",
   "starting",
   "running",
@@ -994,103 +161,103 @@ var RuntimeStatus = Schema5.Literals([
   "failed",
   "destroyed"
 ]);
-var RunExecutionTarget = Schema5.Literals(["local", "remote"]);
-var RunSummary = Schema5.Struct({
+var RunExecutionTarget = Schema4.Literals(["local", "remote"]);
+var RunSummary = Schema4.Struct({
   id: RunId,
   workspaceId: WorkspaceId,
-  taskId: Schema5.NullOr(TaskId),
+  taskId: Schema4.NullOr(TaskId),
   title: TrimmedNonEmptyString,
   runKind: RunKind,
   mode: RunMode,
   runtimeMode: RuntimeMode,
   interactionMode: ProviderInteractionMode,
   status: RunStatus,
-  runtimeAdapter: TrimmedNonEmptyString,
-  model: Schema5.NullOr(TrimmedNonEmptyString),
-  initialPrompt: Schema5.NullOr(Schema5.String),
-  executionTarget: Schema5.optional(RunExecutionTarget),
-  remoteHostId: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
-  remoteLeaseId: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
-  remoteLeaseClaimedAt: Schema5.optional(Schema5.NullOr(IsoDateTime)),
-  activeRuntimeId: Schema5.NullOr(EngineRuntimeId),
-  latestMessageId: Schema5.NullOr(TrimmedNonEmptyString),
+  runtimeAdapter: Schema4.Literal("pi"),
+  model: Schema4.NullOr(TrimmedNonEmptyString),
+  initialPrompt: Schema4.NullOr(Schema4.String),
+  executionTarget: Schema4.optional(RunExecutionTarget),
+  remoteHostId: Schema4.optional(Schema4.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseId: Schema4.optional(Schema4.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseClaimedAt: Schema4.optional(Schema4.NullOr(IsoDateTime)),
+  activeRuntimeId: Schema4.NullOr(EngineRuntimeId),
+  latestMessageId: Schema4.NullOr(TrimmedNonEmptyString),
   pendingApprovalCount: NonNegativeInt,
   pendingUserInputCount: NonNegativeInt,
-  branch: Schema5.NullOr(TrimmedNonEmptyString),
-  worktreePath: Schema5.NullOr(TrimmedNonEmptyString),
-  errorText: Schema5.NullOr(Schema5.String),
+  branch: Schema4.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema4.NullOr(TrimmedNonEmptyString),
+  errorText: Schema4.NullOr(Schema4.String),
   createdAt: IsoDateTime,
   updatedAt: IsoDateTime,
-  startedAt: Schema5.NullOr(IsoDateTime),
-  completedAt: Schema5.NullOr(IsoDateTime)
+  startedAt: Schema4.NullOr(IsoDateTime),
+  completedAt: Schema4.NullOr(IsoDateTime)
 });
-var RuntimeSummary = Schema5.Struct({
+var RuntimeSummary = Schema4.Struct({
   id: EngineRuntimeId,
   workspaceId: WorkspaceId,
   runId: RunId,
-  adapterKind: TrimmedNonEmptyString,
-  executionTarget: Schema5.optional(RunExecutionTarget),
-  remoteHostId: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  adapterKind: Schema4.Literal("pi"),
+  executionTarget: Schema4.optional(RunExecutionTarget),
+  remoteHostId: Schema4.optional(Schema4.NullOr(TrimmedNonEmptyString)),
   status: RuntimeStatus,
   sandboxMode: EngineSandboxMode,
   isolationMode: IsolationMode,
-  workspaceDir: Schema5.NullOr(TrimmedNonEmptyString),
-  homeDir: Schema5.NullOr(TrimmedNonEmptyString),
-  tmpDir: Schema5.NullOr(TrimmedNonEmptyString),
-  cacheDir: Schema5.NullOr(TrimmedNonEmptyString),
-  logsDir: Schema5.NullOr(TrimmedNonEmptyString),
-  stateDir: Schema5.NullOr(TrimmedNonEmptyString),
-  sessionDir: Schema5.NullOr(TrimmedNonEmptyString),
-  sessionLogPath: Schema5.NullOr(TrimmedNonEmptyString),
-  pid: Schema5.NullOr(NonNegativeInt),
-  startedAt: Schema5.NullOr(IsoDateTime),
+  workspaceDir: Schema4.NullOr(TrimmedNonEmptyString),
+  homeDir: Schema4.NullOr(TrimmedNonEmptyString),
+  tmpDir: Schema4.NullOr(TrimmedNonEmptyString),
+  cacheDir: Schema4.NullOr(TrimmedNonEmptyString),
+  logsDir: Schema4.NullOr(TrimmedNonEmptyString),
+  stateDir: Schema4.NullOr(TrimmedNonEmptyString),
+  sessionDir: Schema4.NullOr(TrimmedNonEmptyString),
+  sessionLogPath: Schema4.NullOr(TrimmedNonEmptyString),
+  pid: Schema4.NullOr(NonNegativeInt),
+  startedAt: Schema4.NullOr(IsoDateTime),
   updatedAt: IsoDateTime,
-  exitedAt: Schema5.NullOr(IsoDateTime)
+  exitedAt: Schema4.NullOr(IsoDateTime)
 });
-var ApprovalStatus = Schema5.Literals(["pending", "resolved"]);
-var ApprovalSummary = Schema5.Struct({
+var ApprovalStatus = Schema4.Literals(["pending", "resolved"]);
+var ApprovalSummary = Schema4.Struct({
   id: TrimmedNonEmptyString,
   runId: RunId,
-  actionId: Schema5.NullOr(TrimmedNonEmptyString),
+  actionId: Schema4.NullOr(TrimmedNonEmptyString),
   requestKind: TrimmedNonEmptyString,
   status: ApprovalStatus,
-  payload: Schema5.Unknown,
+  payload: Schema4.Unknown,
   createdAt: IsoDateTime,
-  resolvedAt: Schema5.NullOr(IsoDateTime)
+  resolvedAt: Schema4.NullOr(IsoDateTime)
 });
-var UserInputRequestSummary = Schema5.Struct({
+var UserInputRequestSummary = Schema4.Struct({
   id: TrimmedNonEmptyString,
   runId: RunId,
   status: ApprovalStatus,
-  payload: Schema5.Unknown,
+  payload: Schema4.Unknown,
   createdAt: IsoDateTime,
-  resolvedAt: Schema5.NullOr(IsoDateTime)
+  resolvedAt: Schema4.NullOr(IsoDateTime)
 });
-var WorktreeSummary = Schema5.Struct({
+var WorktreeSummary = Schema4.Struct({
   id: WorktreeId,
   workspaceId: WorkspaceId,
   runId: RunId,
-  taskId: Schema5.NullOr(TaskId),
+  taskId: Schema4.NullOr(TaskId),
   branchName: TrimmedNonEmptyString,
   path: TrimmedNonEmptyString,
   status: TrimmedNonEmptyString,
   createdAt: IsoDateTime,
-  cleanedAt: Schema5.NullOr(IsoDateTime)
+  cleanedAt: Schema4.NullOr(IsoDateTime)
 });
 
 // packages/contracts/src/workspace.ts
-import { Schema as Schema6 } from "effect";
-var WorkspaceSourceKind = Schema6.Literals(["native", "rig-import", "manual", "remote"]);
-var WorkspaceTopologyStatus = Schema6.Literals(["empty", "ready", "degraded"]);
-var WorkspaceRemoteFleetStatus = Schema6.Literals(["empty", "ready", "degraded"]);
-var WorkspaceServiceFabricStatus = Schema6.Literals([
+import { Schema as Schema5 } from "effect";
+var WorkspaceSourceKind = Schema5.Literals(["native", "rig-import", "manual", "remote"]);
+var WorkspaceTopologyStatus = Schema5.Literals(["empty", "ready", "degraded"]);
+var WorkspaceRemoteFleetStatus = Schema5.Literals(["empty", "ready", "degraded"]);
+var WorkspaceServiceFabricStatus = Schema5.Literals([
   "empty",
   "booting",
   "ready",
   "degraded",
   "stopped"
 ]);
-var WorkspaceRemoteHostStatus = Schema6.Literals([
+var WorkspaceRemoteHostStatus = Schema5.Literals([
   "registering",
   "ready",
   "busy",
@@ -1099,103 +266,104 @@ var WorkspaceRemoteHostStatus = Schema6.Literals([
   "offline",
   "quarantined"
 ]);
-var WorkspaceTopologyServiceSummary = Schema6.Struct({
+var WorkspaceTopologyServiceSummary = Schema5.Struct({
   name: TrimmedNonEmptyString,
   relativeRootPath: TrimmedNonEmptyString,
   runtime: TrimmedNonEmptyString,
-  port: Schema6.NullOr(Schema6.Number),
-  healthcheck: Schema6.NullOr(TrimmedNonEmptyString),
-  sourceOfTruth: Schema6.Struct({
-    code: Schema6.NullOr(TrimmedNonEmptyString),
-    tests: Schema6.NullOr(TrimmedNonEmptyString),
-    infra: Schema6.NullOr(TrimmedNonEmptyString),
-    deploy: Schema6.NullOr(TrimmedNonEmptyString),
-    dependencies: Schema6.NullOr(TrimmedNonEmptyString)
-  }),
-  splitReadyChecklist: Schema6.Array(TrimmedNonEmptyString)
-});
-var WorkspaceTopologySummary = Schema6.Struct({
+  port: Schema5.NullOr(Schema5.Number),
+  healthcheck: Schema5.NullOr(TrimmedNonEmptyString),
+  sourceOfTruth: Schema5.Struct({
+    code: Schema5.NullOr(TrimmedNonEmptyString),
+    tests: Schema5.NullOr(TrimmedNonEmptyString),
+    infra: Schema5.NullOr(TrimmedNonEmptyString),
+    deploy: Schema5.NullOr(TrimmedNonEmptyString),
+    dependencies: Schema5.NullOr(TrimmedNonEmptyString)
+  }),
+  splitReadyChecklist: Schema5.Array(TrimmedNonEmptyString)
+});
+var WorkspaceTopologySummary = Schema5.Struct({
   compiledAt: IsoDateTime,
   status: WorkspaceTopologyStatus,
-  manifestCount: Schema6.Number,
-  serviceCount: Schema6.Number,
-  services: Schema6.Array(WorkspaceTopologyServiceSummary),
-  warnings: Schema6.Array(Schema6.String)
+  manifestCount: Schema5.Number,
+  serviceCount: Schema5.Number,
+  services: Schema5.Array(WorkspaceTopologyServiceSummary),
+  warnings: Schema5.Array(Schema5.String)
 });
-var WorkspaceRemoteHostSummary = Schema6.Struct({
+var WorkspaceRemoteHostSummary = Schema5.Struct({
   id: TrimmedNonEmptyString,
   name: TrimmedNonEmptyString,
   baseUrl: TrimmedNonEmptyString,
-  workspacePath: Schema6.NullOr(TrimmedNonEmptyString),
+  workspacePath: Schema5.NullOr(TrimmedNonEmptyString),
   transport: TrimmedNonEmptyString,
-  hostname: Schema6.NullOr(TrimmedNonEmptyString),
-  region: Schema6.NullOr(TrimmedNonEmptyString),
-  labels: Schema6.Array(TrimmedNonEmptyString),
-  capabilities: Schema6.Array(TrimmedNonEmptyString),
-  runtimeAdapters: Schema6.Array(TrimmedNonEmptyString),
+  hostname: Schema5.NullOr(TrimmedNonEmptyString),
+  region: Schema5.NullOr(TrimmedNonEmptyString),
+  labels: Schema5.Array(TrimmedNonEmptyString),
+  capabilities: Schema5.Array(TrimmedNonEmptyString),
+  runtimeAdapters: Schema5.Array(Schema5.Literal("pi")),
   status: WorkspaceRemoteHostStatus,
-  currentLeaseCount: Schema6.Number,
-  lastHeartbeatAt: Schema6.NullOr(IsoDateTime),
+  currentLeaseCount: Schema5.Number,
+  lastHeartbeatAt: Schema5.NullOr(IsoDateTime),
   registeredAt: IsoDateTime,
   manifestPath: TrimmedNonEmptyString
 });
-var WorkspaceRemoteFleetSummary = Schema6.Struct({
+var WorkspaceRemoteFleetSummary = Schema5.Struct({
   updatedAt: IsoDateTime,
   status: WorkspaceRemoteFleetStatus,
-  manifestCount: Schema6.Number,
-  hostCount: Schema6.Number,
-  onlineHostCount: Schema6.Number,
-  hosts: Schema6.Array(WorkspaceRemoteHostSummary),
-  warnings: Schema6.Array(Schema6.String)
+  manifestCount: Schema5.Number,
+  hostCount: Schema5.Number,
+  onlineHostCount: Schema5.Number,
+  hosts: Schema5.Array(WorkspaceRemoteHostSummary),
+  warnings: Schema5.Array(Schema5.String)
 });
-var WorkspaceServiceFabricServiceSummary = Schema6.Struct({
+var WorkspaceServiceFabricServiceSummary = Schema5.Struct({
   name: TrimmedNonEmptyString,
   relativeRootPath: TrimmedNonEmptyString,
-  mode: Schema6.Literals(["stub", "process"]),
-  port: Schema6.Number,
+  mode: Schema5.Literals(["stub", "process"]),
+  port: Schema5.Number,
   healthcheck: TrimmedNonEmptyString,
-  routePrefix: Schema6.NullOr(TrimmedNonEmptyString),
-  status: Schema6.Literals(["planned", "booting", "healthy", "degraded", "failed", "stopped"]),
-  pid: Schema6.NullOr(Schema6.Number),
-  logPath: Schema6.NullOr(TrimmedNonEmptyString)
+  routePrefix: Schema5.NullOr(TrimmedNonEmptyString),
+  status: Schema5.Literals(["planned", "booting", "healthy", "degraded", "failed", "stopped"]),
+  pid: Schema5.NullOr(Schema5.Number),
+  logPath: Schema5.NullOr(TrimmedNonEmptyString)
 });
-var WorkspaceServiceFabricSummary = Schema6.Struct({
+var WorkspaceServiceFabricSummary = Schema5.Struct({
   updatedAt: IsoDateTime,
   status: WorkspaceServiceFabricStatus,
-  serviceCount: Schema6.Number,
-  healthyServiceCount: Schema6.Number,
+  serviceCount: Schema5.Number,
+  healthyServiceCount: Schema5.Number,
   stateDir: TrimmedNonEmptyString,
-  services: Schema6.Array(WorkspaceServiceFabricServiceSummary),
-  warnings: Schema6.Array(Schema6.String)
+  services: Schema5.Array(WorkspaceServiceFabricServiceSummary),
+  warnings: Schema5.Array(Schema5.String)
 });
-var WorkspaceSummary = Schema6.Struct({
+var WorkspaceSummary = Schema5.Struct({
   id: WorkspaceId,
   title: TrimmedNonEmptyString,
   rootPath: TrimmedNonEmptyString,
   sourceKind: WorkspaceSourceKind,
-  defaultRuntimeAdapter: Schema6.optional(TrimmedNonEmptyString),
-  defaultProvider: Schema6.optional(ProviderKind),
-  defaultModel: Schema6.NullOr(TrimmedNonEmptyString),
-  topology: Schema6.optional(WorkspaceTopologySummary),
-  remoteFleet: Schema6.optional(WorkspaceRemoteFleetSummary),
-  serviceFabric: Schema6.optional(WorkspaceServiceFabricSummary),
+  defaultRuntimeAdapter: Schema5.optional(Schema5.Literal("pi")),
+  defaultProvider: Schema5.optional(ProviderKind),
+  defaultModel: Schema5.NullOr(TrimmedNonEmptyString),
+  topology: Schema5.optional(WorkspaceTopologySummary),
+  remoteFleet: Schema5.optional(WorkspaceRemoteFleetSummary),
+  serviceFabric: Schema5.optional(WorkspaceServiceFabricSummary),
   createdAt: IsoDateTime,
   updatedAt: IsoDateTime
 });
 
 // packages/contracts/src/remote.ts
-var RemoteEndpoint = Schema7.Struct({
+var RemoteRuntimeAdapter = Schema6.Literal("pi");
+var RemoteEndpoint = Schema6.Struct({
   id: RemoteEndpointId,
   alias: TrimmedNonEmptyString,
   host: TrimmedNonEmptyString,
-  port: Schema7.Int.check(Schema7.isGreaterThanOrEqualTo(1)).check(Schema7.isLessThanOrEqualTo(65535)),
-  token: Schema7.String,
-  tokenConfigured: Schema7.optional(Schema7.Boolean),
-  autoConnect: Schema7.optional(Schema7.Boolean),
+  port: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(1)).check(Schema6.isLessThanOrEqualTo(65535)),
+  token: Schema6.String,
+  tokenConfigured: Schema6.optional(Schema6.Boolean),
+  autoConnect: Schema6.optional(Schema6.Boolean),
   addedAt: IsoDateTime,
-  lastConnectedAt: Schema7.NullOr(IsoDateTime)
+  lastConnectedAt: Schema6.NullOr(IsoDateTime)
 });
-var RemoteConnectionStatus = Schema7.Literals([
+var RemoteConnectionStatus = Schema6.Literals([
   "disconnected",
   "connecting",
   "authenticating",
@@ -1203,157 +371,150 @@ var RemoteConnectionStatus = Schema7.Literals([
   "reconnecting",
   "error"
 ]);
-var RemoteConnectionSummary = Schema7.Struct({
+var RemoteConnectionSummary = Schema6.Struct({
   endpointId: RemoteEndpointId,
   status: RemoteConnectionStatus,
-  error: Schema7.NullOr(Schema7.String),
-  connectedAt: Schema7.NullOr(IsoDateTime),
-  tokenExpiresAt: Schema7.NullOr(IsoDateTime),
-  latencyMs: Schema7.NullOr(Schema7.Number),
-  subscribedEvents: Schema7.Array(Schema7.String)
-});
-var RemoteConnectionStatusChanged = Schema7.Struct({
-  endpointId: Schema7.String,
-  endpointAlias: Schema7.String,
+  error: Schema6.NullOr(Schema6.String),
+  connectedAt: Schema6.NullOr(IsoDateTime),
+  tokenExpiresAt: Schema6.NullOr(IsoDateTime),
+  latencyMs: Schema6.NullOr(Schema6.Number),
+  subscribedEvents: Schema6.Array(Schema6.String)
+});
+var RemoteConnectionStatusChanged = Schema6.Struct({
+  endpointId: Schema6.String,
+  endpointAlias: Schema6.String,
   status: RemoteConnectionStatus,
   previousStatus: RemoteConnectionStatus,
-  error: Schema7.NullOr(Schema7.String),
-  connectedAt: Schema7.NullOr(Schema7.String),
-  latencyMs: Schema7.NullOr(Schema7.Number),
-  timestamp: Schema7.String
-});
-var EnrichedRemoteEvent = Schema7.Struct({
-  endpointId: Schema7.String,
-  endpointAlias: Schema7.String,
-  receivedAt: Schema7.String,
-  originalTimestamp: Schema7.optional(Schema7.NullOr(Schema7.String)),
-  event: Schema7.Unknown
-});
-var RemoteOrchestratorState = Schema7.Struct({
-  activeTaskId: Schema7.NullOr(Schema7.String),
-  activeIteration: Schema7.NullOr(Schema7.Number),
-  maxIterations: Schema7.Number,
-  isPaused: Schema7.Boolean,
-  isRunning: Schema7.Boolean,
+  error: Schema6.NullOr(Schema6.String),
+  connectedAt: Schema6.NullOr(Schema6.String),
+  latencyMs: Schema6.NullOr(Schema6.Number),
+  timestamp: Schema6.String
+});
+var RemoteOrchestratorState = Schema6.Struct({
+  activeTaskId: Schema6.NullOr(Schema6.String),
+  activeIteration: Schema6.NullOr(Schema6.Number),
+  maxIterations: Schema6.Number,
+  isPaused: Schema6.Boolean,
+  isRunning: Schema6.Boolean,
   totalCompleted: NonNegativeInt,
   totalFailed: NonNegativeInt,
-  lastActivity: Schema7.NullOr(IsoDateTime)
+  lastActivity: Schema6.NullOr(IsoDateTime)
 });
-var RemoteOrchestrationSummary = Schema7.Struct({
+var RemoteOrchestrationSummary = Schema6.Struct({
   orchestrationId: TrimmedNonEmptyString,
   endpointId: RemoteEndpointId,
-  status: Schema7.Literals(["running", "paused", "stopped", "completed"]),
+  status: Schema6.Literals(["running", "paused", "stopped", "completed"]),
   totalTasks: NonNegativeInt,
   totalGroups: NonNegativeInt,
   maxParallelism: NonNegativeInt,
   startedAt: IsoDateTime
 });
-var RemoteIterationOutput = Schema7.Struct({
-  taskId: Schema7.optional(Schema7.String),
-  iteration: Schema7.optional(Schema7.Number),
-  output: Schema7.optional(Schema7.String),
-  startedAt: Schema7.optional(IsoDateTime),
-  endedAt: Schema7.optional(IsoDateTime),
-  durationMs: Schema7.optional(Schema7.Number),
-  isRunning: Schema7.optional(Schema7.Boolean)
+var RemoteIterationOutput = Schema6.Struct({
+  taskId: Schema6.optional(Schema6.String),
+  iteration: Schema6.optional(Schema6.Number),
+  output: Schema6.optional(Schema6.String),
+  startedAt: Schema6.optional(IsoDateTime),
+  endedAt: Schema6.optional(IsoDateTime),
+  durationMs: Schema6.optional(Schema6.Number),
+  isRunning: Schema6.optional(Schema6.Boolean)
 });
-var RemoteRunnerRegisterInput = Schema7.Struct({
+var RemoteRunnerRegisterInput = Schema6.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   name: TrimmedNonEmptyString,
   baseUrl: TrimmedNonEmptyString,
-  workspacePath: Schema7.optional(TrimmedNonEmptyString),
-  transport: Schema7.optional(TrimmedNonEmptyString),
-  hostname: Schema7.optional(TrimmedNonEmptyString),
-  region: Schema7.optional(TrimmedNonEmptyString),
-  labels: Schema7.optional(Schema7.Array(TrimmedNonEmptyString)),
-  capabilities: Schema7.optional(Schema7.Array(TrimmedNonEmptyString)),
-  runtimeAdapters: Schema7.optional(Schema7.Array(TrimmedNonEmptyString)),
-  status: Schema7.optional(WorkspaceRemoteHostStatus),
-  currentLeaseCount: Schema7.optional(Schema7.Number)
-});
-var RemoteRunnerHeartbeatInput = Schema7.Struct({
+  workspacePath: Schema6.optional(TrimmedNonEmptyString),
+  transport: Schema6.optional(TrimmedNonEmptyString),
+  hostname: Schema6.optional(TrimmedNonEmptyString),
+  region: Schema6.optional(TrimmedNonEmptyString),
+  labels: Schema6.optional(Schema6.Array(TrimmedNonEmptyString)),
+  capabilities: Schema6.optional(Schema6.Array(TrimmedNonEmptyString)),
+  runtimeAdapters: Schema6.optional(Schema6.Array(RemoteRuntimeAdapter)),
+  status: Schema6.optional(WorkspaceRemoteHostStatus),
+  currentLeaseCount: Schema6.optional(Schema6.Number)
+});
+var RemoteRunnerHeartbeatInput = Schema6.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   status: WorkspaceRemoteHostStatus,
-  currentLeaseCount: Schema7.optional(Schema7.Number),
-  observedAt: Schema7.optional(IsoDateTime)
+  currentLeaseCount: Schema6.optional(Schema6.Number),
+  observedAt: Schema6.optional(IsoDateTime)
 });
-var RemoteRunnerLifecycleResult = Schema7.Struct({
-  ok: Schema7.Boolean,
+var RemoteRunnerLifecycleResult = Schema6.Struct({
+  ok: Schema6.Boolean,
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   acceptedAt: IsoDateTime,
-  heartbeatIntervalMs: Schema7.Number
+  heartbeatIntervalMs: Schema6.Number
 });
-var RemoteRunClaimInput = Schema7.Struct({
+var RemoteRunClaimInput = Schema6.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
-  runtimeAdapters: Schema7.optional(Schema7.Array(TrimmedNonEmptyString))
+  runtimeAdapters: Schema6.optional(Schema6.Array(RemoteRuntimeAdapter))
 });
-var RemoteRunLeaseSummary = Schema7.Struct({
+var RemoteRunLeaseSummary = Schema6.Struct({
   leaseId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   workspaceId: WorkspaceId,
   title: TrimmedNonEmptyString,
-  runtimeAdapter: TrimmedNonEmptyString,
-  model: Schema7.NullOr(TrimmedNonEmptyString),
+  runtimeAdapter: RemoteRuntimeAdapter,
+  model: Schema6.NullOr(TrimmedNonEmptyString),
   runtimeMode: RuntimeMode,
   interactionMode: ProviderInteractionMode,
   executionTarget: RunExecutionTarget,
-  remoteHostId: Schema7.NullOr(TrimmedNonEmptyString),
+  remoteHostId: Schema6.NullOr(TrimmedNonEmptyString),
   claimedAt: IsoDateTime
 });
-var RemoteRunConversationEntry = Schema7.Struct({
-  role: Schema7.Literals(["user", "assistant", "system"]),
-  text: Schema7.String,
+var RemoteRunConversationEntry = Schema6.Struct({
+  role: Schema6.Literals(["user", "assistant", "system"]),
+  text: Schema6.String,
   createdAt: IsoDateTime
 });
-var RemoteRunExecutionBundle = Schema7.Struct({
+var RemoteRunExecutionBundle = Schema6.Struct({
   workspaceId: WorkspaceId,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString,
-  workspacePath: Schema7.NullOr(TrimmedNonEmptyString),
-  runtimeAdapter: TrimmedNonEmptyString,
-  model: Schema7.NullOr(TrimmedNonEmptyString),
+  workspacePath: Schema6.NullOr(TrimmedNonEmptyString),
+  runtimeAdapter: RemoteRuntimeAdapter,
+  model: Schema6.NullOr(TrimmedNonEmptyString),
   runtimeMode: RuntimeMode,
   interactionMode: ProviderInteractionMode,
-  prompt: Schema7.String,
-  conversation: Schema7.Array(RemoteRunConversationEntry),
-  taskId: Schema7.NullOr(TrimmedNonEmptyString),
-  taskTitle: Schema7.NullOr(TrimmedNonEmptyString)
+  prompt: Schema6.String,
+  conversation: Schema6.Array(RemoteRunConversationEntry),
+  taskId: Schema6.NullOr(TrimmedNonEmptyString),
+  taskTitle: Schema6.NullOr(TrimmedNonEmptyString)
 });
-var RemoteRunClaimResult = Schema7.Struct({
-  ok: Schema7.Boolean,
+var RemoteRunClaimResult = Schema6.Struct({
+  ok: Schema6.Boolean,
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   acceptedAt: IsoDateTime,
-  lease: Schema7.NullOr(RemoteRunLeaseSummary),
-  bundle: Schema7.NullOr(RemoteRunExecutionBundle)
+  lease: Schema6.NullOr(RemoteRunLeaseSummary),
+  bundle: Schema6.NullOr(RemoteRunExecutionBundle)
 });
-var RemoteRunReleaseInput = Schema7.Struct({
+var RemoteRunReleaseInput = Schema6.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString,
-  status: Schema7.optional(WorkspaceRemoteHostStatus)
+  status: Schema6.optional(WorkspaceRemoteHostStatus)
 });
-var RemoteRunReleaseResult = Schema7.Struct({
-  ok: Schema7.Boolean,
+var RemoteRunReleaseResult = Schema6.Struct({
+  ok: Schema6.Boolean,
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString,
   acceptedAt: IsoDateTime
 });
-var RemoteRunStartInput = Schema7.Struct({
+var RemoteRunStartInput = Schema6.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString
 });
-var RemoteRunStartResult = Schema7.Struct({
-  ok: Schema7.Boolean,
+var RemoteRunStartResult = Schema6.Struct({
+  ok: Schema6.Boolean,
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
@@ -1361,48 +522,48 @@ var RemoteRunStartResult = Schema7.Struct({
   runtimeId: TrimmedNonEmptyString,
   acceptedAt: IsoDateTime
 });
-var RemoteRunLogInput = Schema7.Struct({
+var RemoteRunLogInput = Schema6.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString,
   title: TrimmedNonEmptyString,
-  detail: Schema7.optional(Schema7.String),
-  tone: Schema7.optional(EngineLogTone),
-  status: Schema7.optional(TrimmedNonEmptyString),
-  payload: Schema7.optional(Schema7.Unknown)
+  detail: Schema6.optional(Schema6.String),
+  tone: Schema6.optional(EngineLogTone),
+  status: Schema6.optional(TrimmedNonEmptyString),
+  payload: Schema6.optional(Schema6.Unknown)
 });
-var RemoteRunMessageInput = Schema7.Struct({
+var RemoteRunMessageInput = Schema6.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString,
-  messageId: Schema7.optional(TrimmedNonEmptyString),
-  text: Schema7.String,
-  state: Schema7.optional(Schema7.Literals(["streaming", "completed"]))
+  messageId: Schema6.optional(TrimmedNonEmptyString),
+  text: Schema6.String,
+  state: Schema6.optional(Schema6.Literals(["streaming", "completed"]))
 });
-var RemoteRunMutationResult = Schema7.Struct({
-  ok: Schema7.Boolean,
+var RemoteRunMutationResult = Schema6.Struct({
+  ok: Schema6.Boolean,
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString,
   acceptedAt: IsoDateTime
 });
-var RemoteRunCompleteInput = Schema7.Struct({
+var RemoteRunCompleteInput = Schema6.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString
 });
-var RemoteRunFailInput = Schema7.Struct({
+var RemoteRunFailInput = Schema6.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString,
-  errorText: Schema7.optional(Schema7.String)
+  errorText: Schema6.optional(Schema6.String)
 });
-var RemoteRunArtifactInput = Schema7.Struct({
+var RemoteRunArtifactInput = Schema6.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
@@ -1413,8 +574,8 @@ var RemoteRunArtifactInput = Schema7.Struct({
   contentType: TrimmedNonEmptyString,
   contentBase64: TrimmedNonEmptyString
 });
-var RemoteRunArtifactResult = Schema7.Struct({
-  ok: Schema7.Boolean,
+var RemoteRunArtifactResult = Schema6.Struct({
+  ok: Schema6.Boolean,
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
@@ -1422,7 +583,7 @@ var RemoteRunArtifactResult = Schema7.Struct({
   acceptedAt: IsoDateTime,
   artifactPath: TrimmedNonEmptyString
 });
-var RemoteRunArtifactSummary = Schema7.Struct({
+var RemoteRunArtifactSummary = Schema6.Struct({
   workspaceId: WorkspaceId,
   runId: TrimmedNonEmptyString,
   hostId: TrimmedNonEmptyString,
@@ -1432,14 +593,14 @@ var RemoteRunArtifactSummary = Schema7.Struct({
   filename: TrimmedNonEmptyString,
   contentType: TrimmedNonEmptyString,
   uploadedAt: IsoDateTime,
-  byteSize: Schema7.Number,
+  byteSize: Schema6.Number,
   artifactPath: TrimmedNonEmptyString,
   downloadPath: TrimmedNonEmptyString
 });
-var RemoteRunArtifactsResult = Schema7.Struct({
+var RemoteRunArtifactsResult = Schema6.Struct({
   workspaceId: WorkspaceId,
   runId: TrimmedNonEmptyString,
-  artifacts: Schema7.Array(RemoteRunArtifactSummary)
+  artifacts: Schema6.Array(RemoteRunArtifactSummary)
 });
 export {
   RemoteRunnerRegisterInput,
@@ -1469,6 +630,5 @@ export {
   RemoteEndpoint,
   RemoteConnectionSummary,
   RemoteConnectionStatusChanged,
-  RemoteConnectionStatus,
-  EnrichedRemoteEvent
+  RemoteConnectionStatus
 };