@h-rig/contracts 0.0.0-e2e-live.20260630085347

package/dist/src/remote.js

@@ -0,0 +1,634 @@
+// @bun
+// packages/contracts/src/remote.ts
+import { Schema as Schema6 } 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/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/orchestration.ts
+import { Schema as Schema3 } from "effect";
+var ProviderKind = Schema3.Literals(["codex", "claude"]);
+var ProviderApprovalPolicy = Schema3.Literals([
+  "untrusted",
+  "on-failure",
+  "on-request",
+  "never"
+]);
+var ProviderSandboxMode = Schema3.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var ProviderServiceTier = Schema3.Literals(["fast", "flex"]);
+var 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 = Schema3.Record(Schema3.String, Schema3.Unknown);
+var PROVIDER_SEND_TURN_MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+var CHAT_ATTACHMENT_ID_MAX_CHARS = 128;
+var ChatAttachmentId = TrimmedNonEmptyString.check(Schema3.isMaxLength(CHAT_ATTACHMENT_ID_MAX_CHARS), Schema3.isPattern(/^[a-z0-9_-]+$/i));
+var ChatImageAttachment = Schema3.Struct({
+  type: Schema3.Literal("image"),
+  id: ChatAttachmentId,
+  name: TrimmedNonEmptyString.check(Schema3.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema3.isMaxLength(100), Schema3.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema3.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES))
+});
+var ChatAttachment = Schema3.Union([ChatImageAttachment]);
+
+// packages/contracts/src/runtime.ts
+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",
+  "stopped"
+]);
+var EngineSandboxMode = Schema4.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var IsolationMode = Schema4.Literals(["none", "env", "worktree"]);
+var RuntimeStatus = Schema4.Literals([
+  "prepared",
+  "starting",
+  "running",
+  "interrupted",
+  "exited",
+  "failed",
+  "destroyed"
+]);
+var RunExecutionTarget = Schema4.Literals(["local", "remote"]);
+var RunSummary = Schema4.Struct({
+  id: RunId,
+  workspaceId: WorkspaceId,
+  taskId: Schema4.NullOr(TaskId),
+  title: TrimmedNonEmptyString,
+  runKind: RunKind,
+  mode: RunMode,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  status: RunStatus,
+  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: Schema4.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema4.NullOr(TrimmedNonEmptyString),
+  errorText: Schema4.NullOr(Schema4.String),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  startedAt: Schema4.NullOr(IsoDateTime),
+  completedAt: Schema4.NullOr(IsoDateTime)
+});
+var RuntimeSummary = Schema4.Struct({
+  id: EngineRuntimeId,
+  workspaceId: WorkspaceId,
+  runId: RunId,
+  adapterKind: Schema4.Literal("pi"),
+  executionTarget: Schema4.optional(RunExecutionTarget),
+  remoteHostId: Schema4.optional(Schema4.NullOr(TrimmedNonEmptyString)),
+  status: RuntimeStatus,
+  sandboxMode: EngineSandboxMode,
+  isolationMode: IsolationMode,
+  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: Schema4.NullOr(IsoDateTime)
+});
+var ApprovalStatus = Schema4.Literals(["pending", "resolved"]);
+var ApprovalSummary = Schema4.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  actionId: Schema4.NullOr(TrimmedNonEmptyString),
+  requestKind: TrimmedNonEmptyString,
+  status: ApprovalStatus,
+  payload: Schema4.Unknown,
+  createdAt: IsoDateTime,
+  resolvedAt: Schema4.NullOr(IsoDateTime)
+});
+var UserInputRequestSummary = Schema4.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  status: ApprovalStatus,
+  payload: Schema4.Unknown,
+  createdAt: IsoDateTime,
+  resolvedAt: Schema4.NullOr(IsoDateTime)
+});
+var WorktreeSummary = Schema4.Struct({
+  id: WorktreeId,
+  workspaceId: WorkspaceId,
+  runId: RunId,
+  taskId: Schema4.NullOr(TaskId),
+  branchName: TrimmedNonEmptyString,
+  path: TrimmedNonEmptyString,
+  status: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  cleanedAt: Schema4.NullOr(IsoDateTime)
+});
+
+// packages/contracts/src/workspace.ts
+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 = Schema5.Literals([
+  "registering",
+  "ready",
+  "busy",
+  "degraded",
+  "draining",
+  "offline",
+  "quarantined"
+]);
+var WorkspaceTopologyServiceSummary = Schema5.Struct({
+  name: TrimmedNonEmptyString,
+  relativeRootPath: TrimmedNonEmptyString,
+  runtime: TrimmedNonEmptyString,
+  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: Schema5.Number,
+  serviceCount: Schema5.Number,
+  services: Schema5.Array(WorkspaceTopologyServiceSummary),
+  warnings: Schema5.Array(Schema5.String)
+});
+var WorkspaceRemoteHostSummary = Schema5.Struct({
+  id: TrimmedNonEmptyString,
+  name: TrimmedNonEmptyString,
+  baseUrl: TrimmedNonEmptyString,
+  workspacePath: Schema5.NullOr(TrimmedNonEmptyString),
+  transport: 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: Schema5.Number,
+  lastHeartbeatAt: Schema5.NullOr(IsoDateTime),
+  registeredAt: IsoDateTime,
+  manifestPath: TrimmedNonEmptyString
+});
+var WorkspaceRemoteFleetSummary = Schema5.Struct({
+  updatedAt: IsoDateTime,
+  status: WorkspaceRemoteFleetStatus,
+  manifestCount: Schema5.Number,
+  hostCount: Schema5.Number,
+  onlineHostCount: Schema5.Number,
+  hosts: Schema5.Array(WorkspaceRemoteHostSummary),
+  warnings: Schema5.Array(Schema5.String)
+});
+var WorkspaceServiceFabricServiceSummary = Schema5.Struct({
+  name: TrimmedNonEmptyString,
+  relativeRootPath: TrimmedNonEmptyString,
+  mode: Schema5.Literals(["stub", "process"]),
+  port: Schema5.Number,
+  healthcheck: 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 = Schema5.Struct({
+  updatedAt: IsoDateTime,
+  status: WorkspaceServiceFabricStatus,
+  serviceCount: Schema5.Number,
+  healthyServiceCount: Schema5.Number,
+  stateDir: TrimmedNonEmptyString,
+  services: Schema5.Array(WorkspaceServiceFabricServiceSummary),
+  warnings: Schema5.Array(Schema5.String)
+});
+var WorkspaceSummary = Schema5.Struct({
+  id: WorkspaceId,
+  title: TrimmedNonEmptyString,
+  rootPath: TrimmedNonEmptyString,
+  sourceKind: WorkspaceSourceKind,
+  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 RemoteRuntimeAdapter = Schema6.Literal("pi");
+var RemoteEndpoint = Schema6.Struct({
+  id: RemoteEndpointId,
+  alias: TrimmedNonEmptyString,
+  host: TrimmedNonEmptyString,
+  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: Schema6.NullOr(IsoDateTime)
+});
+var RemoteConnectionStatus = Schema6.Literals([
+  "disconnected",
+  "connecting",
+  "authenticating",
+  "connected",
+  "reconnecting",
+  "error"
+]);
+var RemoteConnectionSummary = Schema6.Struct({
+  endpointId: RemoteEndpointId,
+  status: RemoteConnectionStatus,
+  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: 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: Schema6.NullOr(IsoDateTime)
+});
+var RemoteOrchestrationSummary = Schema6.Struct({
+  orchestrationId: TrimmedNonEmptyString,
+  endpointId: RemoteEndpointId,
+  status: Schema6.Literals(["running", "paused", "stopped", "completed"]),
+  totalTasks: NonNegativeInt,
+  totalGroups: NonNegativeInt,
+  maxParallelism: NonNegativeInt,
+  startedAt: IsoDateTime
+});
+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 = Schema6.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  name: TrimmedNonEmptyString,
+  baseUrl: TrimmedNonEmptyString,
+  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: Schema6.optional(Schema6.Number),
+  observedAt: Schema6.optional(IsoDateTime)
+});
+var RemoteRunnerLifecycleResult = Schema6.Struct({
+  ok: Schema6.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime,
+  heartbeatIntervalMs: Schema6.Number
+});
+var RemoteRunClaimInput = Schema6.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runtimeAdapters: Schema6.optional(Schema6.Array(RemoteRuntimeAdapter))
+});
+var RemoteRunLeaseSummary = Schema6.Struct({
+  leaseId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  workspaceId: WorkspaceId,
+  title: TrimmedNonEmptyString,
+  runtimeAdapter: RemoteRuntimeAdapter,
+  model: Schema6.NullOr(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  executionTarget: RunExecutionTarget,
+  remoteHostId: Schema6.NullOr(TrimmedNonEmptyString),
+  claimedAt: IsoDateTime
+});
+var RemoteRunConversationEntry = Schema6.Struct({
+  role: Schema6.Literals(["user", "assistant", "system"]),
+  text: Schema6.String,
+  createdAt: IsoDateTime
+});
+var RemoteRunExecutionBundle = Schema6.Struct({
+  workspaceId: WorkspaceId,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  workspacePath: Schema6.NullOr(TrimmedNonEmptyString),
+  runtimeAdapter: RemoteRuntimeAdapter,
+  model: Schema6.NullOr(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  prompt: Schema6.String,
+  conversation: Schema6.Array(RemoteRunConversationEntry),
+  taskId: Schema6.NullOr(TrimmedNonEmptyString),
+  taskTitle: Schema6.NullOr(TrimmedNonEmptyString)
+});
+var RemoteRunClaimResult = Schema6.Struct({
+  ok: Schema6.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime,
+  lease: Schema6.NullOr(RemoteRunLeaseSummary),
+  bundle: Schema6.NullOr(RemoteRunExecutionBundle)
+});
+var RemoteRunReleaseInput = Schema6.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  status: Schema6.optional(WorkspaceRemoteHostStatus)
+});
+var RemoteRunReleaseResult = Schema6.Struct({
+  ok: Schema6.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime
+});
+var RemoteRunStartInput = Schema6.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString
+});
+var RemoteRunStartResult = Schema6.Struct({
+  ok: Schema6.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  runtimeId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime
+});
+var RemoteRunLogInput = Schema6.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  title: TrimmedNonEmptyString,
+  detail: Schema6.optional(Schema6.String),
+  tone: Schema6.optional(EngineLogTone),
+  status: Schema6.optional(TrimmedNonEmptyString),
+  payload: Schema6.optional(Schema6.Unknown)
+});
+var RemoteRunMessageInput = Schema6.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  messageId: Schema6.optional(TrimmedNonEmptyString),
+  text: Schema6.String,
+  state: Schema6.optional(Schema6.Literals(["streaming", "completed"]))
+});
+var RemoteRunMutationResult = Schema6.Struct({
+  ok: Schema6.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime
+});
+var RemoteRunCompleteInput = Schema6.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString
+});
+var RemoteRunFailInput = Schema6.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  errorText: Schema6.optional(Schema6.String)
+});
+var RemoteRunArtifactInput = Schema6.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  kind: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  filename: TrimmedNonEmptyString,
+  contentType: TrimmedNonEmptyString,
+  contentBase64: TrimmedNonEmptyString
+});
+var RemoteRunArtifactResult = Schema6.Struct({
+  ok: Schema6.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime,
+  artifactPath: TrimmedNonEmptyString
+});
+var RemoteRunArtifactSummary = Schema6.Struct({
+  workspaceId: WorkspaceId,
+  runId: TrimmedNonEmptyString,
+  hostId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  kind: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  filename: TrimmedNonEmptyString,
+  contentType: TrimmedNonEmptyString,
+  uploadedAt: IsoDateTime,
+  byteSize: Schema6.Number,
+  artifactPath: TrimmedNonEmptyString,
+  downloadPath: TrimmedNonEmptyString
+});
+var RemoteRunArtifactsResult = Schema6.Struct({
+  workspaceId: WorkspaceId,
+  runId: TrimmedNonEmptyString,
+  artifacts: Schema6.Array(RemoteRunArtifactSummary)
+});
+export {
+  RemoteRunnerRegisterInput,
+  RemoteRunnerLifecycleResult,
+  RemoteRunnerHeartbeatInput,
+  RemoteRunStartResult,
+  RemoteRunStartInput,
+  RemoteRunReleaseResult,
+  RemoteRunReleaseInput,
+  RemoteRunMutationResult,
+  RemoteRunMessageInput,
+  RemoteRunLogInput,
+  RemoteRunLeaseSummary,
+  RemoteRunFailInput,
+  RemoteRunExecutionBundle,
+  RemoteRunConversationEntry,
+  RemoteRunCompleteInput,
+  RemoteRunClaimResult,
+  RemoteRunClaimInput,
+  RemoteRunArtifactsResult,
+  RemoteRunArtifactSummary,
+  RemoteRunArtifactResult,
+  RemoteRunArtifactInput,
+  RemoteOrchestratorState,
+  RemoteOrchestrationSummary,
+  RemoteIterationOutput,
+  RemoteEndpoint,
+  RemoteConnectionSummary,
+  RemoteConnectionStatusChanged,
+  RemoteConnectionStatus
+};

package/dist/src/review.d.ts

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+export declare const ReviewMode: Schema.Literals<readonly ["off", "advisory", "required"]>;
+export type ReviewMode = typeof ReviewMode.Type;
+export declare const ReviewStatus: Schema.Literals<readonly ["pending", "running", "approved", "rejected", "error"]>;
+export type ReviewStatus = typeof ReviewStatus.Type;
+export declare const ReviewSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "ReviewResultId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly provider: Schema.Trim;
+    readonly mode: Schema.Literals<readonly ["off", "advisory", "required"]>;
+    readonly status: Schema.Literals<readonly ["pending", "running", "approved", "rejected", "error"]>;
+    readonly summary: Schema.NullOr<Schema.String>;
+    readonly output: Schema.Unknown;
+    readonly createdAt: Schema.String;
+    readonly completedAt: Schema.NullOr<Schema.String>;
+}>;
+export type ReviewSummary = typeof ReviewSummary.Type;