@h-rig/contracts 0.0.6-alpha.16 → 0.0.6-alpha.161

package/dist/index.cjs

@@ -0,0 +1,3280 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// packages/contracts/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  makeCapabilityId: () => makeCapabilityId,
+  WrapStageMutation: () => WrapStageMutation,
+  WorktreeSummary: () => WorktreeSummary,
+  WorktreeId: () => WorktreeId,
+  WorkspaceTopologySummary: () => WorkspaceTopologySummary,
+  WorkspaceTopologyStatus: () => WorkspaceTopologyStatus,
+  WorkspaceTopologyServiceSummary: () => WorkspaceTopologyServiceSummary,
+  WorkspaceSummary: () => WorkspaceSummary,
+  WorkspaceSourceKind: () => WorkspaceSourceKind,
+  WorkspaceServiceFabricSummary: () => WorkspaceServiceFabricSummary,
+  WorkspaceServiceFabricStatus: () => WorkspaceServiceFabricStatus,
+  WorkspaceServiceFabricServiceSummary: () => WorkspaceServiceFabricServiceSummary,
+  WorkspaceSandbox: () => WorkspaceSandbox,
+  WorkspaceRollups: () => WorkspaceRollups,
+  WorkspaceRemoteHostSummary: () => WorkspaceRemoteHostSummary,
+  WorkspaceRemoteHostStatus: () => WorkspaceRemoteHostStatus,
+  WorkspaceRemoteFleetSummary: () => WorkspaceRemoteFleetSummary,
+  WorkspaceRemoteFleetStatus: () => WorkspaceRemoteFleetStatus,
+  WorkspaceIsolation: () => WorkspaceIsolation,
+  WorkspaceId: () => WorkspaceId,
+  WorkspaceConfig: () => WorkspaceConfig,
+  WorkspaceCheckout: () => WorkspaceCheckout,
+  WORKSPACE_CONFIG_ENSURE_CAPABILITY_ID: () => WORKSPACE_CONFIG_ENSURE_CAPABILITY_ID,
+  WORKSPACE_CONFIG_ENSURE: () => WORKSPACE_CONFIG_ENSURE,
+  ValidatorRegistration: () => ValidatorRegistration,
+  ValidatorCategory: () => ValidatorCategory,
+  ValidationSummary: () => ValidationSummary,
+  ValidationStatus: () => ValidationStatus,
+  ValidationResultId: () => ValidationResultId,
+  UserStory: () => UserStory,
+  UserInputRequestSummary: () => UserInputRequestSummary,
+  TurnId: () => TurnId,
+  TrimmedString: () => TrimmedString,
+  TrimmedNonEmptyString: () => TrimmedNonEmptyString,
+  ThreadId: () => ThreadId,
+  TerminalWriteInput: () => TerminalWriteInput,
+  TerminalThreadInput: () => TerminalThreadInput,
+  TerminalSessionStatus: () => TerminalSessionStatus,
+  TerminalSessionSnapshot: () => TerminalSessionSnapshot,
+  TerminalRestartInput: () => TerminalRestartInput,
+  TerminalResizeInput: () => TerminalResizeInput,
+  TerminalOpenInput: () => TerminalOpenInput,
+  TerminalEvent: () => TerminalEvent,
+  TerminalCloseInput: () => TerminalCloseInput,
+  TerminalClearInput: () => TerminalClearInput,
+  TaskSummary: () => TaskSummary,
+  TaskStatus: () => TaskStatus,
+  TaskSourceRegistration: () => TaskSourceRegistration,
+  TaskSourceKind: () => TaskSourceKind,
+  TaskSourceConfig: () => TaskSourceConfig,
+  TaskId: () => TaskId,
+  TaskGraphStage: () => TaskGraphStage,
+  TaskGraphNode: () => TaskGraphNode,
+  TaskGraphLayout: () => TaskGraphLayout,
+  TaskGraphLane: () => TaskGraphLane,
+  TaskGraphEdge: () => TaskGraphEdge,
+  TaskFieldExtension: () => TaskFieldExtension,
+  TaskClosureSummary: () => TaskClosureSummary,
+  TYPE_FOR_CUSTOM: () => TYPE_FOR_CUSTOM,
+  TOOL_MATERIALIZER_CAPABILITY_ID: () => TOOL_MATERIALIZER_CAPABILITY_ID,
+  TOOL_MATERIALIZER: () => TOOL_MATERIALIZER,
+  TASK_VERIFY_CAPABILITY_ID: () => TASK_VERIFY_CAPABILITY_ID,
+  TASK_VERIFY_CAPABILITY: () => TASK_VERIFY_CAPABILITY,
+  TASK_SELECTION_CAPABILITY_ID: () => TASK_SELECTION_CAPABILITY_ID,
+  TASK_SELECTION: () => TASK_SELECTION,
+  TASK_IO_SERVICE_CAPABILITY_ID: () => TASK_IO_SERVICE_CAPABILITY_ID,
+  TASK_IO_SERVICE_CAPABILITY: () => TASK_IO_SERVICE_CAPABILITY,
+  TASK_DATA_SERVICE_CAPABILITY_ID: () => TASK_DATA_SERVICE_CAPABILITY_ID,
+  TASK_DATA_SERVICE_CAPABILITY: () => TASK_DATA_SERVICE_CAPABILITY,
+  SupervisorStoppedEvent: () => SupervisorStoppedEvent,
+  SupervisorStopReason: () => SupervisorStopReason,
+  SupervisorStatus: () => SupervisorStatus,
+  SupervisorStartedEvent: () => SupervisorStartedEvent,
+  SupervisorSkippedEvent: () => SupervisorSkippedEvent,
+  SupervisorSelectionPolicy: () => SupervisorSelectionPolicy,
+  SupervisorSelectionPlannedEvent: () => SupervisorSelectionPlannedEvent,
+  SupervisorProjection: () => SupervisorProjection,
+  SupervisorOutcomeEvent: () => SupervisorOutcomeEvent,
+  SupervisorIdleEvent: () => SupervisorIdleEvent,
+  SupervisorFinishedEvent: () => SupervisorFinishedEvent,
+  SupervisorEvent: () => SupervisorEvent,
+  SupervisorDispatchStartedEvent: () => SupervisorDispatchStartedEvent,
+  SupervisorDispatchEvent: () => SupervisorDispatchEvent,
+  SupervisorDispatchConfirmedEvent: () => SupervisorDispatchConfirmedEvent,
+  StageWrapperDescriptor: () => StageWrapperDescriptor,
+  StageRunOutcome: () => StageRunOutcome,
+  StageResult: () => StageResult,
+  StageMutationOp: () => StageMutationOp,
+  StageMutation: () => StageMutation,
+  StageKind: () => StageKind,
+  StageId: () => StageId,
+  StageDescriptor: () => StageDescriptor,
+  StageContinueResult: () => StageContinueResult,
+  StageContext: () => StageContext,
+  StageBlockResult: () => StageBlockResult,
+  StageAllowResult: () => StageAllowResult,
+  Stage: () => Stage,
+  SkillRegistration: () => SkillRegistration,
+  SessionExtensionRegistration: () => SessionExtensionRegistration,
+  SeedEntrypointRegistration: () => SeedEntrypointRegistration,
+  ScopeSearchPrefix: () => ScopeSearchPrefix,
+  ScopeNormalizationRules: () => ScopeNormalizationRules,
+  Schema: () => import_effect30.Schema,
+  SafeRunId: () => SafeRunId,
+  SafePathSegment: () => SafePathSegment,
+  SafeGitRefComponent: () => SafeGitRefComponent,
+  SESSION_ASSET_MATERIALIZER_CAPABILITY_ID: () => SESSION_ASSET_MATERIALIZER_CAPABILITY_ID,
+  SESSION_ASSET_MATERIALIZER: () => SESSION_ASSET_MATERIALIZER,
+  SCRIPT_RUN_COMMAND_PATTERN: () => SCRIPT_RUN_COMMAND_PATTERN,
+  RuntimeTaskId: () => RuntimeTaskId,
+  RuntimeSupervisorConfig: () => RuntimeSupervisorConfig,
+  RuntimeSummary: () => RuntimeSummary,
+  RuntimeStatus: () => RuntimeStatus,
+  RuntimeSessionId: () => RuntimeSessionId,
+  RuntimeRequestId: () => RuntimeRequestId,
+  RuntimePlanningConfig: () => RuntimePlanningConfig,
+  RuntimeMode: () => RuntimeMode,
+  RuntimeItemId: () => RuntimeItemId,
+  RuntimeHarness: () => RuntimeHarness,
+  RuntimeDriftConfig: () => RuntimeDriftConfig,
+  RuntimeConfig: () => RuntimeConfig,
+  RunTimelineEntryEvent: () => RunTimelineEntryEvent,
+  RunSummary: () => RunSummary,
+  RunSteeringEvent: () => RunSteeringEvent,
+  RunStatusChangedEvent: () => RunStatusChangedEvent,
+  RunStatus: () => RunStatus,
+  RunStallDetectedEvent: () => RunStallDetectedEvent,
+  RunStageOutcomeEvent: () => RunStageOutcomeEvent,
+  RunRecordPatchEvent: () => RunRecordPatchEvent,
+  RunRecordPatch: () => RunRecordPatch,
+  RunPipelineResolvedEvent: () => RunPipelineResolvedEvent,
+  RunMode: () => RunMode,
+  RunLogEntryEvent: () => RunLogEntryEvent,
+  RunKind: () => RunKind,
+  RunJournalRecord: () => RunJournalRecord,
+  RunJournalEvent: () => RunJournalEvent,
+  RunInputResolvedEvent: () => RunInputResolvedEvent,
+  RunInputRequestedEvent: () => RunInputRequestedEvent,
+  RunId: () => RunId,
+  RunExecutionTarget: () => RunExecutionTarget,
+  RunCloseoutStatus: () => RunCloseoutStatus,
+  RunCloseoutState: () => RunCloseoutState,
+  RunCloseoutPhaseOutcome: () => RunCloseoutPhaseOutcome,
+  RunCloseoutPhaseEvent: () => RunCloseoutPhaseEvent,
+  RunCloseoutPhase: () => RunCloseoutPhase,
+  RunApprovalResolvedEvent: () => RunApprovalResolvedEvent,
+  RunApprovalRequestedEvent: () => RunApprovalRequestedEvent,
+  RunAdoptedEvent: () => RunAdoptedEvent,
+  RunActor: () => RunActor,
+  RigTaskShowOutput: () => RigTaskShowOutput,
+  RigTaskListOutput: () => RigTaskListOutput,
+  RigStatsOutput: () => RigStatsOutput,
+  RigStatsData: () => RigStatsData,
+  RigServerUseOutput: () => RigServerUseOutput,
+  RigServerStatusOutput: () => RigServerStatusOutput,
+  RigServerRepairLinkOutput: () => RigServerRepairLinkOutput,
+  RigServerConfig: () => RigServerConfig,
+  RigRuntimeMode: () => RigRuntimeMode,
+  RigRunShowOutput: () => RigRunShowOutput,
+  RigRunListOutput: () => RigRunListOutput,
+  RigPlugin: () => RigPlugin,
+  RigInboxInputsOutput: () => RigInboxInputsOutput,
+  RigInboxApprovalsOutput: () => RigInboxApprovalsOutput,
+  RigDoctorCheckOutput: () => RigDoctorCheckOutput,
+  RigConfig: () => RigConfig,
+  RigCliOutputEnvelope: () => RigCliOutputEnvelope,
+  ReviewSummary: () => ReviewSummary,
+  ReviewStatus: () => ReviewStatus,
+  ReviewResultId: () => ReviewResultId,
+  ReviewMode: () => ReviewMode,
+  ReviewConfig: () => ReviewConfig,
+  ResolvedPipeline: () => ResolvedPipeline,
+  ResolvedKeybindingsConfig: () => ResolvedKeybindingsConfig,
+  ResolvedKeybindingRule: () => ResolvedKeybindingRule,
+  ResolutionRecordEntry: () => ResolutionRecordEntry,
+  ResolutionRecord: () => ResolutionRecord,
+  ResolutionGrantUse: () => ResolutionGrantUse,
+  RepoSourceRegistration: () => RepoSourceRegistration,
+  ReplaceStageMutation: () => ReplaceStageMutation,
+  ReorderStageMutation: () => ReorderStageMutation,
+  RemoveStageMutation: () => RemoveStageMutation,
+  RemoteRunnerRegisterInput: () => RemoteRunnerRegisterInput,
+  RemoteRunnerLifecycleResult: () => RemoteRunnerLifecycleResult,
+  RemoteRunnerHeartbeatInput: () => RemoteRunnerHeartbeatInput,
+  RemoteRunStartResult: () => RemoteRunStartResult,
+  RemoteRunStartInput: () => RemoteRunStartInput,
+  RemoteRunReleaseResult: () => RemoteRunReleaseResult,
+  RemoteRunReleaseInput: () => RemoteRunReleaseInput,
+  RemoteRunMutationResult: () => RemoteRunMutationResult,
+  RemoteRunMessageInput: () => RemoteRunMessageInput,
+  RemoteRunLogInput: () => RemoteRunLogInput,
+  RemoteRunLeaseSummary: () => RemoteRunLeaseSummary,
+  RemoteRunFailInput: () => RemoteRunFailInput,
+  RemoteRunExecutionBundle: () => RemoteRunExecutionBundle,
+  RemoteRunConversationEntry: () => RemoteRunConversationEntry,
+  RemoteRunCompleteInput: () => RemoteRunCompleteInput,
+  RemoteRunClaimResult: () => RemoteRunClaimResult,
+  RemoteRunClaimInput: () => RemoteRunClaimInput,
+  RemoteRunArtifactsResult: () => RemoteRunArtifactsResult,
+  RemoteRunArtifactSummary: () => RemoteRunArtifactSummary,
+  RemoteRunArtifactResult: () => RemoteRunArtifactResult,
+  RemoteRunArtifactInput: () => RemoteRunArtifactInput,
+  RemoteOrchestratorState: () => RemoteOrchestratorState,
+  RemoteOrchestrationSummary: () => RemoteOrchestrationSummary,
+  RemoteIterationOutput: () => RemoteIterationOutput,
+  RemoteEndpointId: () => RemoteEndpointId,
+  RemoteEndpoint: () => RemoteEndpoint,
+  RemoteConnectionSummary: () => RemoteConnectionSummary,
+  RemoteConnectionStatusChanged: () => RemoteConnectionStatusChanged,
+  RemoteConnectionStatus: () => RemoteConnectionStatus,
+  RUN_REGISTRY_BACKBONE_CAPABILITY_ID: () => RUN_REGISTRY_BACKBONE_CAPABILITY_ID,
+  RUN_REGISTRY_BACKBONE: () => RUN_REGISTRY_BACKBONE,
+  RUN_READ_MODEL_CAPABILITY_ID: () => RUN_READ_MODEL_CAPABILITY_ID,
+  RUN_READ_MODEL: () => RUN_READ_MODEL,
+  RUN_IDENTITY_ENV_CAPABILITY_ID: () => RUN_IDENTITY_ENV_CAPABILITY_ID,
+  RUN_IDENTITY_ENV: () => RUN_IDENTITY_ENV,
+  RUN_DISPATCH_CAPABILITY_ID: () => RUN_DISPATCH_CAPABILITY_ID,
+  RUN_DISPATCH: () => RUN_DISPATCH,
+  RUN_DISCOVERY_CAPABILITY_ID: () => RUN_DISCOVERY_CAPABILITY_ID,
+  RUN_DISCOVERY: () => RUN_DISCOVERY,
+  RUN_CLOSEOUT_CAPABILITY_ID: () => RUN_CLOSEOUT_CAPABILITY_ID,
+  RUN_CLOSEOUT_CAPABILITY: () => RUN_CLOSEOUT_CAPABILITY,
+  RUNTIME_SHELL_TOOL_NAMES: () => RUNTIME_SHELL_TOOL_NAMES,
+  RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID: () => RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID,
+  RUNTIME_INSTRUCTION: () => RUNTIME_INSTRUCTION,
+  RUNTIME_FILE_TOOL_NAMES: () => RUNTIME_FILE_TOOL_NAMES,
+  RUNTIME_BROWSER_TOOL_NAMES: () => RUNTIME_BROWSER_TOOL_NAMES,
+  RIG_WORKFLOW_TASK_SELECTED: () => RIG_WORKFLOW_TASK_SELECTED,
+  RIG_WORKFLOW_TARGET_SELECTED: () => RIG_WORKFLOW_TARGET_SELECTED,
+  RIG_WORKFLOW_STATUS_CHANGED: () => RIG_WORKFLOW_STATUS_CHANGED,
+  RIG_WORKFLOW_STARTED: () => RIG_WORKFLOW_STARTED,
+  RIG_WORKFLOW_OPERATOR_NOTE: () => RIG_WORKFLOW_OPERATOR_NOTE,
+  RIG_WORKFLOW_INBOX_RESOLVED: () => RIG_WORKFLOW_INBOX_RESOLVED,
+  RIG_WORKFLOW_INBOX_REQUESTED: () => RIG_WORKFLOW_INBOX_REQUESTED,
+  RIG_SUPERVISOR_PANEL_ID: () => RIG_SUPERVISOR_PANEL_ID,
+  RIG_STOP_SENTINEL_END: () => RIG_STOP_SENTINEL_END,
+  RIG_STOP_SENTINEL: () => RIG_STOP_SENTINEL,
+  RIG_STATE_DIRNAME: () => RIG_STATE_DIRNAME,
+  RIG_RUN_TIMELINE_ENTRY: () => RIG_RUN_TIMELINE_ENTRY,
+  RIG_RUN_STOP_PANEL_ACTION: () => RIG_RUN_STOP_PANEL_ACTION,
+  RIG_RUN_STEERING: () => RIG_RUN_STEERING,
+  RIG_RUN_STATUS_CHANGED: () => RIG_RUN_STATUS_CHANGED,
+  RIG_RUN_STALL_DETECTED: () => RIG_RUN_STALL_DETECTED,
+  RIG_RUN_STAGE_OUTCOME: () => RIG_RUN_STAGE_OUTCOME,
+  RIG_RUN_RECORD_PATCH: () => RIG_RUN_RECORD_PATCH,
+  RIG_RUN_PIPELINE_RESOLVED: () => RIG_RUN_PIPELINE_RESOLVED,
+  RIG_RUN_LOG_ENTRY: () => RIG_RUN_LOG_ENTRY,
+  RIG_RUN_INPUT_RESOLVED: () => RIG_RUN_INPUT_RESOLVED,
+  RIG_RUN_INPUT_REQUESTED: () => RIG_RUN_INPUT_REQUESTED,
+  RIG_RUN_CLOSEOUT_PHASE: () => RIG_RUN_CLOSEOUT_PHASE,
+  RIG_RUN_APPROVAL_RESOLVED: () => RIG_RUN_APPROVAL_RESOLVED,
+  RIG_RUN_APPROVAL_REQUESTED: () => RIG_RUN_APPROVAL_REQUESTED,
+  RIG_RUN_ADOPTED: () => RIG_RUN_ADOPTED,
+  RIG_RESUME_SENTINEL: () => RIG_RESUME_SENTINEL,
+  RIG_PROTOCOL_VERSION: () => RIG_PROTOCOL_VERSION,
+  RIG_PAUSE_SENTINEL: () => RIG_PAUSE_SENTINEL,
+  RIG_INBOX_RESOLUTION_SENTINEL: () => RIG_INBOX_RESOLUTION_SENTINEL,
+  RIG_DEFINITION_DIRNAME: () => RIG_DEFINITION_DIRNAME,
+  RIG_CONTROL_SENTINEL_END: () => RIG_CONTROL_SENTINEL_END,
+  RIG_CAPABILITY_PANEL_SLOT: () => RIG_CAPABILITY_PANEL_SLOT,
+  RIG_ARTIFACTS_DIRNAME: () => RIG_ARTIFACTS_DIRNAME,
+  REPO_OPERATIONS_CAPABILITY_ID: () => REPO_OPERATIONS_CAPABILITY_ID,
+  REPO_OPERATIONS_CAPABILITY: () => REPO_OPERATIONS_CAPABILITY,
+  REASONING_EFFORT_OPTIONS_BY_PROVIDER: () => REASONING_EFFORT_OPTIONS_BY_PROVIDER,
+  QueueEntry: () => QueueEntry,
+  PullRequestConfig: () => PullRequestConfig,
+  ProviderUserInputAnswers: () => ProviderUserInputAnswers,
+  ProviderTurnStartResult: () => ProviderTurnStartResult,
+  ProviderStopSessionInput: () => ProviderStopSessionInput,
+  ProviderSessionStartInput: () => ProviderSessionStartInput,
+  ProviderSession: () => ProviderSession,
+  ProviderServiceTier: () => ProviderServiceTier,
+  ProviderSendTurnInput: () => ProviderSendTurnInput,
+  ProviderSandboxMode: () => ProviderSandboxMode,
+  ProviderRespondToUserInputInput: () => ProviderRespondToUserInputInput,
+  ProviderRespondToRequestInput: () => ProviderRespondToRequestInput,
+  ProviderRequestKind: () => ProviderRequestKind,
+  ProviderModelOptions: () => ProviderModelOptions,
+  ProviderKind: () => ProviderKind,
+  ProviderItemId: () => ProviderItemId,
+  ProviderInterruptTurnInput: () => ProviderInterruptTurnInput,
+  ProviderInteractionMode: () => ProviderInteractionMode,
+  ProviderEvent: () => ProviderEvent,
+  ProviderApprovalPolicy: () => ProviderApprovalPolicy,
+  ProviderApprovalDecision: () => ProviderApprovalDecision,
+  ProjectWriteFileResult: () => ProjectWriteFileResult,
+  ProjectWriteFileInput: () => ProjectWriteFileInput,
+  ProjectSearchEntriesResult: () => ProjectSearchEntriesResult,
+  ProjectSearchEntriesInput: () => ProjectSearchEntriesInput,
+  ProjectReadFileResult: () => ProjectReadFileResult,
+  ProjectReadFileInput: () => ProjectReadFileInput,
+  ProjectListDirectoryResult: () => ProjectListDirectoryResult,
+  ProjectListDirectoryInput: () => ProjectListDirectoryInput,
+  ProjectIdentity: () => ProjectIdentity,
+  ProjectId: () => ProjectId,
+  ProjectEntry: () => ProjectEntry,
+  ProjectDirectoryEntry: () => ProjectDirectoryEntry,
+  ProductCapabilityRegistration: () => ProductCapabilityRegistration,
+  PositiveInt: () => PositiveInt,
+  PolicyMode: () => PolicyMode,
+  PolicyDecisionSummary: () => PolicyDecisionSummary,
+  PolicyDecision: () => PolicyDecision,
+  PluginContributes: () => PluginContributes,
+  PlanningConfig: () => PlanningConfig,
+  PlanTask: () => PlanTask,
+  PlanSpec: () => PlanSpec,
+  PipelineUnresolvable: () => PipelineUnresolvable,
+  PiRuntimeConfig: () => PiRuntimeConfig,
+  PercentComplete: () => PercentComplete,
+  PanelRegistration: () => PanelRegistration,
+  PR_MERGE_GATE_CAPABILITY_ID: () => PR_MERGE_GATE_CAPABILITY_ID,
+  PR_MERGE_GATE: () => PR_MERGE_GATE,
+  PROVIDER_SEND_TURN_MAX_INPUT_CHARS: () => PROVIDER_SEND_TURN_MAX_INPUT_CHARS,
+  PROVIDER_SEND_TURN_MAX_IMAGE_BYTES: () => PROVIDER_SEND_TURN_MAX_IMAGE_BYTES,
+  PROVIDER_SEND_TURN_MAX_ATTACHMENTS: () => PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
+  PROJECT_SETUP_CAPABILITY_ID: () => PROJECT_SETUP_CAPABILITY_ID,
+  PROJECT_SETUP: () => PROJECT_SETUP,
+  PROJECT_READ_FILE_MAX_BYTES_VALUE: () => PROJECT_READ_FILE_MAX_BYTES_VALUE,
+  PRIOR_PROGRESS_PROMPT_CAPABILITY_ID: () => PRIOR_PROGRESS_PROMPT_CAPABILITY_ID,
+  PRIOR_PROGRESS_PROMPT: () => PRIOR_PROGRESS_PROMPT,
+  POLICY_VERSION: () => POLICY_VERSION,
+  PLACEMENT_RUN_TRANSPORT: () => PLACEMENT_RUN_TRANSPORT,
+  OpenQuestion: () => OpenQuestion,
+  OpenInEditorInput: () => OpenInEditorInput,
+  OPERATOR_INACTIVE_RUN_STATUSES: () => OPERATOR_INACTIVE_RUN_STATUSES,
+  NonNegativeInt: () => NonNegativeInt,
+  NO_MATCH_RETRIEVAL_CANONICAL_KEY: () => NO_MATCH_RETRIEVAL_CANONICAL_KEY,
+  NOTIFY_SERVICE_CAPABILITY_ID: () => NOTIFY_SERVICE_CAPABILITY_ID,
+  NOTIFY_SERVICE_CAPABILITY: () => NOTIFY_SERVICE_CAPABILITY,
+  MissingCapability: () => MissingCapability,
+  MessageId: () => MessageId,
+  MergeConfig: () => MergeConfig,
+  MODEL_SLUG_ALIASES_BY_PROVIDER: () => MODEL_SLUG_ALIASES_BY_PROVIDER,
+  MODEL_OPTIONS_BY_PROVIDER: () => MODEL_OPTIONS_BY_PROVIDER,
+  MEMORY_SERVICE_CAPABILITY_ID: () => MEMORY_SERVICE_CAPABILITY_ID,
+  MEMORY: () => MEMORY,
+  MAX_WHEN_EXPRESSION_DEPTH: () => MAX_WHEN_EXPRESSION_DEPTH,
+  MAX_SCRIPT_ID_LENGTH: () => MAX_SCRIPT_ID_LENGTH,
+  MAX_KEYBINDING_VALUE_LENGTH: () => MAX_KEYBINDING_VALUE_LENGTH,
+  MAX_KEYBINDINGS_COUNT: () => MAX_KEYBINDINGS_COUNT,
+  MANAGED_REPO_SERVICE_CAPABILITY_ID: () => MANAGED_REPO_SERVICE_CAPABILITY_ID,
+  MANAGED_REPO_SERVICE_CAPABILITY: () => MANAGED_REPO_SERVICE_CAPABILITY,
+  LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID: () => LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID,
+  LIFECYCLE_TOOLCHAIN_SOURCES: () => LIFECYCLE_TOOLCHAIN_SOURCES,
+  LIFECYCLE_GIT_AGENT_CAPABILITY_ID: () => LIFECYCLE_GIT_AGENT_CAPABILITY_ID,
+  LIFECYCLE_GIT_AGENT: () => LIFECYCLE_GIT_AGENT,
+  KeybindingsConfig: () => KeybindingsConfig,
+  KeybindingWhenNode: () => KeybindingWhenNode,
+  KeybindingShortcut: () => KeybindingShortcut,
+  KeybindingRule: () => KeybindingRule,
+  KeybindingCommand: () => KeybindingCommand,
+  KernelResolutionRecord: () => KernelResolutionRecord,
+  KernelReplacementGrant: () => KernelReplacementGrant,
+  KernelReplacementDenied: () => KernelReplacementDenied,
+  KernelBootErrorCode: () => KernelBootErrorCode,
+  KernelBootError: () => KernelBootError,
+  JournalEvent: () => JournalEvent,
+  IssueAnalysisConfig: () => IssueAnalysisConfig,
+  IsolationMode: () => IsolationMode,
+  IsoDateTime: () => IsoDateTime,
+  InsertStageMutation: () => InsertStageMutation,
+  ISSUE_TRIAGE_CAPABILITY_ID: () => ISSUE_TRIAGE_CAPABILITY_ID,
+  ISSUE_TRIAGE: () => ISSUE_TRIAGE,
+  ISOLATION_BACKEND_CAPABILITY_ID: () => ISOLATION_BACKEND_CAPABILITY_ID,
+  ISOLATION_BACKEND: () => ISOLATION_BACKEND,
+  HookToolInput: () => HookToolInput,
+  HookResult: () => HookResult,
+  HookRegistration: () => HookRegistration,
+  HookMatcher: () => HookMatcher,
+  HookEvent: () => HookEvent,
+  HookDecision: () => HookDecision,
+  HookContext: () => HookContext,
+  HOST_RUN_CAPABILITY_ID: () => HOST_RUN_CAPABILITY_ID,
+  HOST_RUN: () => HOST_RUN,
+  HELP_CATALOG_CAPABILITY_ID: () => HELP_CATALOG_CAPABILITY_ID,
+  HELP_CATALOG: () => HELP_CATALOG,
+  GraphSummary: () => GraphSummary,
+  GraphId: () => GraphId,
+  GitStatusResult: () => GitStatusResult,
+  GitStatusInput: () => GitStatusInput,
+  GitStackedAction: () => GitStackedAction,
+  GitRunStackedActionResult: () => GitRunStackedActionResult,
+  GitRunStackedActionInput: () => GitRunStackedActionInput,
+  GitRemoveWorktreeInput: () => GitRemoveWorktreeInput,
+  GitReadWorkingTreePatchResult: () => GitReadWorkingTreePatchResult,
+  GitReadWorkingTreePatchInput: () => GitReadWorkingTreePatchInput,
+  GitPullResult: () => GitPullResult,
+  GitPullInput: () => GitPullInput,
+  GitListBranchesResult: () => GitListBranchesResult,
+  GitListBranchesInput: () => GitListBranchesInput,
+  GitInitInput: () => GitInitInput,
+  GitHubProjectStatusConfig: () => GitHubProjectStatusConfig,
+  GitHubConfig: () => GitHubConfig,
+  GitCreateWorktreeResult: () => GitCreateWorktreeResult,
+  GitCreateWorktreeInput: () => GitCreateWorktreeInput,
+  GitCreateBranchInput: () => GitCreateBranchInput,
+  GitCheckoutInput: () => GitCheckoutInput,
+  GitBranch: () => GitBranch,
+  GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID: () => GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID,
+  GUARD_TOOLCHAIN_SOURCES: () => GUARD_TOOLCHAIN_SOURCES,
+  GRAPH_PROJECT_CAPABILITY_ID: () => GRAPH_PROJECT_CAPABILITY_ID,
+  GRAPH_PROJECT: () => GRAPH_PROJECT,
+  GITHUB_PROVIDER_CAPABILITY_ID: () => GITHUB_PROVIDER_CAPABILITY_ID,
+  GITHUB_PROVIDER: () => GITHUB_PROVIDER,
+  FunctionalRequirement: () => FunctionalRequirement,
+  EventId: () => EventId,
+  EpicRollup: () => EpicRollup,
+  EngineSandboxMode: () => EngineSandboxMode,
+  EngineRuntimeId: () => EngineRuntimeId,
+  EngineRunLog: () => EngineRunLog,
+  EngineMessageState: () => EngineMessageState,
+  EngineMessageRole: () => EngineMessageRole,
+  EngineMessage: () => EngineMessage,
+  EngineLogTone: () => EngineLogTone,
+  EngineAction: () => EngineAction,
+  EditorId: () => EditorId,
+  EDITORS: () => EDITORS,
+  DriftReport: () => DriftReport,
+  DriftKind: () => DriftKind,
+  DriftFinding: () => DriftFinding,
+  DriftConfidence: () => DriftConfidence,
+  DependencyNode: () => DependencyNode,
+  DependencyGraphModel: () => DependencyGraphModel,
+  DependencyEdgeType: () => DependencyEdgeType,
+  DependencyEdge: () => DependencyEdge,
+  DOCTOR_RUNNER_CAPABILITY_ID: () => DOCTOR_RUNNER_CAPABILITY_ID,
+  DOCTOR: () => DOCTOR,
+  DEPENDENCY_PREFLIGHT_CAPABILITY_ID: () => DEPENDENCY_PREFLIGHT_CAPABILITY_ID,
+  DEPENDENCY_PREFLIGHT_CAPABILITY: () => DEPENDENCY_PREFLIGHT_CAPABILITY,
+  DEFAULT_TERMINAL_ID: () => DEFAULT_TERMINAL_ID,
+  DEFAULT_RUNTIME_MODE: () => DEFAULT_RUNTIME_MODE,
+  DEFAULT_REASONING_EFFORT_BY_PROVIDER: () => DEFAULT_REASONING_EFFORT_BY_PROVIDER,
+  DEFAULT_PROVIDER_INTERACTION_MODE: () => DEFAULT_PROVIDER_INTERACTION_MODE,
+  DEFAULT_MODEL_BY_PROVIDER: () => DEFAULT_MODEL_BY_PROVIDER,
+  ConversationSummary: () => ConversationSummary,
+  ConversationId: () => ConversationId,
+  CommandId: () => CommandId,
+  CodexModelOptions: () => CodexModelOptions,
+  CliTaskSummary: () => CliTaskSummary,
+  CliTaskFilters: () => CliTaskFilters,
+  CliServerConnection: () => CliServerConnection,
+  CliRunRecord: () => CliRunRecord,
+  CliRepoConnectionState: () => CliRepoConnectionState,
+  CliRemoteProjectLink: () => CliRemoteProjectLink,
+  CliInboxRecord: () => CliInboxRecord,
+  CliError: () => CliError,
+  CliDoctorCheck: () => CliDoctorCheck,
+  CliCommandRegistration: () => CliCommandRegistration,
+  ClaudeModelOptions: () => ClaudeModelOptions,
+  ClarificationStatus: () => ClarificationStatus,
+  CheckpointRef: () => CheckpointRef,
+  ChatImageAttachment: () => ChatImageAttachment,
+  ChatAttachment: () => ChatAttachment,
+  CapabilityTag: () => CapabilityTag,
+  CapabilityRunSchema: () => CapabilityRunSchema,
+  CapabilityResolutionStatus: () => CapabilityResolutionStatus,
+  CapabilityResolutionRecord: () => CapabilityResolutionRecord,
+  CapabilityReplacementSpec: () => CapabilityReplacementSpec,
+  CapabilityReplacement: () => CapabilityReplacement,
+  CapabilityProviderRef: () => CapabilityProviderRef,
+  CapabilityGrants: () => CapabilityGrants,
+  CUSTOM_TYPE_FOR: () => CUSTOM_TYPE_FOR,
+  COMPLETION_VERIFICATION_CAPABILITY_ID: () => COMPLETION_VERIFICATION_CAPABILITY_ID,
+  COMPLETION_VERIFICATION_CAPABILITY: () => COMPLETION_VERIFICATION_CAPABILITY,
+  COLLAB_SESSION_VIEWER_CAPABILITY_ID: () => COLLAB_SESSION_VIEWER_CAPABILITY_ID,
+  COLLAB_SESSION_VIEWER_CAPABILITY: () => COLLAB_SESSION_VIEWER_CAPABILITY,
+  CODEX_REASONING_EFFORT_OPTIONS: () => CODEX_REASONING_EFFORT_OPTIONS,
+  CLI_RUNNER_CAPABILITY_ID: () => CLI_RUNNER_CAPABILITY_ID,
+  CLI_RUNNER: () => CLI_RUNNER,
+  CLI_OUTPUT_VERSION: () => CLI_OUTPUT_VERSION,
+  BootResultDescriptor: () => BootResultDescriptor,
+  BootIncoherent: () => BootIncoherent,
+  BlockerClassifierRegistration: () => BlockerClassifierRegistration,
+  BlockerClassification: () => BlockerClassification,
+  BlockerClass: () => BlockerClass,
+  BROWSER_CONTRACT_SERVICE_CAPABILITY_ID: () => BROWSER_CONTRACT_SERVICE_CAPABILITY_ID,
+  BROWSER_CONTRACT_SERVICE_CAPABILITY: () => BROWSER_CONTRACT_SERVICE_CAPABILITY,
+  AutomationConfig: () => AutomationConfig,
+  AssigneeRollup: () => AssigneeRollup,
+  ArtifactSummary: () => ArtifactSummary,
+  ArtifactId: () => ArtifactId,
+  ApprovalSummary: () => ApprovalSummary,
+  ApprovalStatus: () => ApprovalStatus,
+  ApprovalRequestId: () => ApprovalRequestId,
+  ApprovalDecision: () => ApprovalDecision,
+  AmbiguousCapability: () => AmbiguousCapability,
+  AgentSessionHookEvent: () => AgentSessionHookEvent,
+  AgentRoleRegistration: () => AgentRoleRegistration,
+  ActionRiskTier: () => ActionRiskTier,
+  ActionId: () => ActionId
+});
+module.exports = __toCommonJS(exports_src);
+var import_effect30 = require("effect");
+
+// packages/contracts/src/baseSchemas.ts
+var import_effect = require("effect");
+var TrimmedString = import_effect.Schema.Trim;
+var TrimmedNonEmptyString = TrimmedString.check(import_effect.Schema.isNonEmpty());
+var NonNegativeInt = import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0));
+var PositiveInt = import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(1));
+var IsoDateTime = import_effect.Schema.String;
+var makeEntityId = (brand) => TrimmedNonEmptyString.pipe(import_effect.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(import_effect.Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(import_effect.Schema.brand("SafePathSegment"));
+var SafeRunId = TrimmedNonEmptyString.check(import_effect.Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(import_effect.Schema.brand("SafeRunId"));
+var SafeGitRefComponent = TrimmedNonEmptyString.check(import_effect.Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(import_effect.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/workspace.ts
+var import_effect3 = require("effect");
+
+// packages/contracts/src/orchestration.ts
+var import_effect2 = require("effect");
+var ProviderKind = import_effect2.Schema.Literals(["codex", "claude"]);
+var ProviderApprovalPolicy = import_effect2.Schema.Literals([
+  "untrusted",
+  "on-failure",
+  "on-request",
+  "never"
+]);
+var ProviderSandboxMode = import_effect2.Schema.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var ProviderServiceTier = import_effect2.Schema.Literals(["fast", "flex"]);
+var RuntimeMode = import_effect2.Schema.Literals(["approval-required", "full-access"]);
+var DEFAULT_RUNTIME_MODE = "full-access";
+var ProviderInteractionMode = import_effect2.Schema.Literals(["default", "plan"]);
+var DEFAULT_PROVIDER_INTERACTION_MODE = "default";
+var ProviderRequestKind = import_effect2.Schema.Literals(["command", "file-read", "file-change"]);
+var ProviderApprovalDecision = import_effect2.Schema.Literals([
+  "accept",
+  "acceptForSession",
+  "decline",
+  "cancel"
+]);
+var ProviderUserInputAnswers = import_effect2.Schema.Record(import_effect2.Schema.String, import_effect2.Schema.Unknown);
+var PROVIDER_SEND_TURN_MAX_INPUT_CHARS = 120000;
+var PROVIDER_SEND_TURN_MAX_ATTACHMENTS = 8;
+var PROVIDER_SEND_TURN_MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+var CHAT_ATTACHMENT_ID_MAX_CHARS = 128;
+var ChatAttachmentId = TrimmedNonEmptyString.check(import_effect2.Schema.isMaxLength(CHAT_ATTACHMENT_ID_MAX_CHARS), import_effect2.Schema.isPattern(/^[a-z0-9_-]+$/i));
+var ChatImageAttachment = import_effect2.Schema.Struct({
+  type: import_effect2.Schema.Literal("image"),
+  id: ChatAttachmentId,
+  name: TrimmedNonEmptyString.check(import_effect2.Schema.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(import_effect2.Schema.isMaxLength(100), import_effect2.Schema.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(import_effect2.Schema.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES))
+});
+var ChatAttachment = import_effect2.Schema.Union([ChatImageAttachment]);
+
+// packages/contracts/src/workspace.ts
+var WorkspaceSourceKind = import_effect3.Schema.Literals(["native", "rig-import", "manual", "remote"]);
+var WorkspaceTopologyStatus = import_effect3.Schema.Literals(["empty", "ready", "degraded"]);
+var WorkspaceRemoteFleetStatus = import_effect3.Schema.Literals(["empty", "ready", "degraded"]);
+var WorkspaceServiceFabricStatus = import_effect3.Schema.Literals([
+  "empty",
+  "booting",
+  "ready",
+  "degraded",
+  "stopped"
+]);
+var WorkspaceRemoteHostStatus = import_effect3.Schema.Literals([
+  "registering",
+  "ready",
+  "busy",
+  "degraded",
+  "draining",
+  "offline",
+  "quarantined"
+]);
+var WorkspaceTopologyServiceSummary = import_effect3.Schema.Struct({
+  name: TrimmedNonEmptyString,
+  relativeRootPath: TrimmedNonEmptyString,
+  runtime: TrimmedNonEmptyString,
+  port: import_effect3.Schema.NullOr(import_effect3.Schema.Number),
+  healthcheck: import_effect3.Schema.NullOr(TrimmedNonEmptyString),
+  sourceOfTruth: import_effect3.Schema.Struct({
+    code: import_effect3.Schema.NullOr(TrimmedNonEmptyString),
+    tests: import_effect3.Schema.NullOr(TrimmedNonEmptyString),
+    infra: import_effect3.Schema.NullOr(TrimmedNonEmptyString),
+    deploy: import_effect3.Schema.NullOr(TrimmedNonEmptyString),
+    dependencies: import_effect3.Schema.NullOr(TrimmedNonEmptyString)
+  }),
+  splitReadyChecklist: import_effect3.Schema.Array(TrimmedNonEmptyString)
+});
+var WorkspaceTopologySummary = import_effect3.Schema.Struct({
+  compiledAt: IsoDateTime,
+  status: WorkspaceTopologyStatus,
+  manifestCount: import_effect3.Schema.Number,
+  serviceCount: import_effect3.Schema.Number,
+  services: import_effect3.Schema.Array(WorkspaceTopologyServiceSummary),
+  warnings: import_effect3.Schema.Array(import_effect3.Schema.String)
+});
+var WorkspaceRemoteHostSummary = import_effect3.Schema.Struct({
+  id: TrimmedNonEmptyString,
+  name: TrimmedNonEmptyString,
+  baseUrl: TrimmedNonEmptyString,
+  workspacePath: import_effect3.Schema.NullOr(TrimmedNonEmptyString),
+  transport: TrimmedNonEmptyString,
+  hostname: import_effect3.Schema.NullOr(TrimmedNonEmptyString),
+  region: import_effect3.Schema.NullOr(TrimmedNonEmptyString),
+  labels: import_effect3.Schema.Array(TrimmedNonEmptyString),
+  capabilities: import_effect3.Schema.Array(TrimmedNonEmptyString),
+  runtimeAdapters: import_effect3.Schema.Array(import_effect3.Schema.Literal("pi")),
+  status: WorkspaceRemoteHostStatus,
+  currentLeaseCount: import_effect3.Schema.Number,
+  lastHeartbeatAt: import_effect3.Schema.NullOr(IsoDateTime),
+  registeredAt: IsoDateTime,
+  manifestPath: TrimmedNonEmptyString
+});
+var WorkspaceRemoteFleetSummary = import_effect3.Schema.Struct({
+  updatedAt: IsoDateTime,
+  status: WorkspaceRemoteFleetStatus,
+  manifestCount: import_effect3.Schema.Number,
+  hostCount: import_effect3.Schema.Number,
+  onlineHostCount: import_effect3.Schema.Number,
+  hosts: import_effect3.Schema.Array(WorkspaceRemoteHostSummary),
+  warnings: import_effect3.Schema.Array(import_effect3.Schema.String)
+});
+var WorkspaceServiceFabricServiceSummary = import_effect3.Schema.Struct({
+  name: TrimmedNonEmptyString,
+  relativeRootPath: TrimmedNonEmptyString,
+  mode: import_effect3.Schema.Literals(["stub", "process"]),
+  port: import_effect3.Schema.Number,
+  healthcheck: TrimmedNonEmptyString,
+  routePrefix: import_effect3.Schema.NullOr(TrimmedNonEmptyString),
+  status: import_effect3.Schema.Literals(["planned", "booting", "healthy", "degraded", "failed", "stopped"]),
+  pid: import_effect3.Schema.NullOr(import_effect3.Schema.Number),
+  logPath: import_effect3.Schema.NullOr(TrimmedNonEmptyString)
+});
+var WorkspaceServiceFabricSummary = import_effect3.Schema.Struct({
+  updatedAt: IsoDateTime,
+  status: WorkspaceServiceFabricStatus,
+  serviceCount: import_effect3.Schema.Number,
+  healthyServiceCount: import_effect3.Schema.Number,
+  stateDir: TrimmedNonEmptyString,
+  services: import_effect3.Schema.Array(WorkspaceServiceFabricServiceSummary),
+  warnings: import_effect3.Schema.Array(import_effect3.Schema.String)
+});
+var WorkspaceSummary = import_effect3.Schema.Struct({
+  id: WorkspaceId,
+  title: TrimmedNonEmptyString,
+  rootPath: TrimmedNonEmptyString,
+  sourceKind: WorkspaceSourceKind,
+  defaultRuntimeAdapter: import_effect3.Schema.optional(import_effect3.Schema.Literal("pi")),
+  defaultProvider: import_effect3.Schema.optional(ProviderKind),
+  defaultModel: import_effect3.Schema.NullOr(TrimmedNonEmptyString),
+  topology: import_effect3.Schema.optional(WorkspaceTopologySummary),
+  remoteFleet: import_effect3.Schema.optional(WorkspaceRemoteFleetSummary),
+  serviceFabric: import_effect3.Schema.optional(WorkspaceServiceFabricSummary),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+// packages/contracts/src/graph.ts
+var import_effect4 = require("effect");
+
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/graph.ts
+var TaskStatus = import_effect4.Schema.Literals([
+  "draft",
+  "open",
+  "ready",
+  "queued",
+  "running",
+  "in_progress",
+  "under_review",
+  "blocked",
+  "unknown",
+  "completed",
+  "failed",
+  "cancelled",
+  "closed"
+]);
+var GraphSummary = import_effect4.Schema.Struct({
+  id: GraphId,
+  workspaceId: WorkspaceId,
+  title: TrimmedNonEmptyString,
+  description: import_effect4.Schema.NullOr(import_effect4.Schema.String),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var TaskSummary = import_effect4.Schema.Struct({
+  id: TaskId,
+  workspaceId: WorkspaceId,
+  graphId: import_effect4.Schema.NullOr(GraphId),
+  externalId: import_effect4.Schema.NullOr(TrimmedNonEmptyString),
+  title: TrimmedNonEmptyString,
+  description: import_effect4.Schema.String,
+  status: TaskStatus,
+  priority: import_effect4.Schema.NullOr(PositiveInt),
+  role: import_effect4.Schema.NullOr(TrimmedNonEmptyString),
+  scope: import_effect4.Schema.Array(TrimmedNonEmptyString),
+  validationKeys: import_effect4.Schema.Array(TrimmedNonEmptyString),
+  sourceIssueId: import_effect4.Schema.optional(import_effect4.Schema.NullOr(TrimmedNonEmptyString)),
+  dependencies: import_effect4.Schema.optional(import_effect4.Schema.Array(TrimmedNonEmptyString)),
+  parentChildDeps: import_effect4.Schema.optional(import_effect4.Schema.Array(TrimmedNonEmptyString)),
+  metadata: import_effect4.Schema.Unknown,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var QueueEntry = import_effect4.Schema.Struct({
+  taskId: TaskId,
+  score: NonNegativeInt,
+  unblockCount: NonNegativeInt,
+  position: NonNegativeInt
+});
+var DependencyEdgeType = import_effect4.Schema.Literals(["blocks", "parent-child", "related"]);
+var DependencyEdge = import_effect4.Schema.Struct({
+  fromTaskId: TaskId,
+  toTaskId: TaskId,
+  type: DependencyEdgeType
+});
+var BlockerClass = import_effect4.Schema.Literals([
+  "not-blocked",
+  "task-blocked",
+  "human-decision",
+  "human-approval",
+  "external-input",
+  "unknown"
+]);
+var ActionRiskTier = import_effect4.Schema.Literals(["t1-read", "t2-reversible", "t3-external", "t4-irreversible"]);
+var BlockerClassification = import_effect4.Schema.Struct({
+  taskId: TaskId,
+  blockerClass: BlockerClass,
+  actionRiskTier: import_effect4.Schema.NullOr(ActionRiskTier),
+  rationale: import_effect4.Schema.String,
+  source: import_effect4.Schema.Literals(["elimination", "label", "status", "llm"]),
+  autoApplied: import_effect4.Schema.Boolean
+});
+var DependencyNode = import_effect4.Schema.Struct({
+  taskId: TaskId,
+  title: TrimmedNonEmptyString,
+  status: TaskStatus,
+  priority: import_effect4.Schema.NullOr(PositiveInt),
+  assignee: import_effect4.Schema.NullOr(TrimmedNonEmptyString),
+  blockedBy: import_effect4.Schema.Array(TaskId),
+  blocks: import_effect4.Schema.Array(TaskId),
+  blockingDepth: NonNegativeInt,
+  blockerClass: import_effect4.Schema.NullOr(BlockerClass),
+  actionRiskTier: import_effect4.Schema.NullOr(ActionRiskTier),
+  epicKey: import_effect4.Schema.NullOr(TrimmedNonEmptyString),
+  groupKey: import_effect4.Schema.optional(import_effect4.Schema.NullOr(TrimmedNonEmptyString)),
+  externalId: import_effect4.Schema.optional(import_effect4.Schema.NullOr(TrimmedNonEmptyString)),
+  sourceIssueId: import_effect4.Schema.optional(import_effect4.Schema.NullOr(TrimmedNonEmptyString)),
+  scope: import_effect4.Schema.optional(import_effect4.Schema.Array(TrimmedNonEmptyString)),
+  validationKeys: import_effect4.Schema.optional(import_effect4.Schema.Array(TrimmedNonEmptyString))
+});
+var TaskGraphLane = import_effect4.Schema.Struct({
+  key: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  rowIndex: NonNegativeInt,
+  x: import_effect4.Schema.Number,
+  y: import_effect4.Schema.Number,
+  width: NonNegativeInt,
+  height: NonNegativeInt,
+  color: import_effect4.Schema.String,
+  taskCount: NonNegativeInt
+});
+var TaskGraphStage = import_effect4.Schema.Struct({
+  index: NonNegativeInt,
+  label: TrimmedNonEmptyString,
+  x: import_effect4.Schema.Number,
+  width: NonNegativeInt
+});
+var TaskGraphNode = import_effect4.Schema.Struct({
+  id: TrimmedNonEmptyString,
+  taskId: TaskId,
+  task: import_effect4.Schema.optional(TaskSummary),
+  rowKey: TrimmedNonEmptyString,
+  rowLabel: TrimmedNonEmptyString,
+  rowIndex: NonNegativeInt,
+  stage: NonNegativeInt,
+  x: import_effect4.Schema.Number,
+  y: import_effect4.Schema.Number,
+  width: NonNegativeInt,
+  height: NonNegativeInt,
+  color: import_effect4.Schema.optional(import_effect4.Schema.String),
+  taskCode: import_effect4.Schema.optional(import_effect4.Schema.NullOr(import_effect4.Schema.String)),
+  strippedTitle: import_effect4.Schema.optional(import_effect4.Schema.String),
+  depsIn: import_effect4.Schema.optional(NonNegativeInt),
+  depsOut: import_effect4.Schema.optional(NonNegativeInt),
+  runCount: import_effect4.Schema.optional(NonNegativeInt),
+  hasApprovals: import_effect4.Schema.optional(import_effect4.Schema.Boolean),
+  hasPendingUserInput: import_effect4.Schema.optional(import_effect4.Schema.Boolean),
+  hasRejectedReview: import_effect4.Schema.optional(import_effect4.Schema.Boolean),
+  hasFailedValidations: import_effect4.Schema.optional(import_effect4.Schema.Boolean),
+  artifactCount: import_effect4.Schema.optional(NonNegativeInt)
+});
+var TaskGraphEdge = import_effect4.Schema.Struct({
+  id: TrimmedNonEmptyString,
+  sourceId: TrimmedNonEmptyString,
+  targetId: TrimmedNonEmptyString,
+  color: import_effect4.Schema.String,
+  kind: import_effect4.Schema.Literals(["blocking", "parent-child"])
+});
+var TaskGraphLayout = import_effect4.Schema.Struct({
+  lanes: import_effect4.Schema.Array(TaskGraphLane),
+  stages: import_effect4.Schema.Array(TaskGraphStage),
+  nodes: import_effect4.Schema.Array(TaskGraphNode),
+  edges: import_effect4.Schema.Array(TaskGraphEdge),
+  totalWidth: NonNegativeInt,
+  totalHeight: NonNegativeInt,
+  taskCount: NonNegativeInt
+});
+var DependencyGraphModel = import_effect4.Schema.Struct({
+  graphId: GraphId,
+  nodes: import_effect4.Schema.Array(DependencyNode),
+  edges: import_effect4.Schema.Array(DependencyEdge),
+  layout: TaskGraphLayout,
+  cycles: import_effect4.Schema.Array(import_effect4.Schema.Array(TaskId)),
+  unresolvedRefs: import_effect4.Schema.Array(TrimmedNonEmptyString),
+  degraded: import_effect4.Schema.Boolean,
+  generatedAt: IsoDateTime
+});
+var GRAPH_PROJECT_CAPABILITY_ID = "rig.graph.project";
+var GRAPH_PROJECT = makeCapabilityId(GRAPH_PROJECT_CAPABILITY_ID);
+var TASK_SELECTION_CAPABILITY_ID = "cap:task-selection";
+var TASK_SELECTION = makeCapabilityId(TASK_SELECTION_CAPABILITY_ID);
+// packages/contracts/src/runtime.ts
+var import_effect5 = require("effect");
+var RunKind = import_effect5.Schema.Literals(["adhoc", "task", "batch", "validation", "review"]);
+var RunMode = import_effect5.Schema.Literals(["interactive", "autonomous", "supervised"]);
+var RunStatus = import_effect5.Schema.Literals([
+  "created",
+  "queued",
+  "preparing",
+  "running",
+  "waiting-approval",
+  "waiting-user-input",
+  "paused",
+  "validating",
+  "reviewing",
+  "closing-out",
+  "needs-attention",
+  "completed",
+  "failed",
+  "stopped"
+]);
+var EngineSandboxMode = import_effect5.Schema.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var IsolationMode = import_effect5.Schema.Literals(["none", "env", "worktree"]);
+var RuntimeStatus = import_effect5.Schema.Literals([
+  "prepared",
+  "starting",
+  "running",
+  "interrupted",
+  "exited",
+  "failed",
+  "destroyed"
+]);
+var RunExecutionTarget = import_effect5.Schema.Literals(["local", "remote"]);
+var RunSummary = import_effect5.Schema.Struct({
+  id: RunId,
+  workspaceId: WorkspaceId,
+  taskId: import_effect5.Schema.NullOr(TaskId),
+  title: TrimmedNonEmptyString,
+  runKind: RunKind,
+  mode: RunMode,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  status: RunStatus,
+  runtimeAdapter: import_effect5.Schema.Literal("pi"),
+  model: import_effect5.Schema.NullOr(TrimmedNonEmptyString),
+  initialPrompt: import_effect5.Schema.NullOr(import_effect5.Schema.String),
+  executionTarget: import_effect5.Schema.optional(RunExecutionTarget),
+  remoteHostId: import_effect5.Schema.optional(import_effect5.Schema.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseId: import_effect5.Schema.optional(import_effect5.Schema.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseClaimedAt: import_effect5.Schema.optional(import_effect5.Schema.NullOr(IsoDateTime)),
+  activeRuntimeId: import_effect5.Schema.NullOr(EngineRuntimeId),
+  latestMessageId: import_effect5.Schema.NullOr(TrimmedNonEmptyString),
+  pendingApprovalCount: NonNegativeInt,
+  pendingUserInputCount: NonNegativeInt,
+  branch: import_effect5.Schema.NullOr(TrimmedNonEmptyString),
+  worktreePath: import_effect5.Schema.NullOr(TrimmedNonEmptyString),
+  errorText: import_effect5.Schema.NullOr(import_effect5.Schema.String),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  startedAt: import_effect5.Schema.NullOr(IsoDateTime),
+  completedAt: import_effect5.Schema.NullOr(IsoDateTime)
+});
+var RuntimeSummary = import_effect5.Schema.Struct({
+  id: EngineRuntimeId,
+  workspaceId: WorkspaceId,
+  runId: RunId,
+  adapterKind: import_effect5.Schema.Literal("pi"),
+  executionTarget: import_effect5.Schema.optional(RunExecutionTarget),
+  remoteHostId: import_effect5.Schema.optional(import_effect5.Schema.NullOr(TrimmedNonEmptyString)),
+  status: RuntimeStatus,
+  sandboxMode: EngineSandboxMode,
+  isolationMode: IsolationMode,
+  workspaceDir: import_effect5.Schema.NullOr(TrimmedNonEmptyString),
+  homeDir: import_effect5.Schema.NullOr(TrimmedNonEmptyString),
+  tmpDir: import_effect5.Schema.NullOr(TrimmedNonEmptyString),
+  cacheDir: import_effect5.Schema.NullOr(TrimmedNonEmptyString),
+  logsDir: import_effect5.Schema.NullOr(TrimmedNonEmptyString),
+  stateDir: import_effect5.Schema.NullOr(TrimmedNonEmptyString),
+  sessionDir: import_effect5.Schema.NullOr(TrimmedNonEmptyString),
+  sessionLogPath: import_effect5.Schema.NullOr(TrimmedNonEmptyString),
+  pid: import_effect5.Schema.NullOr(NonNegativeInt),
+  startedAt: import_effect5.Schema.NullOr(IsoDateTime),
+  updatedAt: IsoDateTime,
+  exitedAt: import_effect5.Schema.NullOr(IsoDateTime)
+});
+var ApprovalStatus = import_effect5.Schema.Literals(["pending", "resolved"]);
+var ApprovalSummary = import_effect5.Schema.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  actionId: import_effect5.Schema.NullOr(TrimmedNonEmptyString),
+  requestKind: TrimmedNonEmptyString,
+  status: ApprovalStatus,
+  payload: import_effect5.Schema.Unknown,
+  createdAt: IsoDateTime,
+  resolvedAt: import_effect5.Schema.NullOr(IsoDateTime)
+});
+var UserInputRequestSummary = import_effect5.Schema.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  status: ApprovalStatus,
+  payload: import_effect5.Schema.Unknown,
+  createdAt: IsoDateTime,
+  resolvedAt: import_effect5.Schema.NullOr(IsoDateTime)
+});
+var WorktreeSummary = import_effect5.Schema.Struct({
+  id: WorktreeId,
+  workspaceId: WorkspaceId,
+  runId: RunId,
+  taskId: import_effect5.Schema.NullOr(TaskId),
+  branchName: TrimmedNonEmptyString,
+  path: TrimmedNonEmptyString,
+  status: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  cleanedAt: import_effect5.Schema.NullOr(IsoDateTime)
+});
+// packages/contracts/src/run-journal.ts
+var import_effect7 = require("effect");
+
+// packages/contracts/src/stage.ts
+var import_effect6 = require("effect");
+var StageKind = import_effect6.Schema.Literals(["transform", "gate", "observe"]);
+var StageId = TrimmedNonEmptyString.pipe(import_effect6.Schema.brand("StageId"));
+var StageContext = import_effect6.Schema.Struct({
+  runId: RunId,
+  taskId: import_effect6.Schema.optional(import_effect6.Schema.NullOr(TaskId)),
+  state: import_effect6.Schema.Unknown,
+  metadata: import_effect6.Schema.optional(import_effect6.Schema.Record(import_effect6.Schema.String, import_effect6.Schema.Unknown))
+});
+var StageDescriptor = import_effect6.Schema.Struct({
+  id: StageId,
+  kind: StageKind,
+  before: import_effect6.Schema.optional(import_effect6.Schema.Array(StageId)),
+  after: import_effect6.Schema.optional(import_effect6.Schema.Array(StageId)),
+  priority: import_effect6.Schema.Number.pipe(import_effect6.Schema.withDecodingDefault(() => 0)),
+  protected: import_effect6.Schema.Boolean.pipe(import_effect6.Schema.withDecodingDefault(() => false))
+});
+var Stage = StageDescriptor;
+var StageContinueResult = import_effect6.Schema.Struct({
+  kind: import_effect6.Schema.Literal("continue"),
+  ctx: StageContext
+});
+var StageAllowResult = import_effect6.Schema.Struct({
+  kind: import_effect6.Schema.Literal("allow")
+});
+var StageBlockResult = import_effect6.Schema.Struct({
+  kind: import_effect6.Schema.Literal("block"),
+  reason: TrimmedNonEmptyString
+});
+var StageResult = import_effect6.Schema.Union([
+  StageContinueResult,
+  StageAllowResult,
+  StageBlockResult
+]);
+var StageWrapperDescriptor = import_effect6.Schema.Struct({
+  id: TrimmedNonEmptyString,
+  priority: import_effect6.Schema.Number.pipe(import_effect6.Schema.withDecodingDefault(() => 0))
+});
+var StageMutationOp = import_effect6.Schema.Literals(["insert", "remove", "replace", "wrap", "reorder"]);
+var InsertStageMutation = import_effect6.Schema.Struct({
+  op: import_effect6.Schema.Literal("insert"),
+  stage: StageDescriptor,
+  contributedBy: import_effect6.Schema.optional(TrimmedNonEmptyString)
+});
+var RemoveStageMutation = import_effect6.Schema.Struct({
+  op: import_effect6.Schema.Literal("remove"),
+  id: StageId,
+  contributedBy: import_effect6.Schema.optional(TrimmedNonEmptyString)
+});
+var ReplaceStageMutation = import_effect6.Schema.Struct({
+  op: import_effect6.Schema.Literal("replace"),
+  id: StageId,
+  stage: StageDescriptor,
+  contributedBy: import_effect6.Schema.optional(TrimmedNonEmptyString)
+});
+var WrapStageMutation = import_effect6.Schema.Struct({
+  op: import_effect6.Schema.Literal("wrap"),
+  id: StageId,
+  around: StageWrapperDescriptor,
+  contributedBy: import_effect6.Schema.optional(TrimmedNonEmptyString)
+});
+var ReorderStageMutation = import_effect6.Schema.Struct({
+  op: import_effect6.Schema.Literal("reorder"),
+  id: StageId,
+  before: import_effect6.Schema.optional(import_effect6.Schema.Array(StageId)),
+  after: import_effect6.Schema.optional(import_effect6.Schema.Array(StageId)),
+  contributedBy: import_effect6.Schema.optional(TrimmedNonEmptyString)
+});
+var StageMutation = import_effect6.Schema.Union([
+  InsertStageMutation,
+  RemoveStageMutation,
+  ReplaceStageMutation,
+  WrapStageMutation,
+  ReorderStageMutation
+]);
+var ResolutionGrantUse = import_effect6.Schema.Struct({
+  kind: import_effect6.Schema.Literal("kernel-replacement"),
+  target: TrimmedNonEmptyString,
+  pluginId: TrimmedNonEmptyString
+});
+var ResolutionRecordEntry = import_effect6.Schema.Struct({
+  stageId: StageId,
+  contributedBy: TrimmedNonEmptyString,
+  removedBy: import_effect6.Schema.optional(TrimmedNonEmptyString),
+  replacedBy: import_effect6.Schema.optional(TrimmedNonEmptyString),
+  wrappedBy: import_effect6.Schema.optional(import_effect6.Schema.Array(TrimmedNonEmptyString)),
+  droppedAnchors: import_effect6.Schema.optional(import_effect6.Schema.Array(StageId)),
+  isProtected: import_effect6.Schema.Boolean
+});
+var ResolvedPipeline = import_effect6.Schema.Struct({
+  runId: import_effect6.Schema.optional(RunId),
+  order: import_effect6.Schema.Array(StageId),
+  record: import_effect6.Schema.Array(ResolutionRecordEntry),
+  cycles: import_effect6.Schema.Array(import_effect6.Schema.Array(StageId)),
+  grantUses: import_effect6.Schema.optional(import_effect6.Schema.Array(ResolutionGrantUse)),
+  resolvedAt: import_effect6.Schema.optional(IsoDateTime)
+});
+var ResolutionRecord = ResolvedPipeline;
+var StageRunOutcome = import_effect6.Schema.Struct({
+  stageId: StageId,
+  result: StageResult,
+  startedAt: IsoDateTime,
+  finishedAt: IsoDateTime
+});
+
+// packages/contracts/src/run-journal.ts
+var RunActor = import_effect7.Schema.Struct({
+  kind: import_effect7.Schema.Literals(["operator", "agent", "server", "system"]),
+  id: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString))
+});
+var RunCloseoutPhase = import_effect7.Schema.Literals([
+  "queued",
+  "commit",
+  "push",
+  "pr-review-merge",
+  "pr-opened",
+  "merge",
+  "close-source",
+  "completed"
+]);
+var RunCloseoutPhaseOutcome = import_effect7.Schema.Literals(["started", "completed", "failed"]);
+var RunCloseoutStatus = import_effect7.Schema.Literals([
+  "pending",
+  "running",
+  "completed",
+  "needs-attention",
+  "failed"
+]);
+var RunCloseoutState = import_effect7.Schema.Struct({
+  phase: RunCloseoutPhase,
+  status: RunCloseoutStatus,
+  updatedAt: IsoDateTime,
+  taskId: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString)),
+  runtimeWorkspace: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString)),
+  branch: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString)),
+  prUrl: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString)),
+  artifactRoot: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString)),
+  iterations: import_effect7.Schema.optional(import_effect7.Schema.NullOr(import_effect7.Schema.Int)),
+  feedback: import_effect7.Schema.optional(import_effect7.Schema.Array(import_effect7.Schema.String)),
+  error: import_effect7.Schema.optional(import_effect7.Schema.NullOr(import_effect7.Schema.String)),
+  reason: import_effect7.Schema.optional(import_effect7.Schema.NullOr(import_effect7.Schema.String)),
+  merged: import_effect7.Schema.optional(import_effect7.Schema.Boolean),
+  resumedAt: import_effect7.Schema.optional(import_effect7.Schema.NullOr(IsoDateTime)),
+  completedAt: import_effect7.Schema.optional(import_effect7.Schema.NullOr(IsoDateTime))
+});
+var ApprovalDecision = import_effect7.Schema.Literals(["approve", "reject"]);
+var runRecordFields = {
+  runId: TrimmedNonEmptyString,
+  workspaceId: TrimmedNonEmptyString,
+  taskId: import_effect7.Schema.NullOr(TrimmedNonEmptyString),
+  threadId: import_effect7.Schema.NullOr(TrimmedNonEmptyString),
+  mode: import_effect7.Schema.Literals(["local", "remote"]),
+  runtimeAdapter: import_effect7.Schema.Literal("pi"),
+  createdAt: IsoDateTime,
+  startedAt: import_effect7.Schema.NullOr(IsoDateTime),
+  completedAt: import_effect7.Schema.NullOr(IsoDateTime),
+  endpointId: import_effect7.Schema.NullOr(TrimmedNonEmptyString),
+  hostId: import_effect7.Schema.NullOr(TrimmedNonEmptyString),
+  worktreePath: import_effect7.Schema.NullOr(TrimmedNonEmptyString),
+  artifactRoot: import_effect7.Schema.NullOr(TrimmedNonEmptyString),
+  logRoot: import_effect7.Schema.NullOr(TrimmedNonEmptyString),
+  sessionPath: import_effect7.Schema.NullOr(TrimmedNonEmptyString),
+  sessionLogPath: import_effect7.Schema.NullOr(TrimmedNonEmptyString),
+  pid: import_effect7.Schema.optional(import_effect7.Schema.NullOr(import_effect7.Schema.Int)),
+  piSession: import_effect7.Schema.optional(import_effect7.Schema.Unknown),
+  piSessionPrivate: import_effect7.Schema.optional(import_effect7.Schema.Unknown),
+  updatedAt: IsoDateTime,
+  title: TrimmedNonEmptyString,
+  projectRoot: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString)),
+  errorText: import_effect7.Schema.optional(import_effect7.Schema.NullOr(import_effect7.Schema.String)),
+  latestMessageId: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString)),
+  prUrl: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString)),
+  leaseId: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString)),
+  serverCloseout: import_effect7.Schema.optional(import_effect7.Schema.NullOr(RunCloseoutState)),
+  model: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString)),
+  runtimeMode: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString)),
+  interactionMode: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString)),
+  runMode: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString)),
+  initialPrompt: import_effect7.Schema.optional(import_effect7.Schema.NullOr(import_effect7.Schema.String)),
+  baselineMode: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString)),
+  prMode: import_effect7.Schema.optional(import_effect7.Schema.NullOr(import_effect7.Schema.Literals(["auto", "ask", "off"]))),
+  initiatedBy: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString)),
+  sourceTask: import_effect7.Schema.optional(import_effect7.Schema.Unknown),
+  serverPid: import_effect7.Schema.optional(import_effect7.Schema.NullOr(import_effect7.Schema.Int)),
+  latestSteeringAt: import_effect7.Schema.optional(import_effect7.Schema.NullOr(IsoDateTime)),
+  latestSteeringDeliveredAt: import_effect7.Schema.optional(import_effect7.Schema.NullOr(IsoDateTime)),
+  statusDetail: import_effect7.Schema.optional(import_effect7.Schema.NullOr(import_effect7.Schema.String)),
+  planning: import_effect7.Schema.optional(import_effect7.Schema.Unknown),
+  branch: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString))
+};
+var RunJournalRecord = import_effect7.Schema.Struct({
+  ...runRecordFields,
+  status: RunStatus
+});
+var RunRecordPatch = import_effect7.Schema.Struct({
+  runId: import_effect7.Schema.optional(runRecordFields.runId),
+  workspaceId: import_effect7.Schema.optional(runRecordFields.workspaceId),
+  taskId: import_effect7.Schema.optional(runRecordFields.taskId),
+  threadId: import_effect7.Schema.optional(runRecordFields.threadId),
+  mode: import_effect7.Schema.optional(runRecordFields.mode),
+  runtimeAdapter: import_effect7.Schema.optional(runRecordFields.runtimeAdapter),
+  createdAt: import_effect7.Schema.optional(runRecordFields.createdAt),
+  startedAt: import_effect7.Schema.optional(runRecordFields.startedAt),
+  completedAt: import_effect7.Schema.optional(runRecordFields.completedAt),
+  endpointId: import_effect7.Schema.optional(runRecordFields.endpointId),
+  hostId: import_effect7.Schema.optional(runRecordFields.hostId),
+  worktreePath: import_effect7.Schema.optional(runRecordFields.worktreePath),
+  artifactRoot: import_effect7.Schema.optional(runRecordFields.artifactRoot),
+  logRoot: import_effect7.Schema.optional(runRecordFields.logRoot),
+  sessionPath: import_effect7.Schema.optional(runRecordFields.sessionPath),
+  sessionLogPath: import_effect7.Schema.optional(runRecordFields.sessionLogPath),
+  pid: runRecordFields.pid,
+  piSession: runRecordFields.piSession,
+  piSessionPrivate: runRecordFields.piSessionPrivate,
+  updatedAt: import_effect7.Schema.optional(runRecordFields.updatedAt),
+  title: import_effect7.Schema.optional(runRecordFields.title),
+  projectRoot: runRecordFields.projectRoot,
+  errorText: runRecordFields.errorText,
+  latestMessageId: runRecordFields.latestMessageId,
+  prUrl: runRecordFields.prUrl,
+  leaseId: runRecordFields.leaseId,
+  serverCloseout: runRecordFields.serverCloseout,
+  model: runRecordFields.model,
+  runtimeMode: runRecordFields.runtimeMode,
+  interactionMode: runRecordFields.interactionMode,
+  runMode: runRecordFields.runMode,
+  initialPrompt: runRecordFields.initialPrompt,
+  baselineMode: runRecordFields.baselineMode,
+  prMode: runRecordFields.prMode,
+  initiatedBy: runRecordFields.initiatedBy,
+  sourceTask: runRecordFields.sourceTask,
+  serverPid: runRecordFields.serverPid,
+  latestSteeringAt: runRecordFields.latestSteeringAt,
+  latestSteeringDeliveredAt: runRecordFields.latestSteeringDeliveredAt,
+  statusDetail: runRecordFields.statusDetail,
+  planning: runRecordFields.planning,
+  branch: runRecordFields.branch
+});
+var journalEnvelopeFields = {
+  v: import_effect7.Schema.Literal(1),
+  seq: PositiveInt,
+  at: IsoDateTime,
+  runId: RunId
+};
+var RunStatusChangedEvent = import_effect7.Schema.Struct({
+  ...journalEnvelopeFields,
+  type: import_effect7.Schema.Literal("status-changed"),
+  from: import_effect7.Schema.NullOr(RunStatus),
+  to: RunStatus,
+  reason: import_effect7.Schema.optional(import_effect7.Schema.NullOr(import_effect7.Schema.String)),
+  actor: import_effect7.Schema.optional(RunActor)
+});
+var RunRecordPatchEvent = import_effect7.Schema.Struct({
+  ...journalEnvelopeFields,
+  type: import_effect7.Schema.Literal("record-patch"),
+  patch: RunRecordPatch
+});
+var RunTimelineEntryEvent = import_effect7.Schema.Struct({
+  ...journalEnvelopeFields,
+  type: import_effect7.Schema.Literal("timeline-entry"),
+  payload: import_effect7.Schema.Unknown
+});
+var RunLogEntryEvent = import_effect7.Schema.Struct({
+  ...journalEnvelopeFields,
+  type: import_effect7.Schema.Literal("log-entry"),
+  payload: import_effect7.Schema.Unknown
+});
+var RunApprovalRequestedEvent = import_effect7.Schema.Struct({
+  ...journalEnvelopeFields,
+  type: import_effect7.Schema.Literal("approval-requested"),
+  requestId: TrimmedNonEmptyString,
+  requestKind: TrimmedNonEmptyString,
+  actionId: import_effect7.Schema.optional(import_effect7.Schema.NullOr(TrimmedNonEmptyString)),
+  payload: import_effect7.Schema.Unknown
+});
+var RunApprovalResolvedEvent = import_effect7.Schema.Struct({
+  ...journalEnvelopeFields,
+  type: import_effect7.Schema.Literal("approval-resolved"),
+  requestId: TrimmedNonEmptyString,
+  decision: ApprovalDecision,
+  note: import_effect7.Schema.optional(import_effect7.Schema.NullOr(import_effect7.Schema.String)),
+  actor: RunActor
+});
+var RunInputRequestedEvent = import_effect7.Schema.Struct({
+  ...journalEnvelopeFields,
+  type: import_effect7.Schema.Literal("input-requested"),
+  requestId: TrimmedNonEmptyString,
+  payload: import_effect7.Schema.Unknown
+});
+var RunInputResolvedEvent = import_effect7.Schema.Struct({
+  ...journalEnvelopeFields,
+  type: import_effect7.Schema.Literal("input-resolved"),
+  requestId: TrimmedNonEmptyString,
+  answers: import_effect7.Schema.Record(import_effect7.Schema.String, import_effect7.Schema.String),
+  actor: RunActor
+});
+var RunSteeringEvent = import_effect7.Schema.Struct({
+  ...journalEnvelopeFields,
+  type: import_effect7.Schema.Literal("steering"),
+  actor: RunActor,
+  text: import_effect7.Schema.String
+});
+var RunAdoptedEvent = import_effect7.Schema.Struct({
+  ...journalEnvelopeFields,
+  type: import_effect7.Schema.Literal("adopted"),
+  pid: import_effect7.Schema.NullOr(import_effect7.Schema.Int),
+  serverPid: import_effect7.Schema.Int
+});
+var RunStallDetectedEvent = import_effect7.Schema.Struct({
+  ...journalEnvelopeFields,
+  type: import_effect7.Schema.Literal("stall-detected"),
+  detail: import_effect7.Schema.String
+});
+var RunCloseoutPhaseEvent = import_effect7.Schema.Struct({
+  ...journalEnvelopeFields,
+  type: import_effect7.Schema.Literal("closeout-phase"),
+  phase: RunCloseoutPhase,
+  outcome: RunCloseoutPhaseOutcome,
+  detail: import_effect7.Schema.optional(import_effect7.Schema.NullOr(import_effect7.Schema.String))
+});
+var RunPipelineResolvedEvent = import_effect7.Schema.Struct({
+  ...journalEnvelopeFields,
+  type: import_effect7.Schema.Literal("pipeline-resolved"),
+  pipeline: ResolvedPipeline
+});
+var RunStageOutcomeEvent = import_effect7.Schema.Struct({
+  ...journalEnvelopeFields,
+  type: import_effect7.Schema.Literal("stage-outcome"),
+  outcome: StageRunOutcome
+});
+var RunJournalEvent = import_effect7.Schema.Union([
+  RunStatusChangedEvent,
+  RunRecordPatchEvent,
+  RunTimelineEntryEvent,
+  RunLogEntryEvent,
+  RunApprovalRequestedEvent,
+  RunApprovalResolvedEvent,
+  RunInputRequestedEvent,
+  RunInputResolvedEvent,
+  RunSteeringEvent,
+  RunAdoptedEvent,
+  RunStallDetectedEvent,
+  RunCloseoutPhaseEvent,
+  RunPipelineResolvedEvent,
+  RunStageOutcomeEvent
+]);
+// packages/contracts/src/run-session-journal.ts
+var RIG_RUN_STATUS_CHANGED = "rig.run.status-changed";
+var RIG_RUN_RECORD_PATCH = "rig.run.record-patch";
+var RIG_RUN_TIMELINE_ENTRY = "rig.run.timeline-entry";
+var RIG_RUN_LOG_ENTRY = "rig.run.log-entry";
+var RIG_RUN_APPROVAL_REQUESTED = "rig.run.approval-requested";
+var RIG_RUN_APPROVAL_RESOLVED = "rig.run.approval-resolved";
+var RIG_RUN_INPUT_REQUESTED = "rig.run.input-requested";
+var RIG_RUN_INPUT_RESOLVED = "rig.run.input-resolved";
+var RIG_RUN_STEERING = "rig.run.steering";
+var RIG_RUN_ADOPTED = "rig.run.adopted";
+var RIG_RUN_STALL_DETECTED = "rig.run.stall-detected";
+var RIG_RUN_CLOSEOUT_PHASE = "rig.run.closeout-phase";
+var RIG_RUN_PIPELINE_RESOLVED = "rig.run.pipeline-resolved";
+var RIG_RUN_STAGE_OUTCOME = "rig.run.stage-outcome";
+var RIG_STOP_SENTINEL = "<<RIG_STOP";
+var RIG_STOP_SENTINEL_END = ">>";
+var RIG_PAUSE_SENTINEL = "<<RIG_PAUSE";
+var RIG_RESUME_SENTINEL = "<<RIG_RESUME";
+var RIG_CONTROL_SENTINEL_END = ">>";
+var RIG_INBOX_RESOLUTION_SENTINEL = "<<RIG_INBOX_RESOLUTION";
+var CUSTOM_TYPE_FOR = {
+  "status-changed": RIG_RUN_STATUS_CHANGED,
+  "record-patch": RIG_RUN_RECORD_PATCH,
+  "timeline-entry": RIG_RUN_TIMELINE_ENTRY,
+  "log-entry": RIG_RUN_LOG_ENTRY,
+  "approval-requested": RIG_RUN_APPROVAL_REQUESTED,
+  "approval-resolved": RIG_RUN_APPROVAL_RESOLVED,
+  "input-requested": RIG_RUN_INPUT_REQUESTED,
+  "input-resolved": RIG_RUN_INPUT_RESOLVED,
+  steering: RIG_RUN_STEERING,
+  adopted: RIG_RUN_ADOPTED,
+  "stall-detected": RIG_RUN_STALL_DETECTED,
+  "closeout-phase": RIG_RUN_CLOSEOUT_PHASE,
+  "pipeline-resolved": RIG_RUN_PIPELINE_RESOLVED,
+  "stage-outcome": RIG_RUN_STAGE_OUTCOME
+};
+var TYPE_FOR_CUSTOM = {
+  [RIG_RUN_STATUS_CHANGED]: "status-changed",
+  [RIG_RUN_RECORD_PATCH]: "record-patch",
+  [RIG_RUN_TIMELINE_ENTRY]: "timeline-entry",
+  [RIG_RUN_LOG_ENTRY]: "log-entry",
+  [RIG_RUN_APPROVAL_REQUESTED]: "approval-requested",
+  [RIG_RUN_APPROVAL_RESOLVED]: "approval-resolved",
+  [RIG_RUN_INPUT_REQUESTED]: "input-requested",
+  [RIG_RUN_INPUT_RESOLVED]: "input-resolved",
+  [RIG_RUN_STEERING]: "steering",
+  [RIG_RUN_ADOPTED]: "adopted",
+  [RIG_RUN_STALL_DETECTED]: "stall-detected",
+  [RIG_RUN_CLOSEOUT_PHASE]: "closeout-phase",
+  [RIG_RUN_PIPELINE_RESOLVED]: "pipeline-resolved",
+  [RIG_RUN_STAGE_OUTCOME]: "stage-outcome"
+};
+// packages/contracts/src/workflow-journal.ts
+var RIG_WORKFLOW_STARTED = "rig.workflow.started";
+var RIG_WORKFLOW_TARGET_SELECTED = "rig.workflow.target.selected";
+var RIG_WORKFLOW_TASK_SELECTED = "rig.workflow.task.selected";
+var RIG_WORKFLOW_STATUS_CHANGED = "rig.workflow.status.changed";
+var RIG_WORKFLOW_OPERATOR_NOTE = "rig.workflow.operator.note";
+var RIG_WORKFLOW_INBOX_REQUESTED = "rig.workflow.inbox.requested";
+var RIG_WORKFLOW_INBOX_RESOLVED = "rig.workflow.inbox.resolved";
+// packages/contracts/src/run-status.ts
+var OPERATOR_INACTIVE_RUN_STATUSES = new Set([
+  "completed",
+  "complete",
+  "done",
+  "success",
+  "succeeded",
+  "passed",
+  "failed",
+  "failure",
+  "error",
+  "errored",
+  "stopped",
+  "cancelled",
+  "canceled",
+  "aborted",
+  "abort",
+  "merged",
+  "closed",
+  "skipped",
+  "needs-attention",
+  "needs_attention"
+]);
+// packages/contracts/src/run-read-model.ts
+var RUN_READ_MODEL_CAPABILITY_ID = "rig.runs.read-model";
+var RUN_READ_MODEL = makeCapabilityId(RUN_READ_MODEL_CAPABILITY_ID);
+// packages/contracts/src/conversation.ts
+var import_effect8 = require("effect");
+var EngineMessageRole = import_effect8.Schema.Literals(["user", "assistant", "system"]);
+var EngineMessageState = import_effect8.Schema.Literals([
+  "streaming",
+  "completed",
+  "interrupted",
+  "errored"
+]);
+var ConversationSummary = import_effect8.Schema.Struct({
+  id: ConversationId,
+  runId: RunId,
+  title: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var EngineMessage = import_effect8.Schema.Struct({
+  id: MessageId,
+  conversationId: ConversationId,
+  role: EngineMessageRole,
+  text: import_effect8.Schema.String,
+  attachments: import_effect8.Schema.Array(import_effect8.Schema.Unknown),
+  state: EngineMessageState,
+  createdAt: IsoDateTime,
+  completedAt: import_effect8.Schema.NullOr(IsoDateTime)
+});
+var EngineAction = import_effect8.Schema.Struct({
+  id: ActionId,
+  runId: RunId,
+  messageId: import_effect8.Schema.NullOr(MessageId),
+  actionType: TrimmedNonEmptyString,
+  title: TrimmedNonEmptyString,
+  detail: import_effect8.Schema.NullOr(import_effect8.Schema.String),
+  state: TrimmedNonEmptyString,
+  payload: import_effect8.Schema.Unknown,
+  startedAt: IsoDateTime,
+  completedAt: import_effect8.Schema.NullOr(IsoDateTime)
+});
+var EngineLogTone = import_effect8.Schema.Literals(["thinking", "tool", "info", "error"]);
+var EngineRunLog = import_effect8.Schema.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  title: TrimmedNonEmptyString,
+  detail: import_effect8.Schema.NullOr(import_effect8.Schema.String),
+  tone: EngineLogTone,
+  status: import_effect8.Schema.NullOr(TrimmedNonEmptyString),
+  payload: import_effect8.Schema.Unknown,
+  createdAt: IsoDateTime
+});
+// packages/contracts/src/plugin.ts
+var import_effect10 = require("effect");
+
+// packages/contracts/src/kernel.ts
+var import_effect9 = require("effect");
+var CapabilityTag = import_effect9.Schema.Literals([
+  "kernel",
+  "journal",
+  "stage-runner",
+  "transport",
+  "loader-policy"
+]);
+var CapabilityProviderRef = import_effect9.Schema.Struct({
+  capability: CapabilityTag,
+  pluginId: TrimmedNonEmptyString
+});
+var CapabilityReplacement = import_effect9.Schema.Struct({
+  capability: CapabilityTag,
+  providerPluginId: TrimmedNonEmptyString
+});
+var CapabilityReplacementSpec = import_effect9.Schema.Union([
+  CapabilityReplacement,
+  TrimmedNonEmptyString
+]);
+var KernelReplacementGrant = import_effect9.Schema.Struct({
+  pluginId: TrimmedNonEmptyString,
+  grantedBy: import_effect9.Schema.optional(TrimmedNonEmptyString),
+  reason: import_effect9.Schema.optional(import_effect9.Schema.String)
+});
+var CapabilityGrants = import_effect9.Schema.Struct({
+  capabilityPrecedence: import_effect9.Schema.optional(import_effect9.Schema.Record(import_effect9.Schema.String, import_effect9.Schema.Array(TrimmedNonEmptyString))),
+  kernelReplacementGrants: import_effect9.Schema.optional(import_effect9.Schema.Array(KernelReplacementGrant))
+});
+var KernelBootErrorCode = import_effect9.Schema.Literals([
+  "BootIncoherent",
+  "AmbiguousCapability",
+  "MissingCapability",
+  "KernelReplacementDenied",
+  "PipelineUnresolvable"
+]);
+var KernelBootError = import_effect9.Schema.Struct({
+  code: KernelBootErrorCode,
+  message: TrimmedNonEmptyString,
+  capability: import_effect9.Schema.optional(CapabilityTag),
+  stageId: import_effect9.Schema.optional(TrimmedNonEmptyString),
+  pluginIds: import_effect9.Schema.optional(import_effect9.Schema.Array(TrimmedNonEmptyString))
+});
+
+class BootIncoherent extends Error {
+  code = "BootIncoherent";
+}
+
+class AmbiguousCapability extends Error {
+  code = "AmbiguousCapability";
+}
+
+class MissingCapability extends Error {
+  code = "MissingCapability";
+}
+
+class KernelReplacementDenied extends Error {
+  code = "KernelReplacementDenied";
+}
+
+class PipelineUnresolvable extends Error {
+  code = "PipelineUnresolvable";
+}
+var CapabilityResolutionStatus = import_effect9.Schema.Literals(["resolved", "ambiguous", "missing", "replaced"]);
+var CapabilityResolutionRecord = import_effect9.Schema.Struct({
+  capability: CapabilityTag,
+  status: CapabilityResolutionStatus,
+  selectedPluginId: import_effect9.Schema.NullOr(TrimmedNonEmptyString),
+  candidatePluginIds: import_effect9.Schema.Array(TrimmedNonEmptyString),
+  precedenceUsed: import_effect9.Schema.Boolean,
+  replacementUsed: import_effect9.Schema.optional(CapabilityReplacement),
+  error: import_effect9.Schema.optional(import_effect9.Schema.String)
+});
+var KernelResolutionRecord = import_effect9.Schema.Struct({
+  resolvedAt: IsoDateTime,
+  capabilities: import_effect9.Schema.Array(CapabilityResolutionRecord),
+  pipeline: import_effect9.Schema.optional(ResolvedPipeline)
+});
+var BootResultDescriptor = import_effect9.Schema.Struct({
+  kernelPluginId: TrimmedNonEmptyString,
+  pluginIds: import_effect9.Schema.Array(TrimmedNonEmptyString),
+  resolution: KernelResolutionRecord
+});
+var JournalEvent = import_effect9.Schema.Struct({
+  type: TrimmedNonEmptyString,
+  runId: import_effect9.Schema.optional(RunId),
+  at: IsoDateTime,
+  payload: import_effect9.Schema.Unknown
+});
+var PLACEMENT_RUN_TRANSPORT = makeCapabilityId("transport.placement-run");
+
+// packages/contracts/src/plugin.ts
+var ValidatorCategory = import_effect10.Schema.Literals([
+  "boundary",
+  "contract",
+  "integration",
+  "regression",
+  "external",
+  "custom"
+]);
+var ValidatorRegistration = import_effect10.Schema.Struct({
+  id: import_effect10.Schema.String,
+  category: ValidatorCategory,
+  description: import_effect10.Schema.optional(import_effect10.Schema.String)
+});
+var AgentSessionHookEvent = import_effect10.Schema.Literals([
+  "PreToolUse",
+  "PostToolUse",
+  "UserPromptSubmit",
+  "Stop",
+  "SessionStart",
+  "SessionEnd"
+]);
+var HookEvent = AgentSessionHookEvent;
+var HookMatcher = import_effect10.Schema.Union([
+  import_effect10.Schema.Struct({ kind: import_effect10.Schema.Literal("all") }),
+  import_effect10.Schema.Struct({ kind: import_effect10.Schema.Literal("tool"), name: import_effect10.Schema.String }),
+  import_effect10.Schema.Struct({ kind: import_effect10.Schema.Literal("glob"), pattern: import_effect10.Schema.String })
+]);
+var HookRegistration = import_effect10.Schema.Struct({
+  id: import_effect10.Schema.String,
+  event: AgentSessionHookEvent,
+  matcher: HookMatcher,
+  command: import_effect10.Schema.optional(import_effect10.Schema.String),
+  description: import_effect10.Schema.optional(import_effect10.Schema.String)
+});
+var SkillRegistration = import_effect10.Schema.Struct({
+  id: import_effect10.Schema.String,
+  path: import_effect10.Schema.String,
+  description: import_effect10.Schema.optional(import_effect10.Schema.String)
+});
+var RepoSourceRegistration = import_effect10.Schema.Struct({
+  id: import_effect10.Schema.String,
+  url: import_effect10.Schema.String,
+  defaultPath: import_effect10.Schema.optional(import_effect10.Schema.String),
+  description: import_effect10.Schema.optional(import_effect10.Schema.String),
+  defaultBranch: import_effect10.Schema.optional(import_effect10.Schema.String),
+  remoteEnvVar: import_effect10.Schema.optional(import_effect10.Schema.String),
+  checkoutEnvVar: import_effect10.Schema.optional(import_effect10.Schema.String)
+});
+var AgentRoleRegistration = import_effect10.Schema.Struct({
+  id: import_effect10.Schema.String,
+  defaultModel: import_effect10.Schema.optional(import_effect10.Schema.String),
+  description: import_effect10.Schema.optional(import_effect10.Schema.String)
+});
+var TaskFieldExtension = import_effect10.Schema.Struct({
+  id: import_effect10.Schema.String,
+  fieldName: import_effect10.Schema.String,
+  schemaJson: import_effect10.Schema.String
+});
+var TaskSourceKind = import_effect10.Schema.String;
+var TaskSourceRegistration = import_effect10.Schema.Struct({
+  id: import_effect10.Schema.String,
+  kind: import_effect10.Schema.String,
+  description: import_effect10.Schema.optional(import_effect10.Schema.String)
+});
+var CliCommandRegistration = import_effect10.Schema.Struct({
+  id: import_effect10.Schema.String,
+  family: import_effect10.Schema.optional(import_effect10.Schema.String),
+  command: import_effect10.Schema.optional(import_effect10.Schema.String),
+  description: import_effect10.Schema.optional(import_effect10.Schema.String),
+  usage: import_effect10.Schema.optional(import_effect10.Schema.String),
+  aliases: import_effect10.Schema.optional(import_effect10.Schema.Array(import_effect10.Schema.String)),
+  projectRequired: import_effect10.Schema.optional(import_effect10.Schema.Boolean),
+  rootDefault: import_effect10.Schema.optional(import_effect10.Schema.Boolean),
+  productRoot: import_effect10.Schema.optional(import_effect10.Schema.Boolean),
+  subcommands: import_effect10.Schema.optional(import_effect10.Schema.Array(import_effect10.Schema.String))
+});
+var CapabilityRunSchema = import_effect10.Schema.declare((u) => typeof u === "function", { identifier: "CapabilityRun" });
+var ProductCapabilityRegistration = import_effect10.Schema.Struct({
+  id: import_effect10.Schema.String,
+  title: import_effect10.Schema.String,
+  description: import_effect10.Schema.optional(import_effect10.Schema.String),
+  commandId: import_effect10.Schema.optional(import_effect10.Schema.String),
+  panelId: import_effect10.Schema.optional(import_effect10.Schema.String),
+  run: import_effect10.Schema.optional(CapabilityRunSchema)
+});
+var PanelRegistration = import_effect10.Schema.Struct({
+  id: import_effect10.Schema.String,
+  slot: import_effect10.Schema.String,
+  title: import_effect10.Schema.String,
+  capabilityId: import_effect10.Schema.optional(import_effect10.Schema.String),
+  badge: import_effect10.Schema.optional(import_effect10.Schema.String),
+  disabled: import_effect10.Schema.optional(import_effect10.Schema.Boolean),
+  description: import_effect10.Schema.optional(import_effect10.Schema.String)
+});
+var BlockerClassifierRegistration = import_effect10.Schema.Struct({
+  id: import_effect10.Schema.String,
+  description: import_effect10.Schema.optional(import_effect10.Schema.String),
+  priority: import_effect10.Schema.optional(import_effect10.Schema.Number)
+});
+var SessionExtensionRegistration = import_effect10.Schema.Struct({
+  id: import_effect10.Schema.String,
+  description: import_effect10.Schema.optional(import_effect10.Schema.String)
+});
+var SeedEntrypointRegistration = import_effect10.Schema.Struct({
+  id: import_effect10.Schema.String,
+  description: import_effect10.Schema.optional(import_effect10.Schema.String),
+  basename: import_effect10.Schema.optional(import_effect10.Schema.String),
+  workerArg: import_effect10.Schema.optional(import_effect10.Schema.String),
+  insidePty: import_effect10.Schema.optional(import_effect10.Schema.Boolean)
+});
+var PluginContributes = import_effect10.Schema.Struct({
+  validators: import_effect10.Schema.optional(import_effect10.Schema.Array(ValidatorRegistration)),
+  hooks: import_effect10.Schema.optional(import_effect10.Schema.Array(HookRegistration)),
+  skills: import_effect10.Schema.optional(import_effect10.Schema.Array(SkillRegistration)),
+  repoSources: import_effect10.Schema.optional(import_effect10.Schema.Array(RepoSourceRegistration)),
+  agentRoles: import_effect10.Schema.optional(import_effect10.Schema.Array(AgentRoleRegistration)),
+  taskFieldSchemas: import_effect10.Schema.optional(import_effect10.Schema.Array(TaskFieldExtension)),
+  taskSources: import_effect10.Schema.optional(import_effect10.Schema.Array(TaskSourceRegistration)),
+  cliCommands: import_effect10.Schema.optional(import_effect10.Schema.Array(CliCommandRegistration)),
+  stages: import_effect10.Schema.optional(import_effect10.Schema.Array(Stage)),
+  stageMutations: import_effect10.Schema.optional(import_effect10.Schema.Array(StageMutation)),
+  capabilities: import_effect10.Schema.optional(import_effect10.Schema.Array(ProductCapabilityRegistration)),
+  panels: import_effect10.Schema.optional(import_effect10.Schema.Array(PanelRegistration)),
+  blockerClassifiers: import_effect10.Schema.optional(import_effect10.Schema.Array(BlockerClassifierRegistration)),
+  sessionExtensions: import_effect10.Schema.optional(import_effect10.Schema.Array(SessionExtensionRegistration)),
+  seedEntrypoints: import_effect10.Schema.optional(import_effect10.Schema.Array(SeedEntrypointRegistration))
+});
+var RigPlugin = import_effect10.Schema.Struct({
+  name: import_effect10.Schema.String,
+  version: import_effect10.Schema.String,
+  provides: import_effect10.Schema.optional(import_effect10.Schema.Array(CapabilityTag)),
+  requires: import_effect10.Schema.optional(import_effect10.Schema.Array(CapabilityTag)),
+  replaces: import_effect10.Schema.optional(import_effect10.Schema.Array(CapabilityReplacementSpec)),
+  contributes: import_effect10.Schema.optional(PluginContributes)
+});
+// packages/contracts/src/plugin-hooks.ts
+var import_effect11 = require("effect");
+var HookToolInput = import_effect11.Schema.Record(import_effect11.Schema.String, import_effect11.Schema.Unknown);
+var HookContext = import_effect11.Schema.Struct({
+  event: AgentSessionHookEvent,
+  toolName: import_effect11.Schema.optional(import_effect11.Schema.String),
+  toolInput: HookToolInput,
+  filePaths: import_effect11.Schema.Array(import_effect11.Schema.String),
+  projectRoot: import_effect11.Schema.String,
+  taskId: import_effect11.Schema.String
+});
+var HookDecision = import_effect11.Schema.Literals(["allow", "block"]);
+var HookResult = import_effect11.Schema.Struct({
+  decision: HookDecision,
+  reason: import_effect11.Schema.optional(import_effect11.Schema.String),
+  systemMessage: import_effect11.Schema.optional(import_effect11.Schema.String)
+});
+// packages/contracts/src/config.ts
+var import_effect13 = require("effect");
+
+// packages/contracts/src/supervisor-journal.ts
+var import_effect12 = require("effect");
+var SupervisorStopReason = import_effect12.Schema.Literals([
+  "all-done",
+  "all-human-blocked",
+  "max-tasks",
+  "budget",
+  "judge-stop",
+  "operator-stop",
+  "source-error"
+]);
+var SupervisorSelectionPolicy = import_effect12.Schema.Literals(["rank", "max-unblock", "blocking-only"]);
+var SupervisorStatus = import_effect12.Schema.Literals(["running", "idle", "stopped", "finished"]);
+var TaskClosureSummary = import_effect12.Schema.Struct({
+  taskId: TaskId,
+  runId: RunId,
+  prUrl: import_effect12.Schema.NullOr(import_effect12.Schema.String),
+  mergeGate: import_effect12.Schema.NullOr(import_effect12.Schema.Literals(["passed", "blocked", "skipped"])),
+  acceptanceChecked: import_effect12.Schema.Array(import_effect12.Schema.Struct({
+    item: import_effect12.Schema.String,
+    met: import_effect12.Schema.Boolean
+  })),
+  unblockedTaskIds: import_effect12.Schema.Array(TaskId)
+});
+var SupervisorStartedEvent = import_effect12.Schema.Struct({
+  kind: import_effect12.Schema.Literal("supervisor.started"),
+  at: IsoDateTime,
+  options: import_effect12.Schema.Unknown
+});
+var SupervisorSelectionPlannedEvent = import_effect12.Schema.Struct({
+  kind: import_effect12.Schema.Literal("supervisor.selection-planned"),
+  at: IsoDateTime,
+  taskIds: import_effect12.Schema.Array(TaskId),
+  policy: SupervisorSelectionPolicy
+});
+var SupervisorDispatchStartedEvent = import_effect12.Schema.Struct({
+  kind: import_effect12.Schema.Literal("supervisor.dispatch-started"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  score: NonNegativeInt
+});
+var SupervisorDispatchConfirmedEvent = import_effect12.Schema.Struct({
+  kind: import_effect12.Schema.Literal("supervisor.dispatch-confirmed"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  runId: RunId,
+  dispatchHandle: import_effect12.Schema.optional(import_effect12.Schema.NullOr(import_effect12.Schema.String))
+});
+var SupervisorDispatchEvent = import_effect12.Schema.Struct({
+  kind: import_effect12.Schema.Literal("supervisor.dispatch"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  runId: RunId,
+  score: NonNegativeInt,
+  dispatchHandle: import_effect12.Schema.optional(import_effect12.Schema.NullOr(import_effect12.Schema.String))
+});
+var SupervisorOutcomeEvent = import_effect12.Schema.Struct({
+  kind: import_effect12.Schema.Literal("supervisor.outcome"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  runId: RunId,
+  status: RunStatus,
+  failed: import_effect12.Schema.Boolean,
+  unblockedTaskIds: import_effect12.Schema.Array(TaskId),
+  closure: import_effect12.Schema.optional(TaskClosureSummary)
+});
+var SupervisorSkippedEvent = import_effect12.Schema.Struct({
+  kind: import_effect12.Schema.Literal("supervisor.skipped"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  reason: import_effect12.Schema.String
+});
+var SupervisorIdleEvent = import_effect12.Schema.Struct({
+  kind: import_effect12.Schema.Literal("supervisor.idle"),
+  at: IsoDateTime,
+  reason: SupervisorStopReason
+});
+var SupervisorStoppedEvent = import_effect12.Schema.Struct({
+  kind: import_effect12.Schema.Literal("supervisor.stopped"),
+  at: IsoDateTime,
+  reason: SupervisorStopReason
+});
+var SupervisorFinishedEvent = import_effect12.Schema.Struct({
+  kind: import_effect12.Schema.Literal("supervisor.finished"),
+  at: IsoDateTime,
+  processed: NonNegativeInt,
+  succeeded: NonNegativeInt,
+  failed: NonNegativeInt,
+  skipped: import_effect12.Schema.optional(NonNegativeInt),
+  idleReason: import_effect12.Schema.NullOr(SupervisorStopReason)
+});
+var SupervisorEvent = import_effect12.Schema.Union([
+  SupervisorStartedEvent,
+  SupervisorSelectionPlannedEvent,
+  SupervisorDispatchStartedEvent,
+  SupervisorDispatchConfirmedEvent,
+  SupervisorDispatchEvent,
+  SupervisorOutcomeEvent,
+  SupervisorSkippedEvent,
+  SupervisorIdleEvent,
+  SupervisorStoppedEvent,
+  SupervisorFinishedEvent
+]);
+var SupervisorProjection = import_effect12.Schema.Struct({
+  status: SupervisorStatus,
+  processed: NonNegativeInt,
+  succeeded: NonNegativeInt,
+  failed: NonNegativeInt,
+  skipped: NonNegativeInt,
+  current: import_effect12.Schema.NullOr(import_effect12.Schema.Struct({ taskId: TaskId, runId: RunId })),
+  plannedOrder: import_effect12.Schema.Array(TaskId),
+  selectionPolicy: import_effect12.Schema.NullOr(SupervisorSelectionPolicy),
+  concurrency: import_effect12.Schema.NullOr(NonNegativeInt),
+  idleReason: import_effect12.Schema.NullOr(SupervisorStopReason),
+  stopReason: import_effect12.Schema.NullOr(SupervisorStopReason),
+  closures: import_effect12.Schema.Array(TaskClosureSummary),
+  anomalies: import_effect12.Schema.Array(import_effect12.Schema.String)
+});
+
+// packages/contracts/src/config.ts
+var WorkspaceIsolation = import_effect13.Schema.Literals([
+  "worktree",
+  "directory"
+]);
+var WorkspaceCheckout = WorkspaceIsolation;
+var WorkspaceSandbox = import_effect13.Schema.Literals(["enforce", "auto", "off"]);
+var ScopeSearchPrefix = import_effect13.Schema.Struct({
+  prefix: import_effect13.Schema.String,
+  matchStartsWith: import_effect13.Schema.optional(import_effect13.Schema.Array(import_effect13.Schema.String)),
+  matchExact: import_effect13.Schema.optional(import_effect13.Schema.Array(import_effect13.Schema.String))
+});
+var ScopeNormalizationRules = import_effect13.Schema.Struct({
+  stripPrefixes: import_effect13.Schema.optional(import_effect13.Schema.Array(import_effect13.Schema.String)),
+  searchPrefixes: import_effect13.Schema.optional(import_effect13.Schema.Array(ScopeSearchPrefix))
+});
+var WorkspaceConfig = import_effect13.Schema.Struct({
+  mainRepo: import_effect13.Schema.String,
+  checkout: import_effect13.Schema.optional(WorkspaceCheckout),
+  isolation: import_effect13.Schema.optional(WorkspaceIsolation),
+  sandbox: import_effect13.Schema.optional(WorkspaceSandbox),
+  scopeNormalization: import_effect13.Schema.optional(ScopeNormalizationRules)
+});
+var TaskSourceConfig = import_effect13.Schema.Struct({
+  kind: import_effect13.Schema.String,
+  path: import_effect13.Schema.optional(import_effect13.Schema.String),
+  owner: import_effect13.Schema.optional(import_effect13.Schema.String),
+  repo: import_effect13.Schema.optional(import_effect13.Schema.String),
+  labels: import_effect13.Schema.optional(import_effect13.Schema.Array(import_effect13.Schema.String)),
+  state: import_effect13.Schema.optional(import_effect13.Schema.Literals(["open", "closed", "all"])),
+  url: import_effect13.Schema.optional(import_effect13.Schema.String),
+  options: import_effect13.Schema.optional(import_effect13.Schema.Record(import_effect13.Schema.String, import_effect13.Schema.Unknown))
+});
+var RuntimeHarness = import_effect13.Schema.Literal("pi");
+var RigRuntimeMode = import_effect13.Schema.Literals(["yolo", "approval-required"]);
+var PiRuntimeConfig = import_effect13.Schema.Struct({
+  packages: import_effect13.Schema.optional(import_effect13.Schema.Array(import_effect13.Schema.String))
+});
+var RigServerConfig = import_effect13.Schema.Struct({
+  host: import_effect13.Schema.optional(import_effect13.Schema.String),
+  relayUrl: import_effect13.Schema.optional(import_effect13.Schema.String),
+  registryUrl: import_effect13.Schema.optional(import_effect13.Schema.String),
+  sshTarget: import_effect13.Schema.optional(import_effect13.Schema.String),
+  checkout: import_effect13.Schema.optional(import_effect13.Schema.String)
+});
+var RuntimePositiveInt = import_effect13.Schema.Int.check(import_effect13.Schema.isGreaterThanOrEqualTo(1));
+var RuntimeSupervisorConfig = import_effect13.Schema.Struct({
+  concurrency: import_effect13.Schema.optional(RuntimePositiveInt),
+  pauseOnAttention: import_effect13.Schema.optional(import_effect13.Schema.Boolean),
+  stopWhen: import_effect13.Schema.optional(import_effect13.Schema.Array(SupervisorStopReason)),
+  maxTasks: import_effect13.Schema.optional(RuntimePositiveInt),
+  selectionPolicy: import_effect13.Schema.optional(SupervisorSelectionPolicy),
+  failFast: import_effect13.Schema.optional(import_effect13.Schema.Boolean)
+});
+var RuntimeDriftConfig = import_effect13.Schema.Struct({
+  enabled: import_effect13.Schema.optional(import_effect13.Schema.Boolean),
+  failOnDrift: import_effect13.Schema.optional(import_effect13.Schema.Boolean),
+  docsGlobs: import_effect13.Schema.optional(import_effect13.Schema.Array(import_effect13.Schema.String)),
+  ignoreGlobs: import_effect13.Schema.optional(import_effect13.Schema.Array(import_effect13.Schema.String)),
+  judge: import_effect13.Schema.optional(import_effect13.Schema.Boolean)
+});
+var RuntimePlanningConfig = import_effect13.Schema.Struct({
+  architectRole: import_effect13.Schema.optional(import_effect13.Schema.String),
+  autoResolveFromCode: import_effect13.Schema.optional(import_effect13.Schema.Boolean),
+  materialize: import_effect13.Schema.optional(import_effect13.Schema.Literals(["dry-run", "create"]))
+});
+var RuntimeConfig = import_effect13.Schema.Struct({
+  agentRoles: import_effect13.Schema.optional(import_effect13.Schema.Record(import_effect13.Schema.String, import_effect13.Schema.Unknown)),
+  timeouts: import_effect13.Schema.optional(import_effect13.Schema.Record(import_effect13.Schema.String, import_effect13.Schema.Number)),
+  harness: import_effect13.Schema.optional(RuntimeHarness),
+  model: import_effect13.Schema.optional(import_effect13.Schema.String),
+  mode: import_effect13.Schema.optional(RigRuntimeMode),
+  pi: import_effect13.Schema.optional(PiRuntimeConfig),
+  server: import_effect13.Schema.optional(RigServerConfig),
+  capabilities: import_effect13.Schema.optional(CapabilityGrants),
+  supervisor: import_effect13.Schema.optional(RuntimeSupervisorConfig),
+  drift: import_effect13.Schema.optional(RuntimeDriftConfig),
+  planning: import_effect13.Schema.optional(RuntimePlanningConfig)
+});
+var ProjectIdentity = import_effect13.Schema.Struct({
+  name: import_effect13.Schema.String,
+  repo: import_effect13.Schema.optional(import_effect13.Schema.String)
+});
+var PlanningConfig = import_effect13.Schema.Struct({
+  mode: import_effect13.Schema.optional(import_effect13.Schema.Literals(["auto", "always", "off"])),
+  requireForLabels: import_effect13.Schema.optional(import_effect13.Schema.Array(import_effect13.Schema.String)),
+  skipForLabels: import_effect13.Schema.optional(import_effect13.Schema.Array(import_effect13.Schema.String))
+});
+var GitHubProjectStatusConfig = import_effect13.Schema.Struct({
+  enabled: import_effect13.Schema.optional(import_effect13.Schema.Boolean),
+  projectId: import_effect13.Schema.optional(import_effect13.Schema.String),
+  statusFieldId: import_effect13.Schema.optional(import_effect13.Schema.String),
+  statuses: import_effect13.Schema.optional(import_effect13.Schema.Struct({
+    running: import_effect13.Schema.optional(import_effect13.Schema.String),
+    prOpen: import_effect13.Schema.optional(import_effect13.Schema.String),
+    ciFixing: import_effect13.Schema.optional(import_effect13.Schema.String),
+    merging: import_effect13.Schema.optional(import_effect13.Schema.String),
+    done: import_effect13.Schema.optional(import_effect13.Schema.String),
+    needsAttention: import_effect13.Schema.optional(import_effect13.Schema.String)
+  }))
+});
+var GitHubConfig = import_effect13.Schema.Struct({
+  issueUpdates: import_effect13.Schema.optional(import_effect13.Schema.Literals(["lifecycle", "minimal", "off"])),
+  projects: import_effect13.Schema.optional(GitHubProjectStatusConfig)
+});
+var AutomationConfig = import_effect13.Schema.Struct({
+  maxValidationAttempts: import_effect13.Schema.optional(import_effect13.Schema.Number),
+  maxPrFixIterations: import_effect13.Schema.optional(import_effect13.Schema.Number)
+});
+var PullRequestConfig = import_effect13.Schema.Struct({
+  mode: import_effect13.Schema.optional(import_effect13.Schema.Literals(["auto", "ask", "off"])),
+  watchChecks: import_effect13.Schema.optional(import_effect13.Schema.Boolean),
+  autoFixChecks: import_effect13.Schema.optional(import_effect13.Schema.Boolean),
+  autoFixReview: import_effect13.Schema.optional(import_effect13.Schema.Boolean),
+  pendingTimeoutMs: import_effect13.Schema.optional(import_effect13.Schema.Number),
+  pendingPollMs: import_effect13.Schema.optional(import_effect13.Schema.Number)
+});
+var MergeConfig = import_effect13.Schema.Struct({
+  mode: import_effect13.Schema.optional(import_effect13.Schema.Literals(["auto", "off", "pr-ready"])),
+  method: import_effect13.Schema.optional(import_effect13.Schema.Literals(["repo-default", "squash", "merge", "rebase"])),
+  deleteBranch: import_effect13.Schema.optional(import_effect13.Schema.Union([import_effect13.Schema.Literal("repo-default"), import_effect13.Schema.Boolean])),
+  allowedFailures: import_effect13.Schema.optional(import_effect13.Schema.Array(import_effect13.Schema.String)),
+  bypass: import_effect13.Schema.optional(import_effect13.Schema.Boolean)
+});
+var IssueAnalysisConfig = import_effect13.Schema.Struct({
+  enabled: import_effect13.Schema.optional(import_effect13.Schema.Boolean),
+  harness: import_effect13.Schema.optional(import_effect13.Schema.Literal("pi")),
+  model: import_effect13.Schema.optional(import_effect13.Schema.String),
+  mode: import_effect13.Schema.optional(import_effect13.Schema.Literals(["continuous", "off"]))
+});
+var ReviewConfig = import_effect13.Schema.Struct({
+  mode: import_effect13.Schema.optional(import_effect13.Schema.Literals(["off", "advisory", "required"])),
+  provider: import_effect13.Schema.optional(import_effect13.Schema.Literals(["greptile", "github"]))
+});
+var RigConfig = import_effect13.Schema.Struct({
+  project: ProjectIdentity,
+  plugins: import_effect13.Schema.Array(RigPlugin),
+  taskSource: TaskSourceConfig,
+  workspace: WorkspaceConfig,
+  runtime: import_effect13.Schema.optional(RuntimeConfig),
+  planning: import_effect13.Schema.optional(PlanningConfig),
+  github: import_effect13.Schema.optional(GitHubConfig),
+  automation: import_effect13.Schema.optional(AutomationConfig),
+  pr: import_effect13.Schema.optional(PullRequestConfig),
+  merge: import_effect13.Schema.optional(MergeConfig),
+  review: import_effect13.Schema.optional(ReviewConfig),
+  issueAnalysis: import_effect13.Schema.optional(IssueAnalysisConfig),
+  capabilities: import_effect13.Schema.optional(CapabilityGrants),
+  env: import_effect13.Schema.optional(import_effect13.Schema.Record(import_effect13.Schema.String, import_effect13.Schema.String))
+});
+// packages/contracts/src/policy.ts
+var import_effect14 = require("effect");
+var PolicyDecision = import_effect14.Schema.Literals(["allow", "warn", "block"]);
+var PolicyMode = import_effect14.Schema.Literals(["off", "observe", "enforce"]);
+var PolicyDecisionSummary = import_effect14.Schema.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  actionId: import_effect14.Schema.NullOr(ActionId),
+  decision: PolicyDecision,
+  mode: PolicyMode,
+  matchedRules: import_effect14.Schema.Array(TrimmedNonEmptyString),
+  reason: import_effect14.Schema.String,
+  createdAt: IsoDateTime
+});
+// packages/contracts/src/guard.ts
+var POLICY_VERSION = 1;
+// packages/contracts/src/tool-registry.ts
+var RUNTIME_SHELL_TOOL_NAMES = [
+  "bash",
+  "sh",
+  "zsh",
+  "git",
+  "bun",
+  "node",
+  "python3",
+  "rg",
+  "grep",
+  "sed",
+  "cat",
+  "ls",
+  "find",
+  "tsc",
+  "gh",
+  "mkdir",
+  "rm",
+  "mv",
+  "cp",
+  "touch",
+  "pwd",
+  "head",
+  "tail",
+  "wc",
+  "sort",
+  "uniq",
+  "awk",
+  "xargs",
+  "dirname",
+  "basename",
+  "realpath",
+  "env",
+  "jq",
+  "tee",
+  "which"
+];
+var RUNTIME_FILE_TOOL_NAMES = [
+  "rig-read",
+  "rig-write",
+  "rig-edit",
+  "rig-glob",
+  "rig-grep"
+];
+var RUNTIME_BROWSER_TOOL_NAMES = [
+  "rig-browser-launch",
+  "rig-browser-check",
+  "rig-browser-attach-info",
+  "rig-browser-e2e",
+  "rig-browser-reset-profile"
+];
+// packages/contracts/src/validation.ts
+var import_effect15 = require("effect");
+var ValidationStatus = import_effect15.Schema.Literals([
+  "pending",
+  "running",
+  "passed",
+  "failed",
+  "skipped"
+]);
+var ValidationSummary = import_effect15.Schema.Struct({
+  id: ValidationResultId,
+  runId: RunId,
+  taskId: import_effect15.Schema.NullOr(TaskId),
+  validatorKey: TrimmedNonEmptyString,
+  status: ValidationStatus,
+  output: import_effect15.Schema.Unknown,
+  startedAt: IsoDateTime,
+  completedAt: import_effect15.Schema.NullOr(IsoDateTime)
+});
+// packages/contracts/src/review.ts
+var import_effect16 = require("effect");
+var ReviewMode = import_effect16.Schema.Literals(["off", "advisory", "required"]);
+var ReviewStatus = import_effect16.Schema.Literals(["pending", "running", "approved", "rejected", "error"]);
+var ReviewSummary = import_effect16.Schema.Struct({
+  id: ReviewResultId,
+  runId: RunId,
+  taskId: import_effect16.Schema.NullOr(TaskId),
+  provider: TrimmedNonEmptyString,
+  mode: ReviewMode,
+  status: ReviewStatus,
+  summary: import_effect16.Schema.NullOr(import_effect16.Schema.String),
+  output: import_effect16.Schema.Unknown,
+  createdAt: IsoDateTime,
+  completedAt: import_effect16.Schema.NullOr(IsoDateTime)
+});
+// packages/contracts/src/artifact.ts
+var import_effect17 = require("effect");
+var ArtifactSummary = import_effect17.Schema.Struct({
+  id: ArtifactId,
+  runId: RunId,
+  taskId: import_effect17.Schema.NullOr(TaskId),
+  kind: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  path: import_effect17.Schema.NullOr(TrimmedNonEmptyString),
+  url: import_effect17.Schema.NullOr(TrimmedNonEmptyString),
+  metadata: import_effect17.Schema.Record(import_effect17.Schema.String, import_effect17.Schema.Unknown),
+  createdAt: IsoDateTime
+});
+// packages/contracts/src/remote.ts
+var import_effect18 = require("effect");
+var RemoteRuntimeAdapter = import_effect18.Schema.Literal("pi");
+var RemoteEndpoint = import_effect18.Schema.Struct({
+  id: RemoteEndpointId,
+  alias: TrimmedNonEmptyString,
+  host: TrimmedNonEmptyString,
+  port: import_effect18.Schema.Int.check(import_effect18.Schema.isGreaterThanOrEqualTo(1)).check(import_effect18.Schema.isLessThanOrEqualTo(65535)),
+  token: import_effect18.Schema.String,
+  tokenConfigured: import_effect18.Schema.optional(import_effect18.Schema.Boolean),
+  autoConnect: import_effect18.Schema.optional(import_effect18.Schema.Boolean),
+  addedAt: IsoDateTime,
+  lastConnectedAt: import_effect18.Schema.NullOr(IsoDateTime)
+});
+var RemoteConnectionStatus = import_effect18.Schema.Literals([
+  "disconnected",
+  "connecting",
+  "authenticating",
+  "connected",
+  "reconnecting",
+  "error"
+]);
+var RemoteConnectionSummary = import_effect18.Schema.Struct({
+  endpointId: RemoteEndpointId,
+  status: RemoteConnectionStatus,
+  error: import_effect18.Schema.NullOr(import_effect18.Schema.String),
+  connectedAt: import_effect18.Schema.NullOr(IsoDateTime),
+  tokenExpiresAt: import_effect18.Schema.NullOr(IsoDateTime),
+  latencyMs: import_effect18.Schema.NullOr(import_effect18.Schema.Number),
+  subscribedEvents: import_effect18.Schema.Array(import_effect18.Schema.String)
+});
+var RemoteConnectionStatusChanged = import_effect18.Schema.Struct({
+  endpointId: import_effect18.Schema.String,
+  endpointAlias: import_effect18.Schema.String,
+  status: RemoteConnectionStatus,
+  previousStatus: RemoteConnectionStatus,
+  error: import_effect18.Schema.NullOr(import_effect18.Schema.String),
+  connectedAt: import_effect18.Schema.NullOr(import_effect18.Schema.String),
+  latencyMs: import_effect18.Schema.NullOr(import_effect18.Schema.Number),
+  timestamp: import_effect18.Schema.String
+});
+var RemoteOrchestratorState = import_effect18.Schema.Struct({
+  activeTaskId: import_effect18.Schema.NullOr(import_effect18.Schema.String),
+  activeIteration: import_effect18.Schema.NullOr(import_effect18.Schema.Number),
+  maxIterations: import_effect18.Schema.Number,
+  isPaused: import_effect18.Schema.Boolean,
+  isRunning: import_effect18.Schema.Boolean,
+  totalCompleted: NonNegativeInt,
+  totalFailed: NonNegativeInt,
+  lastActivity: import_effect18.Schema.NullOr(IsoDateTime)
+});
+var RemoteOrchestrationSummary = import_effect18.Schema.Struct({
+  orchestrationId: TrimmedNonEmptyString,
+  endpointId: RemoteEndpointId,
+  status: import_effect18.Schema.Literals(["running", "paused", "stopped", "completed"]),
+  totalTasks: NonNegativeInt,
+  totalGroups: NonNegativeInt,
+  maxParallelism: NonNegativeInt,
+  startedAt: IsoDateTime
+});
+var RemoteIterationOutput = import_effect18.Schema.Struct({
+  taskId: import_effect18.Schema.optional(import_effect18.Schema.String),
+  iteration: import_effect18.Schema.optional(import_effect18.Schema.Number),
+  output: import_effect18.Schema.optional(import_effect18.Schema.String),
+  startedAt: import_effect18.Schema.optional(IsoDateTime),
+  endedAt: import_effect18.Schema.optional(IsoDateTime),
+  durationMs: import_effect18.Schema.optional(import_effect18.Schema.Number),
+  isRunning: import_effect18.Schema.optional(import_effect18.Schema.Boolean)
+});
+var RemoteRunnerRegisterInput = import_effect18.Schema.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  name: TrimmedNonEmptyString,
+  baseUrl: TrimmedNonEmptyString,
+  workspacePath: import_effect18.Schema.optional(TrimmedNonEmptyString),
+  transport: import_effect18.Schema.optional(TrimmedNonEmptyString),
+  hostname: import_effect18.Schema.optional(TrimmedNonEmptyString),
+  region: import_effect18.Schema.optional(TrimmedNonEmptyString),
+  labels: import_effect18.Schema.optional(import_effect18.Schema.Array(TrimmedNonEmptyString)),
+  capabilities: import_effect18.Schema.optional(import_effect18.Schema.Array(TrimmedNonEmptyString)),
+  runtimeAdapters: import_effect18.Schema.optional(import_effect18.Schema.Array(RemoteRuntimeAdapter)),
+  status: import_effect18.Schema.optional(WorkspaceRemoteHostStatus),
+  currentLeaseCount: import_effect18.Schema.optional(import_effect18.Schema.Number)
+});
+var RemoteRunnerHeartbeatInput = import_effect18.Schema.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  status: WorkspaceRemoteHostStatus,
+  currentLeaseCount: import_effect18.Schema.optional(import_effect18.Schema.Number),
+  observedAt: import_effect18.Schema.optional(IsoDateTime)
+});
+var RemoteRunnerLifecycleResult = import_effect18.Schema.Struct({
+  ok: import_effect18.Schema.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime,
+  heartbeatIntervalMs: import_effect18.Schema.Number
+});
+var RemoteRunClaimInput = import_effect18.Schema.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runtimeAdapters: import_effect18.Schema.optional(import_effect18.Schema.Array(RemoteRuntimeAdapter))
+});
+var RemoteRunLeaseSummary = import_effect18.Schema.Struct({
+  leaseId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  workspaceId: WorkspaceId,
+  title: TrimmedNonEmptyString,
+  runtimeAdapter: RemoteRuntimeAdapter,
+  model: import_effect18.Schema.NullOr(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  executionTarget: RunExecutionTarget,
+  remoteHostId: import_effect18.Schema.NullOr(TrimmedNonEmptyString),
+  claimedAt: IsoDateTime
+});
+var RemoteRunConversationEntry = import_effect18.Schema.Struct({
+  role: import_effect18.Schema.Literals(["user", "assistant", "system"]),
+  text: import_effect18.Schema.String,
+  createdAt: IsoDateTime
+});
+var RemoteRunExecutionBundle = import_effect18.Schema.Struct({
+  workspaceId: WorkspaceId,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  workspacePath: import_effect18.Schema.NullOr(TrimmedNonEmptyString),
+  runtimeAdapter: RemoteRuntimeAdapter,
+  model: import_effect18.Schema.NullOr(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  prompt: import_effect18.Schema.String,
+  conversation: import_effect18.Schema.Array(RemoteRunConversationEntry),
+  taskId: import_effect18.Schema.NullOr(TrimmedNonEmptyString),
+  taskTitle: import_effect18.Schema.NullOr(TrimmedNonEmptyString)
+});
+var RemoteRunClaimResult = import_effect18.Schema.Struct({
+  ok: import_effect18.Schema.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime,
+  lease: import_effect18.Schema.NullOr(RemoteRunLeaseSummary),
+  bundle: import_effect18.Schema.NullOr(RemoteRunExecutionBundle)
+});
+var RemoteRunReleaseInput = import_effect18.Schema.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  status: import_effect18.Schema.optional(WorkspaceRemoteHostStatus)
+});
+var RemoteRunReleaseResult = import_effect18.Schema.Struct({
+  ok: import_effect18.Schema.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime
+});
+var RemoteRunStartInput = import_effect18.Schema.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString
+});
+var RemoteRunStartResult = import_effect18.Schema.Struct({
+  ok: import_effect18.Schema.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  runtimeId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime
+});
+var RemoteRunLogInput = import_effect18.Schema.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  title: TrimmedNonEmptyString,
+  detail: import_effect18.Schema.optional(import_effect18.Schema.String),
+  tone: import_effect18.Schema.optional(EngineLogTone),
+  status: import_effect18.Schema.optional(TrimmedNonEmptyString),
+  payload: import_effect18.Schema.optional(import_effect18.Schema.Unknown)
+});
+var RemoteRunMessageInput = import_effect18.Schema.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  messageId: import_effect18.Schema.optional(TrimmedNonEmptyString),
+  text: import_effect18.Schema.String,
+  state: import_effect18.Schema.optional(import_effect18.Schema.Literals(["streaming", "completed"]))
+});
+var RemoteRunMutationResult = import_effect18.Schema.Struct({
+  ok: import_effect18.Schema.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime
+});
+var RemoteRunCompleteInput = import_effect18.Schema.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString
+});
+var RemoteRunFailInput = import_effect18.Schema.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  errorText: import_effect18.Schema.optional(import_effect18.Schema.String)
+});
+var RemoteRunArtifactInput = import_effect18.Schema.Struct({
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  kind: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  filename: TrimmedNonEmptyString,
+  contentType: TrimmedNonEmptyString,
+  contentBase64: TrimmedNonEmptyString
+});
+var RemoteRunArtifactResult = import_effect18.Schema.Struct({
+  ok: import_effect18.Schema.Boolean,
+  workspaceId: WorkspaceId,
+  hostId: TrimmedNonEmptyString,
+  runId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  acceptedAt: IsoDateTime,
+  artifactPath: TrimmedNonEmptyString
+});
+var RemoteRunArtifactSummary = import_effect18.Schema.Struct({
+  workspaceId: WorkspaceId,
+  runId: TrimmedNonEmptyString,
+  hostId: TrimmedNonEmptyString,
+  leaseId: TrimmedNonEmptyString,
+  kind: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  filename: TrimmedNonEmptyString,
+  contentType: TrimmedNonEmptyString,
+  uploadedAt: IsoDateTime,
+  byteSize: import_effect18.Schema.Number,
+  artifactPath: TrimmedNonEmptyString,
+  downloadPath: TrimmedNonEmptyString
+});
+var RemoteRunArtifactsResult = import_effect18.Schema.Struct({
+  workspaceId: WorkspaceId,
+  runId: TrimmedNonEmptyString,
+  artifacts: import_effect18.Schema.Array(RemoteRunArtifactSummary)
+});
+// packages/contracts/src/terminal.ts
+var import_effect19 = require("effect");
+var DEFAULT_TERMINAL_ID = "default";
+var TrimmedNonEmptyStringSchema = TrimmedNonEmptyString;
+var TerminalColsSchema = import_effect19.Schema.Int.check(import_effect19.Schema.isGreaterThanOrEqualTo(20)).check(import_effect19.Schema.isLessThanOrEqualTo(400));
+var TerminalRowsSchema = import_effect19.Schema.Int.check(import_effect19.Schema.isGreaterThanOrEqualTo(5)).check(import_effect19.Schema.isLessThanOrEqualTo(200));
+var TerminalIdSchema = TrimmedNonEmptyStringSchema.check(import_effect19.Schema.isMaxLength(128));
+var TerminalEnvKeySchema = import_effect19.Schema.String.check(import_effect19.Schema.isPattern(/^[A-Za-z_][A-Za-z0-9_]*$/)).check(import_effect19.Schema.isMaxLength(128));
+var TerminalEnvValueSchema = import_effect19.Schema.String.check(import_effect19.Schema.isMaxLength(8192));
+var TerminalEnvSchema = import_effect19.Schema.Record(TerminalEnvKeySchema, TerminalEnvValueSchema).check(import_effect19.Schema.isMaxProperties(128));
+var TerminalIdWithDefaultSchema = TerminalIdSchema.pipe(import_effect19.Schema.withDecodingDefault(() => DEFAULT_TERMINAL_ID));
+var TerminalThreadInput = import_effect19.Schema.Struct({
+  threadId: TrimmedNonEmptyStringSchema
+});
+var TerminalSessionInput = import_effect19.Schema.Struct({
+  ...TerminalThreadInput.fields,
+  terminalId: TerminalIdWithDefaultSchema
+});
+var TerminalOpenInput = import_effect19.Schema.Struct({
+  ...TerminalSessionInput.fields,
+  cwd: TrimmedNonEmptyStringSchema,
+  cols: import_effect19.Schema.optional(TerminalColsSchema),
+  rows: import_effect19.Schema.optional(TerminalRowsSchema),
+  env: import_effect19.Schema.optional(TerminalEnvSchema)
+});
+var TerminalWriteInput = import_effect19.Schema.Struct({
+  ...TerminalSessionInput.fields,
+  data: import_effect19.Schema.String.check(import_effect19.Schema.isNonEmpty()).check(import_effect19.Schema.isMaxLength(65536))
+});
+var TerminalResizeInput = import_effect19.Schema.Struct({
+  ...TerminalSessionInput.fields,
+  cols: TerminalColsSchema,
+  rows: TerminalRowsSchema
+});
+var TerminalClearInput = TerminalSessionInput;
+var TerminalRestartInput = import_effect19.Schema.Struct({
+  ...TerminalThreadInput.fields,
+  cwd: TrimmedNonEmptyStringSchema,
+  cols: TerminalColsSchema,
+  rows: TerminalRowsSchema,
+  env: import_effect19.Schema.optional(TerminalEnvSchema)
+});
+var TerminalCloseInput = import_effect19.Schema.Struct({
+  ...TerminalThreadInput.fields,
+  terminalId: import_effect19.Schema.optional(TerminalIdSchema),
+  deleteHistory: import_effect19.Schema.optional(import_effect19.Schema.Boolean)
+});
+var TerminalSessionStatus = import_effect19.Schema.Literals(["starting", "running", "exited", "error"]);
+var TerminalSessionSnapshot = import_effect19.Schema.Struct({
+  threadId: import_effect19.Schema.String.check(import_effect19.Schema.isNonEmpty()),
+  terminalId: import_effect19.Schema.String.check(import_effect19.Schema.isNonEmpty()),
+  cwd: import_effect19.Schema.String.check(import_effect19.Schema.isNonEmpty()),
+  status: TerminalSessionStatus,
+  pid: import_effect19.Schema.NullOr(import_effect19.Schema.Int.check(import_effect19.Schema.isGreaterThan(0))),
+  history: import_effect19.Schema.String,
+  exitCode: import_effect19.Schema.NullOr(import_effect19.Schema.Int),
+  exitSignal: import_effect19.Schema.NullOr(import_effect19.Schema.String),
+  updatedAt: import_effect19.Schema.String
+});
+var TerminalEventBaseSchema = import_effect19.Schema.Struct({
+  threadId: import_effect19.Schema.String.check(import_effect19.Schema.isNonEmpty()),
+  terminalId: import_effect19.Schema.String.check(import_effect19.Schema.isNonEmpty()),
+  createdAt: import_effect19.Schema.String
+});
+var TerminalStartedEvent = import_effect19.Schema.Struct({
+  ...TerminalEventBaseSchema.fields,
+  type: import_effect19.Schema.Literal("started"),
+  snapshot: TerminalSessionSnapshot
+});
+var TerminalOutputEvent = import_effect19.Schema.Struct({
+  ...TerminalEventBaseSchema.fields,
+  type: import_effect19.Schema.Literal("output"),
+  data: import_effect19.Schema.String
+});
+var TerminalExitedEvent = import_effect19.Schema.Struct({
+  ...TerminalEventBaseSchema.fields,
+  type: import_effect19.Schema.Literal("exited"),
+  exitCode: import_effect19.Schema.NullOr(import_effect19.Schema.Int),
+  exitSignal: import_effect19.Schema.NullOr(import_effect19.Schema.String)
+});
+var TerminalErrorEvent = import_effect19.Schema.Struct({
+  ...TerminalEventBaseSchema.fields,
+  type: import_effect19.Schema.Literal("error"),
+  message: import_effect19.Schema.String.check(import_effect19.Schema.isNonEmpty())
+});
+var TerminalClearedEvent = import_effect19.Schema.Struct({
+  ...TerminalEventBaseSchema.fields,
+  type: import_effect19.Schema.Literal("cleared")
+});
+var TerminalRestartedEvent = import_effect19.Schema.Struct({
+  ...TerminalEventBaseSchema.fields,
+  type: import_effect19.Schema.Literal("restarted"),
+  snapshot: TerminalSessionSnapshot
+});
+var TerminalActivityEvent = import_effect19.Schema.Struct({
+  ...TerminalEventBaseSchema.fields,
+  type: import_effect19.Schema.Literal("activity"),
+  hasRunningSubprocess: import_effect19.Schema.Boolean
+});
+var TerminalEvent = import_effect19.Schema.Union([
+  TerminalStartedEvent,
+  TerminalOutputEvent,
+  TerminalExitedEvent,
+  TerminalErrorEvent,
+  TerminalClearedEvent,
+  TerminalRestartedEvent,
+  TerminalActivityEvent
+]);
+// packages/contracts/src/provider.ts
+var import_effect21 = require("effect");
+
+// packages/contracts/src/model.ts
+var import_effect20 = require("effect");
+var CODEX_REASONING_EFFORT_OPTIONS = ["xhigh", "high", "medium", "low"];
+var CodexModelOptions = import_effect20.Schema.Struct({
+  reasoningEffort: import_effect20.Schema.optional(import_effect20.Schema.Literals(CODEX_REASONING_EFFORT_OPTIONS)),
+  fastMode: import_effect20.Schema.optional(import_effect20.Schema.Boolean)
+});
+var ClaudeModelOptions = import_effect20.Schema.Struct({});
+var ProviderModelOptions = import_effect20.Schema.Struct({
+  codex: import_effect20.Schema.optional(CodexModelOptions),
+  claude: import_effect20.Schema.optional(ClaudeModelOptions)
+});
+var MODEL_OPTIONS_BY_PROVIDER = {
+  codex: [
+    { slug: "gpt-5.4", name: "GPT-5.4" },
+    { slug: "gpt-5.3-codex", name: "GPT-5.3 Codex" },
+    { slug: "gpt-5.3-codex-spark", name: "GPT-5.3 Codex Spark" },
+    { slug: "gpt-5.2-codex", name: "GPT-5.2 Codex" },
+    { slug: "gpt-5.2", name: "GPT-5.2" }
+  ],
+  claude: [
+    { slug: "claude-sonnet-4-6", name: "Claude Sonnet 4.6" },
+    { slug: "claude-opus-4-1", name: "Claude Opus 4.1" },
+    { slug: "claude-3-7-sonnet-latest", name: "Claude 3.7 Sonnet" }
+  ]
+};
+var DEFAULT_MODEL_BY_PROVIDER = {
+  codex: "gpt-5.4",
+  claude: "claude-sonnet-4-6"
+};
+var MODEL_SLUG_ALIASES_BY_PROVIDER = {
+  codex: {
+    "5.4": "gpt-5.4",
+    "5.3": "gpt-5.3-codex",
+    "gpt-5.3": "gpt-5.3-codex",
+    "5.3-spark": "gpt-5.3-codex-spark",
+    "gpt-5.3-spark": "gpt-5.3-codex-spark"
+  },
+  claude: {
+    sonnet: "claude-sonnet-4-6",
+    opus: "claude-opus-4-1",
+    "3.7-sonnet": "claude-3-7-sonnet-latest"
+  }
+};
+var REASONING_EFFORT_OPTIONS_BY_PROVIDER = {
+  codex: CODEX_REASONING_EFFORT_OPTIONS,
+  claude: []
+};
+var DEFAULT_REASONING_EFFORT_BY_PROVIDER = {
+  codex: "high",
+  claude: null
+};
+
+// packages/contracts/src/provider.ts
+var TrimmedNonEmptyStringSchema2 = TrimmedNonEmptyString;
+var ProviderSessionStatus = import_effect21.Schema.Literals([
+  "connecting",
+  "ready",
+  "running",
+  "error",
+  "closed"
+]);
+var ProviderSession = import_effect21.Schema.Struct({
+  provider: ProviderKind,
+  status: ProviderSessionStatus,
+  runtimeMode: RuntimeMode,
+  cwd: import_effect21.Schema.optional(TrimmedNonEmptyStringSchema2),
+  model: import_effect21.Schema.optional(TrimmedNonEmptyStringSchema2),
+  threadId: ThreadId,
+  resumeCursor: import_effect21.Schema.optional(import_effect21.Schema.Unknown),
+  activeTurnId: import_effect21.Schema.optional(TurnId),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  lastError: import_effect21.Schema.optional(TrimmedNonEmptyStringSchema2)
+});
+var CodexProviderStartOptions = import_effect21.Schema.Struct({
+  binaryPath: import_effect21.Schema.optional(TrimmedNonEmptyStringSchema2),
+  homePath: import_effect21.Schema.optional(TrimmedNonEmptyStringSchema2)
+});
+var ProviderStartOptions = import_effect21.Schema.Struct({
+  codex: import_effect21.Schema.optional(CodexProviderStartOptions)
+});
+var ProviderSessionStartInput = import_effect21.Schema.Struct({
+  threadId: ThreadId,
+  provider: import_effect21.Schema.optional(ProviderKind),
+  cwd: import_effect21.Schema.optional(TrimmedNonEmptyStringSchema2),
+  model: import_effect21.Schema.optional(TrimmedNonEmptyStringSchema2),
+  modelOptions: import_effect21.Schema.optional(ProviderModelOptions),
+  resumeCursor: import_effect21.Schema.optional(import_effect21.Schema.Unknown),
+  serviceTier: import_effect21.Schema.optional(import_effect21.Schema.NullOr(ProviderServiceTier)),
+  approvalPolicy: import_effect21.Schema.optional(ProviderApprovalPolicy),
+  sandboxMode: import_effect21.Schema.optional(ProviderSandboxMode),
+  providerOptions: import_effect21.Schema.optional(ProviderStartOptions),
+  runtimeMode: RuntimeMode
+});
+var ProviderSendTurnInput = import_effect21.Schema.Struct({
+  threadId: ThreadId,
+  input: import_effect21.Schema.optional(TrimmedNonEmptyStringSchema2.check(import_effect21.Schema.isMaxLength(PROVIDER_SEND_TURN_MAX_INPUT_CHARS))),
+  attachments: import_effect21.Schema.optional(import_effect21.Schema.Array(ChatAttachment).check(import_effect21.Schema.isMaxLength(PROVIDER_SEND_TURN_MAX_ATTACHMENTS))),
+  model: import_effect21.Schema.optional(TrimmedNonEmptyStringSchema2),
+  serviceTier: import_effect21.Schema.optional(import_effect21.Schema.NullOr(ProviderServiceTier)),
+  modelOptions: import_effect21.Schema.optional(ProviderModelOptions),
+  interactionMode: import_effect21.Schema.optional(ProviderInteractionMode)
+});
+var ProviderTurnStartResult = import_effect21.Schema.Struct({
+  threadId: ThreadId,
+  turnId: TurnId,
+  resumeCursor: import_effect21.Schema.optional(import_effect21.Schema.Unknown)
+});
+var ProviderInterruptTurnInput = import_effect21.Schema.Struct({
+  threadId: ThreadId,
+  turnId: import_effect21.Schema.optional(TurnId)
+});
+var ProviderStopSessionInput = import_effect21.Schema.Struct({
+  threadId: ThreadId
+});
+var ProviderRespondToRequestInput = import_effect21.Schema.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision
+});
+var ProviderRespondToUserInputInput = import_effect21.Schema.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers
+});
+var ProviderEventKind = import_effect21.Schema.Literals(["session", "notification", "request", "error"]);
+var ProviderEvent = import_effect21.Schema.Struct({
+  id: EventId,
+  kind: ProviderEventKind,
+  provider: ProviderKind,
+  threadId: ThreadId,
+  createdAt: IsoDateTime,
+  method: TrimmedNonEmptyStringSchema2,
+  message: import_effect21.Schema.optional(TrimmedNonEmptyStringSchema2),
+  turnId: import_effect21.Schema.optional(TurnId),
+  itemId: import_effect21.Schema.optional(ProviderItemId),
+  requestId: import_effect21.Schema.optional(ApprovalRequestId),
+  requestKind: import_effect21.Schema.optional(ProviderRequestKind),
+  textDelta: import_effect21.Schema.optional(import_effect21.Schema.String),
+  payload: import_effect21.Schema.optional(import_effect21.Schema.Unknown)
+});
+// packages/contracts/src/keybindings.ts
+var import_effect22 = require("effect");
+var MAX_KEYBINDING_VALUE_LENGTH = 64;
+var MAX_KEYBINDING_WHEN_LENGTH = 256;
+var MAX_WHEN_EXPRESSION_DEPTH = 64;
+var MAX_SCRIPT_ID_LENGTH = 24;
+var MAX_KEYBINDINGS_COUNT = 256;
+var STATIC_KEYBINDING_COMMANDS = [
+  "terminal.toggle",
+  "terminal.split",
+  "terminal.new",
+  "terminal.close",
+  "diff.toggle",
+  "chat.new",
+  "chat.newLocal",
+  "editor.openFavorite"
+];
+var SCRIPT_RUN_COMMAND_PATTERN = import_effect22.Schema.TemplateLiteral([
+  import_effect22.Schema.Literal("script."),
+  import_effect22.Schema.NonEmptyString.check(import_effect22.Schema.isMaxLength(MAX_SCRIPT_ID_LENGTH), import_effect22.Schema.isPattern(/^[a-z0-9][a-z0-9-]*$/)),
+  import_effect22.Schema.Literal(".run")
+]);
+var KeybindingCommand = import_effect22.Schema.Union([
+  import_effect22.Schema.Literals(STATIC_KEYBINDING_COMMANDS),
+  SCRIPT_RUN_COMMAND_PATTERN
+]);
+var KeybindingValue = TrimmedString.check(import_effect22.Schema.isMinLength(1), import_effect22.Schema.isMaxLength(MAX_KEYBINDING_VALUE_LENGTH));
+var KeybindingWhen = TrimmedString.check(import_effect22.Schema.isMinLength(1), import_effect22.Schema.isMaxLength(MAX_KEYBINDING_WHEN_LENGTH));
+var KeybindingRule = import_effect22.Schema.Struct({
+  key: KeybindingValue,
+  command: KeybindingCommand,
+  when: import_effect22.Schema.optional(KeybindingWhen)
+});
+var KeybindingsConfig = import_effect22.Schema.Array(KeybindingRule).check(import_effect22.Schema.isMaxLength(MAX_KEYBINDINGS_COUNT));
+var KeybindingShortcut = import_effect22.Schema.Struct({
+  key: KeybindingValue,
+  metaKey: import_effect22.Schema.Boolean,
+  ctrlKey: import_effect22.Schema.Boolean,
+  shiftKey: import_effect22.Schema.Boolean,
+  altKey: import_effect22.Schema.Boolean,
+  modKey: import_effect22.Schema.Boolean
+});
+var KeybindingWhenNode = import_effect22.Schema.Union([
+  import_effect22.Schema.Struct({
+    type: import_effect22.Schema.Literal("identifier"),
+    name: import_effect22.Schema.NonEmptyString
+  }),
+  import_effect22.Schema.Struct({
+    type: import_effect22.Schema.Literal("not"),
+    node: import_effect22.Schema.suspend(() => KeybindingWhenNode)
+  }),
+  import_effect22.Schema.Struct({
+    type: import_effect22.Schema.Literal("and"),
+    left: import_effect22.Schema.suspend(() => KeybindingWhenNode),
+    right: import_effect22.Schema.suspend(() => KeybindingWhenNode)
+  }),
+  import_effect22.Schema.Struct({
+    type: import_effect22.Schema.Literal("or"),
+    left: import_effect22.Schema.suspend(() => KeybindingWhenNode),
+    right: import_effect22.Schema.suspend(() => KeybindingWhenNode)
+  })
+]);
+var ResolvedKeybindingRule = import_effect22.Schema.Struct({
+  command: KeybindingCommand,
+  shortcut: KeybindingShortcut,
+  whenAst: import_effect22.Schema.optional(KeybindingWhenNode)
+}).annotate({ parseOptions: { onExcessProperty: "ignore" } });
+var ResolvedKeybindingsConfig = import_effect22.Schema.Array(ResolvedKeybindingRule).check(import_effect22.Schema.isMaxLength(MAX_KEYBINDINGS_COUNT));
+// packages/contracts/src/git.ts
+var import_effect23 = require("effect");
+var TrimmedNonEmptyStringSchema3 = TrimmedNonEmptyString;
+var GitStackedAction = import_effect23.Schema.Literals(["commit", "commit_push", "commit_push_pr"]);
+var GitCommitStepStatus = import_effect23.Schema.Literals(["created", "skipped_no_changes"]);
+var GitPushStepStatus = import_effect23.Schema.Literals([
+  "pushed",
+  "skipped_not_requested",
+  "skipped_up_to_date"
+]);
+var GitBranchStepStatus = import_effect23.Schema.Literals(["created", "skipped_not_requested"]);
+var GitPrStepStatus = import_effect23.Schema.Literals([
+  "created",
+  "opened_existing",
+  "skipped_not_requested"
+]);
+var GitStatusPrState = import_effect23.Schema.Literals(["open", "closed", "merged"]);
+var GitBranch = import_effect23.Schema.Struct({
+  name: TrimmedNonEmptyStringSchema3,
+  isRemote: import_effect23.Schema.optional(import_effect23.Schema.Boolean),
+  remoteName: import_effect23.Schema.optional(TrimmedNonEmptyStringSchema3),
+  current: import_effect23.Schema.Boolean,
+  isDefault: import_effect23.Schema.Boolean,
+  worktreePath: TrimmedNonEmptyStringSchema3.pipe(import_effect23.Schema.NullOr)
+});
+var GitWorktree = import_effect23.Schema.Struct({
+  path: TrimmedNonEmptyStringSchema3,
+  branch: TrimmedNonEmptyStringSchema3
+});
+var GitStatusInput = import_effect23.Schema.Struct({
+  cwd: TrimmedNonEmptyStringSchema3
+});
+var GitPullInput = import_effect23.Schema.Struct({
+  cwd: TrimmedNonEmptyStringSchema3
+});
+var GitReadWorkingTreePatchInput = import_effect23.Schema.Struct({
+  cwd: TrimmedNonEmptyStringSchema3,
+  relativePath: import_effect23.Schema.optional(TrimmedNonEmptyStringSchema3)
+});
+var GitRunStackedActionInput = import_effect23.Schema.Struct({
+  cwd: TrimmedNonEmptyStringSchema3,
+  action: GitStackedAction,
+  commitMessage: import_effect23.Schema.optional(TrimmedNonEmptyStringSchema3.check(import_effect23.Schema.isMaxLength(1e4))),
+  featureBranch: import_effect23.Schema.optional(import_effect23.Schema.Boolean)
+});
+var GitListBranchesInput = import_effect23.Schema.Struct({
+  cwd: TrimmedNonEmptyStringSchema3
+});
+var GitCreateWorktreeInput = import_effect23.Schema.Struct({
+  cwd: TrimmedNonEmptyStringSchema3,
+  branch: TrimmedNonEmptyStringSchema3,
+  newBranch: TrimmedNonEmptyStringSchema3,
+  path: import_effect23.Schema.NullOr(TrimmedNonEmptyStringSchema3)
+});
+var GitRemoveWorktreeInput = import_effect23.Schema.Struct({
+  cwd: TrimmedNonEmptyStringSchema3,
+  path: TrimmedNonEmptyStringSchema3,
+  force: import_effect23.Schema.optional(import_effect23.Schema.Boolean)
+});
+var GitCreateBranchInput = import_effect23.Schema.Struct({
+  cwd: TrimmedNonEmptyStringSchema3,
+  branch: TrimmedNonEmptyStringSchema3
+});
+var GitCheckoutInput = import_effect23.Schema.Struct({
+  cwd: TrimmedNonEmptyStringSchema3,
+  branch: TrimmedNonEmptyStringSchema3
+});
+var GitInitInput = import_effect23.Schema.Struct({
+  cwd: TrimmedNonEmptyStringSchema3
+});
+var GitStatusPr = import_effect23.Schema.Struct({
+  number: PositiveInt,
+  title: TrimmedNonEmptyStringSchema3,
+  url: import_effect23.Schema.String,
+  baseBranch: TrimmedNonEmptyStringSchema3,
+  headBranch: TrimmedNonEmptyStringSchema3,
+  state: GitStatusPrState
+});
+var GitStatusResult = import_effect23.Schema.Struct({
+  branch: TrimmedNonEmptyStringSchema3.pipe(import_effect23.Schema.NullOr),
+  hasWorkingTreeChanges: import_effect23.Schema.Boolean,
+  workingTree: import_effect23.Schema.Struct({
+    files: import_effect23.Schema.Array(import_effect23.Schema.Struct({
+      path: TrimmedNonEmptyStringSchema3,
+      insertions: NonNegativeInt,
+      deletions: NonNegativeInt
+    })),
+    insertions: NonNegativeInt,
+    deletions: NonNegativeInt
+  }),
+  hasUpstream: import_effect23.Schema.Boolean,
+  aheadCount: NonNegativeInt,
+  behindCount: NonNegativeInt,
+  pr: import_effect23.Schema.NullOr(GitStatusPr)
+});
+var GitListBranchesResult = import_effect23.Schema.Struct({
+  branches: import_effect23.Schema.Array(GitBranch),
+  isRepo: import_effect23.Schema.Boolean
+});
+var GitCreateWorktreeResult = import_effect23.Schema.Struct({
+  worktree: GitWorktree
+});
+var GitRunStackedActionResult = import_effect23.Schema.Struct({
+  action: GitStackedAction,
+  branch: import_effect23.Schema.Struct({
+    status: GitBranchStepStatus,
+    name: import_effect23.Schema.optional(TrimmedNonEmptyStringSchema3)
+  }),
+  commit: import_effect23.Schema.Struct({
+    status: GitCommitStepStatus,
+    commitSha: import_effect23.Schema.optional(TrimmedNonEmptyStringSchema3),
+    subject: import_effect23.Schema.optional(TrimmedNonEmptyStringSchema3)
+  }),
+  push: import_effect23.Schema.Struct({
+    status: GitPushStepStatus,
+    branch: import_effect23.Schema.optional(TrimmedNonEmptyStringSchema3),
+    upstreamBranch: import_effect23.Schema.optional(TrimmedNonEmptyStringSchema3),
+    setUpstream: import_effect23.Schema.optional(import_effect23.Schema.Boolean)
+  }),
+  pr: import_effect23.Schema.Struct({
+    status: GitPrStepStatus,
+    url: import_effect23.Schema.optional(import_effect23.Schema.String),
+    number: import_effect23.Schema.optional(PositiveInt),
+    baseBranch: import_effect23.Schema.optional(TrimmedNonEmptyStringSchema3),
+    headBranch: import_effect23.Schema.optional(TrimmedNonEmptyStringSchema3),
+    title: import_effect23.Schema.optional(TrimmedNonEmptyStringSchema3)
+  })
+});
+var GitPullResult = import_effect23.Schema.Struct({
+  status: import_effect23.Schema.Literals(["pulled", "skipped_up_to_date"]),
+  branch: TrimmedNonEmptyStringSchema3,
+  upstreamBranch: TrimmedNonEmptyStringSchema3.pipe(import_effect23.Schema.NullOr)
+});
+var GitReadWorkingTreePatchResult = import_effect23.Schema.Struct({
+  diff: import_effect23.Schema.String
+});
+// packages/contracts/src/editor.ts
+var import_effect24 = require("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 = import_effect24.Schema.Literals(EDITORS.map((e) => e.id));
+var OpenInEditorInput = import_effect24.Schema.Struct({
+  cwd: TrimmedNonEmptyString,
+  editor: EditorId
+});
+// packages/contracts/src/project.ts
+var import_effect25 = require("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 = import_effect25.Schema.Struct({
+  cwd: TrimmedNonEmptyString,
+  query: TrimmedNonEmptyString.check(import_effect25.Schema.isMaxLength(256)),
+  limit: PositiveInt.check(import_effect25.Schema.isLessThanOrEqualTo(PROJECT_SEARCH_ENTRIES_MAX_LIMIT))
+});
+var ProjectEntryKind = import_effect25.Schema.Literals(["file", "directory"]);
+var ProjectEntry = import_effect25.Schema.Struct({
+  path: TrimmedNonEmptyString,
+  kind: ProjectEntryKind,
+  parentPath: import_effect25.Schema.optional(TrimmedNonEmptyString)
+});
+var ProjectSearchEntriesResult = import_effect25.Schema.Struct({
+  entries: import_effect25.Schema.Array(ProjectEntry),
+  truncated: import_effect25.Schema.Boolean
+});
+var ProjectListDirectoryInput = import_effect25.Schema.Struct({
+  cwd: TrimmedNonEmptyString,
+  relativePath: TrimmedNonEmptyString.check(import_effect25.Schema.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH)),
+  limit: PositiveInt.check(import_effect25.Schema.isLessThanOrEqualTo(PROJECT_LIST_DIRECTORY_MAX_LIMIT))
+});
+var ProjectDirectoryEntry = import_effect25.Schema.Struct({
+  name: TrimmedNonEmptyString,
+  relativePath: TrimmedNonEmptyString,
+  kind: ProjectEntryKind,
+  sizeBytes: import_effect25.Schema.optional(NonNegativeInt),
+  modifiedAt: import_effect25.Schema.optional(import_effect25.Schema.String)
+});
+var ProjectListDirectoryResult = import_effect25.Schema.Struct({
+  entries: import_effect25.Schema.Array(ProjectDirectoryEntry),
+  truncated: import_effect25.Schema.Boolean
+});
+var ProjectWriteFileInput = import_effect25.Schema.Struct({
+  cwd: TrimmedNonEmptyString,
+  relativePath: TrimmedNonEmptyString.check(import_effect25.Schema.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH)),
+  contents: import_effect25.Schema.String
+});
+var ProjectWriteFileResult = import_effect25.Schema.Struct({
+  relativePath: TrimmedNonEmptyString
+});
+var ProjectReadFileInput = import_effect25.Schema.Struct({
+  cwd: TrimmedNonEmptyString,
+  relativePath: TrimmedNonEmptyString.check(import_effect25.Schema.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH))
+});
+var ProjectReadFileResult = import_effect25.Schema.Struct({
+  relativePath: TrimmedNonEmptyString,
+  contents: import_effect25.Schema.String,
+  truncated: import_effect25.Schema.Boolean,
+  sizeBytes: NonNegativeInt,
+  maxBytes: PositiveInt
+});
+var PROJECT_READ_FILE_MAX_BYTES_VALUE = PROJECT_READ_FILE_MAX_BYTES;
+// packages/contracts/src/setup.ts
+var PROJECT_SETUP_CAPABILITY_ID = "cap:project-setup";
+var PROJECT_SETUP = makeCapabilityId(PROJECT_SETUP_CAPABILITY_ID);
+// packages/contracts/src/host.ts
+var HOST_RUN_CAPABILITY_ID = "cap:host-run";
+var HOST_RUN = makeCapabilityId(HOST_RUN_CAPABILITY_ID);
+// packages/contracts/src/run-identity.ts
+var RUN_IDENTITY_ENV_CAPABILITY_ID = "cap:run-identity-env";
+var RUN_IDENTITY_ENV = makeCapabilityId(RUN_IDENTITY_ENV_CAPABILITY_ID);
+// packages/contracts/src/prompt.ts
+var PRIOR_PROGRESS_PROMPT_CAPABILITY_ID = "prompt.prior-progress";
+var PRIOR_PROGRESS_PROMPT = makeCapabilityId(PRIOR_PROGRESS_PROMPT_CAPABILITY_ID);
+// packages/contracts/src/task-source.ts
+var TASK_IO_SERVICE_CAPABILITY_ID = "task-sources.task-io";
+var TASK_IO_SERVICE_CAPABILITY = makeCapabilityId(TASK_IO_SERVICE_CAPABILITY_ID);
+// packages/contracts/src/task-data.ts
+var TASK_DATA_SERVICE_CAPABILITY_ID = "task-sources.task-data";
+var TASK_DATA_SERVICE_CAPABILITY = makeCapabilityId(TASK_DATA_SERVICE_CAPABILITY_ID);
+// packages/contracts/src/cli-output.ts
+var import_effect26 = require("effect");
+var CLI_OUTPUT_VERSION = 1;
+var RigCliOutputEnvelope = import_effect26.Schema.Struct({
+  v: import_effect26.Schema.Literal(1),
+  command: import_effect26.Schema.String,
+  data: import_effect26.Schema.Unknown
+});
+var CliTaskSummary = import_effect26.Schema.Struct({
+  id: import_effect26.Schema.NullOr(import_effect26.Schema.String),
+  title: import_effect26.Schema.NullOr(import_effect26.Schema.String),
+  status: import_effect26.Schema.NullOr(import_effect26.Schema.String),
+  source: import_effect26.Schema.optional(import_effect26.Schema.String),
+  url: import_effect26.Schema.optional(import_effect26.Schema.String),
+  number: import_effect26.Schema.optional(import_effect26.Schema.Number),
+  labels: import_effect26.Schema.optional(import_effect26.Schema.Array(import_effect26.Schema.Unknown)),
+  assignees: import_effect26.Schema.optional(import_effect26.Schema.Array(import_effect26.Schema.Unknown)),
+  readiness: import_effect26.Schema.optional(import_effect26.Schema.Union([import_effect26.Schema.String, import_effect26.Schema.Boolean])),
+  validators: import_effect26.Schema.optional(import_effect26.Schema.Array(import_effect26.Schema.Unknown)),
+  raw: import_effect26.Schema.optional(import_effect26.Schema.Unknown)
+});
+var CliTaskFilters = import_effect26.Schema.Struct({
+  assignee: import_effect26.Schema.optional(import_effect26.Schema.String),
+  state: import_effect26.Schema.optional(import_effect26.Schema.String),
+  status: import_effect26.Schema.optional(import_effect26.Schema.String),
+  limit: import_effect26.Schema.optional(import_effect26.Schema.Number)
+});
+var CliRunRecord = import_effect26.Schema.Record(import_effect26.Schema.String, import_effect26.Schema.Unknown);
+var CliInboxRecord = import_effect26.Schema.Record(import_effect26.Schema.String, import_effect26.Schema.Unknown);
+var CliDoctorCheck = import_effect26.Schema.Struct({
+  id: import_effect26.Schema.String,
+  label: import_effect26.Schema.String,
+  status: import_effect26.Schema.Literals(["pass", "warn", "fail"]),
+  detail: import_effect26.Schema.optional(import_effect26.Schema.String),
+  remediation: import_effect26.Schema.optional(import_effect26.Schema.String)
+});
+var CliServerConnection = import_effect26.Schema.Union([
+  import_effect26.Schema.Struct({ kind: import_effect26.Schema.Literal("local"), mode: import_effect26.Schema.Literal("auto") }),
+  import_effect26.Schema.Struct({ kind: import_effect26.Schema.Literal("remote"), baseUrl: import_effect26.Schema.String })
+]);
+var CliRepoConnectionState = import_effect26.Schema.Struct({
+  selected: import_effect26.Schema.String,
+  project: import_effect26.Schema.optional(import_effect26.Schema.String),
+  linkedAt: import_effect26.Schema.optional(import_effect26.Schema.String),
+  serverProjectRoot: import_effect26.Schema.optional(import_effect26.Schema.String),
+  serverProjectRootAlias: import_effect26.Schema.optional(import_effect26.Schema.String),
+  serverProjectRootBaseUrl: import_effect26.Schema.optional(import_effect26.Schema.String)
+});
+var CliRemoteProjectLink = import_effect26.Schema.Struct({
+  ok: import_effect26.Schema.Boolean,
+  status: import_effect26.Schema.String,
+  alias: import_effect26.Schema.optional(import_effect26.Schema.String),
+  baseUrl: import_effect26.Schema.optional(import_effect26.Schema.String),
+  repoSlug: import_effect26.Schema.optional(import_effect26.Schema.String),
+  serverProjectRoot: import_effect26.Schema.optional(import_effect26.Schema.String),
+  source: import_effect26.Schema.optional(import_effect26.Schema.String),
+  prepared: import_effect26.Schema.optional(import_effect26.Schema.Boolean),
+  validated: import_effect26.Schema.optional(import_effect26.Schema.Boolean),
+  statusCode: import_effect26.Schema.optional(import_effect26.Schema.Number),
+  message: import_effect26.Schema.String,
+  hint: import_effect26.Schema.String,
+  next: import_effect26.Schema.optional(import_effect26.Schema.String),
+  skippedCandidates: import_effect26.Schema.optional(import_effect26.Schema.Array(import_effect26.Schema.String))
+});
+var RigTaskListOutput = import_effect26.Schema.Struct({
+  v: import_effect26.Schema.Literal(1),
+  command: import_effect26.Schema.Literal("task list"),
+  data: import_effect26.Schema.Struct({
+    count: import_effect26.Schema.Number,
+    filters: CliTaskFilters,
+    raw: import_effect26.Schema.Boolean,
+    tasks: import_effect26.Schema.Array(CliTaskSummary)
+  })
+});
+var RigTaskShowOutput = import_effect26.Schema.Struct({
+  v: import_effect26.Schema.Literal(1),
+  command: import_effect26.Schema.Literal("task show"),
+  data: import_effect26.Schema.Struct({
+    task: CliTaskSummary,
+    raw: import_effect26.Schema.Boolean
+  })
+});
+var RigRunListOutput = import_effect26.Schema.Struct({
+  v: import_effect26.Schema.Literal(1),
+  command: import_effect26.Schema.Literal("run list"),
+  data: import_effect26.Schema.Struct({
+    runs: import_effect26.Schema.Array(CliRunRecord),
+    source: import_effect26.Schema.Literals(["local", "server"])
+  })
+});
+var RigRunShowOutput = import_effect26.Schema.Struct({
+  v: import_effect26.Schema.Literal(1),
+  command: import_effect26.Schema.Literal("run show"),
+  data: CliRunRecord
+});
+var RigServerUseOutput = import_effect26.Schema.Struct({
+  v: import_effect26.Schema.Literal(1),
+  command: import_effect26.Schema.Literal("server use"),
+  data: import_effect26.Schema.Struct({
+    selected: import_effect26.Schema.String,
+    repo: import_effect26.Schema.NullOr(CliRepoConnectionState),
+    remoteProjectLink: import_effect26.Schema.NullOr(CliRemoteProjectLink)
+  })
+});
+var RigServerStatusOutput = import_effect26.Schema.Struct({
+  v: import_effect26.Schema.Literal(1),
+  command: import_effect26.Schema.Literal("server status"),
+  data: import_effect26.Schema.Struct({
+    selected: import_effect26.Schema.String,
+    repo: import_effect26.Schema.NullOr(CliRepoConnectionState),
+    connections: import_effect26.Schema.Record(import_effect26.Schema.String, CliServerConnection),
+    remoteProjectLink: import_effect26.Schema.NullOr(CliRemoteProjectLink)
+  })
+});
+var RigServerRepairLinkOutput = import_effect26.Schema.Struct({
+  v: import_effect26.Schema.Literal(1),
+  command: import_effect26.Schema.Literal("server repair-link"),
+  data: CliRemoteProjectLink
+});
+var RigInboxApprovalsOutput = import_effect26.Schema.Struct({
+  v: import_effect26.Schema.Literal(1),
+  command: import_effect26.Schema.Literal("inbox approvals"),
+  data: import_effect26.Schema.Struct({
+    approvals: import_effect26.Schema.Array(CliInboxRecord)
+  })
+});
+var RigInboxInputsOutput = import_effect26.Schema.Struct({
+  v: import_effect26.Schema.Literal(1),
+  command: import_effect26.Schema.Literal("inbox inputs"),
+  data: import_effect26.Schema.Struct({
+    requests: import_effect26.Schema.Array(CliInboxRecord)
+  })
+});
+var RigDoctorCheckOutput = import_effect26.Schema.Struct({
+  v: import_effect26.Schema.Literal(1),
+  command: import_effect26.Schema.Literal("doctor check"),
+  data: import_effect26.Schema.Struct({
+    checks: import_effect26.Schema.Array(CliDoctorCheck),
+    failures: import_effect26.Schema.Number
+  })
+});
+var RigStatsData = import_effect26.Schema.Struct({
+  since: import_effect26.Schema.NullOr(import_effect26.Schema.String),
+  totalRuns: import_effect26.Schema.Number,
+  statusCounts: import_effect26.Schema.Record(import_effect26.Schema.String, import_effect26.Schema.Number),
+  completedRuns: import_effect26.Schema.Number,
+  failedRuns: import_effect26.Schema.Number,
+  needsAttentionRuns: import_effect26.Schema.Number,
+  completionRate: import_effect26.Schema.NullOr(import_effect26.Schema.Number),
+  failureRate: import_effect26.Schema.NullOr(import_effect26.Schema.Number),
+  needsAttentionRate: import_effect26.Schema.NullOr(import_effect26.Schema.Number),
+  medianCompletionMs: import_effect26.Schema.NullOr(import_effect26.Schema.Number),
+  steeringTotal: import_effect26.Schema.Number,
+  steeringPerRun: import_effect26.Schema.NullOr(import_effect26.Schema.Number),
+  stallTotal: import_effect26.Schema.Number,
+  approvalsRequested: import_effect26.Schema.Number,
+  approvalsApproved: import_effect26.Schema.Number,
+  approvalsRejected: import_effect26.Schema.Number,
+  approvalsPending: import_effect26.Schema.Number
+});
+var RigStatsOutput = import_effect26.Schema.Struct({
+  v: import_effect26.Schema.Literal(1),
+  command: import_effect26.Schema.Literal("stats show"),
+  data: RigStatsData
+});
+// packages/contracts/src/protocol-version.ts
+var RIG_PROTOCOL_VERSION = 1;
+// packages/contracts/src/help-catalog.ts
+var HELP_CATALOG_CAPABILITY_ID = "rig.help.catalog";
+var HELP_CATALOG = makeCapabilityId(HELP_CATALOG_CAPABILITY_ID);
+// packages/contracts/src/planning.ts
+var import_effect27 = require("effect");
+var ClarificationStatus = import_effect27.Schema.Literals([
+  "open",
+  "resolved-from-code",
+  "resolved-by-human",
+  "deferred"
+]);
+var OpenQuestion = import_effect27.Schema.Struct({
+  id: TrimmedNonEmptyString,
+  question: TrimmedNonEmptyString,
+  status: ClarificationStatus,
+  resolution: import_effect27.Schema.NullOr(import_effect27.Schema.String)
+});
+var UserStory = import_effect27.Schema.Struct({
+  id: TrimmedNonEmptyString,
+  title: TrimmedNonEmptyString,
+  priority: PositiveInt
+});
+var FunctionalRequirement = import_effect27.Schema.Struct({
+  id: TrimmedNonEmptyString,
+  text: TrimmedNonEmptyString
+});
+var PlanTask = import_effect27.Schema.Struct({
+  localId: TrimmedNonEmptyString,
+  title: TrimmedNonEmptyString,
+  description: import_effect27.Schema.String,
+  acceptance: import_effect27.Schema.Array(import_effect27.Schema.String),
+  scope: import_effect27.Schema.Array(TrimmedNonEmptyString),
+  validationKeys: import_effect27.Schema.Array(TrimmedNonEmptyString),
+  dependsOn: import_effect27.Schema.Array(TrimmedNonEmptyString),
+  parent: import_effect27.Schema.NullOr(TrimmedNonEmptyString),
+  parallelizable: import_effect27.Schema.Boolean
+});
+var PlanSpec = import_effect27.Schema.Struct({
+  prdTitle: TrimmedNonEmptyString,
+  userStories: import_effect27.Schema.Array(UserStory),
+  functionalRequirements: import_effect27.Schema.Array(FunctionalRequirement),
+  openQuestions: import_effect27.Schema.Array(OpenQuestion),
+  tasks: import_effect27.Schema.Array(PlanTask),
+  generatedAt: IsoDateTime
+});
+// packages/contracts/src/drift.ts
+var import_effect28 = require("effect");
+var DriftKind = import_effect28.Schema.Literals([
+  "deleted-reference",
+  "stale-anchor",
+  "semantic-mismatch",
+  "issue-mismatch"
+]);
+var DriftConfidence = import_effect28.Schema.Literals(["high", "medium", "low"]);
+var DriftFinding = import_effect28.Schema.Struct({
+  kind: DriftKind,
+  docPath: TrimmedNonEmptyString,
+  line: import_effect28.Schema.NullOr(PositiveInt),
+  reference: import_effect28.Schema.NullOr(TrimmedNonEmptyString),
+  detail: import_effect28.Schema.String,
+  confidence: DriftConfidence
+});
+var DriftReport = import_effect28.Schema.Struct({
+  generatedAt: IsoDateTime,
+  scanned: NonNegativeInt,
+  degraded: import_effect28.Schema.Boolean,
+  findings: import_effect28.Schema.Array(DriftFinding)
+});
+// packages/contracts/src/rollups.ts
+var import_effect29 = require("effect");
+var PercentComplete = NonNegativeInt.check(import_effect29.Schema.isLessThanOrEqualTo(100));
+var EpicRollup = import_effect29.Schema.Struct({
+  epicKey: TrimmedNonEmptyString,
+  total: NonNegativeInt,
+  percentComplete: PercentComplete,
+  blockedCount: NonNegativeInt,
+  humanBlockedCount: NonNegativeInt,
+  inFlightCount: NonNegativeInt,
+  byStatus: import_effect29.Schema.Record(import_effect29.Schema.String, NonNegativeInt)
+});
+var AssigneeRollup = import_effect29.Schema.Struct({
+  assignee: TrimmedNonEmptyString,
+  openTaskCount: NonNegativeInt,
+  inFlightRunCount: NonNegativeInt,
+  prsAwaitingReview: NonNegativeInt,
+  blockers: import_effect29.Schema.Array(TaskId)
+});
+var WorkspaceRollups = import_effect29.Schema.Struct({
+  epics: import_effect29.Schema.Array(EpicRollup),
+  assignees: import_effect29.Schema.Array(AssigneeRollup),
+  generatedAt: IsoDateTime
+});
+// packages/contracts/src/panel-protocol.ts
+var RIG_RUN_STOP_PANEL_ACTION = "rig-run:stop";
+var RIG_CAPABILITY_PANEL_SLOT = "capability";
+var RIG_SUPERVISOR_PANEL_ID = "supervisor";
+// packages/contracts/src/control-plane-types.ts
+var PR_MERGE_GATE_CAPABILITY_ID = "rig.mergeGate.resolveHeadSha";
+var PR_MERGE_GATE = makeCapabilityId(PR_MERGE_GATE_CAPABILITY_ID);
+// packages/contracts/src/dependency-preflight.ts
+var DEPENDENCY_PREFLIGHT_CAPABILITY_ID = "workspace.dependency-preflight";
+var DEPENDENCY_PREFLIGHT_CAPABILITY = makeCapabilityId(DEPENDENCY_PREFLIGHT_CAPABILITY_ID);
+// packages/contracts/src/workspace-config.ts
+var WORKSPACE_CONFIG_ENSURE_CAPABILITY_ID = "workspace.config.ensure";
+var WORKSPACE_CONFIG_ENSURE = makeCapabilityId(WORKSPACE_CONFIG_ENSURE_CAPABILITY_ID);
+// packages/contracts/src/layout.ts
+var RIG_DEFINITION_DIRNAME = "rig";
+var RIG_STATE_DIRNAME = ".rig";
+var RIG_ARTIFACTS_DIRNAME = "artifacts";
+// packages/contracts/src/errors.ts
+class CliError extends Error {
+  exitCode;
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
+// packages/contracts/src/lifecycle-capabilities.ts
+var TASK_VERIFY_CAPABILITY_ID = "default-lifecycle.task-verify";
+var COMPLETION_VERIFICATION_CAPABILITY_ID = "default-lifecycle.completion-verification";
+var RUN_CLOSEOUT_CAPABILITY_ID = "default-lifecycle.run-closeout";
+var LIFECYCLE_GIT_AGENT_CAPABILITY_ID = "default-lifecycle.git-agent";
+var TASK_VERIFY_CAPABILITY = makeCapabilityId(TASK_VERIFY_CAPABILITY_ID);
+var COMPLETION_VERIFICATION_CAPABILITY = makeCapabilityId(COMPLETION_VERIFICATION_CAPABILITY_ID);
+var LIFECYCLE_GIT_AGENT = makeCapabilityId(LIFECYCLE_GIT_AGENT_CAPABILITY_ID);
+var RUN_CLOSEOUT_CAPABILITY = makeCapabilityId(RUN_CLOSEOUT_CAPABILITY_ID);
+// packages/contracts/src/browser.ts
+var BROWSER_CONTRACT_SERVICE_CAPABILITY_ID = "browser.contract";
+var BROWSER_CONTRACT_SERVICE_CAPABILITY = makeCapabilityId(BROWSER_CONTRACT_SERVICE_CAPABILITY_ID);
+// packages/contracts/src/memory.ts
+var MEMORY_SERVICE_CAPABILITY_ID = "memory.service";
+var NO_MATCH_RETRIEVAL_CANONICAL_KEY = "__memory_recall__:none";
+var MEMORY = makeCapabilityId(MEMORY_SERVICE_CAPABILITY_ID);
+// packages/contracts/src/notify.ts
+var NOTIFY_SERVICE_CAPABILITY_ID = "notify.dispatch";
+var NOTIFY_SERVICE_CAPABILITY = makeCapabilityId(NOTIFY_SERVICE_CAPABILITY_ID);
+// packages/contracts/src/collab-session-viewer.ts
+var COLLAB_SESSION_VIEWER_CAPABILITY_ID = "collab.session-viewer";
+var COLLAB_SESSION_VIEWER_CAPABILITY = makeCapabilityId(COLLAB_SESSION_VIEWER_CAPABILITY_ID);
+// packages/contracts/src/provider-instructions.ts
+var RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID = "provider.runtime-instructions";
+var RUNTIME_INSTRUCTION = makeCapabilityId(RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID);
+// packages/contracts/src/session-asset-materializer.ts
+var SESSION_ASSET_MATERIALIZER_CAPABILITY_ID = "provider.session-asset-materializer";
+var SESSION_ASSET_MATERIALIZER = makeCapabilityId(SESSION_ASSET_MATERIALIZER_CAPABILITY_ID);
+// packages/contracts/src/isolation.ts
+var ISOLATION_BACKEND_CAPABILITY_ID = "isolation.backend";
+var ISOLATION_BACKEND = makeCapabilityId(ISOLATION_BACKEND_CAPABILITY_ID);
+// packages/contracts/src/managed-repos.ts
+var REPO_OPERATIONS_CAPABILITY_ID = "repos.operations";
+var REPO_OPERATIONS_CAPABILITY = makeCapabilityId(REPO_OPERATIONS_CAPABILITY_ID);
+var MANAGED_REPO_SERVICE_CAPABILITY_ID = "managed-repos.service";
+var MANAGED_REPO_SERVICE_CAPABILITY = makeCapabilityId(MANAGED_REPO_SERVICE_CAPABILITY_ID);
+// packages/contracts/src/github.ts
+var GITHUB_PROVIDER_CAPABILITY_ID = "github.provider";
+var GITHUB_PROVIDER = makeCapabilityId(GITHUB_PROVIDER_CAPABILITY_ID);
+var ISSUE_TRIAGE_CAPABILITY_ID = "cap:issue-triage";
+var ISSUE_TRIAGE = makeCapabilityId(ISSUE_TRIAGE_CAPABILITY_ID);
+// packages/contracts/src/doctor.ts
+var DOCTOR_RUNNER_CAPABILITY_ID = "doctor.runner";
+var DOCTOR = makeCapabilityId(DOCTOR_RUNNER_CAPABILITY_ID);
+// packages/contracts/src/run-dispatch.ts
+var RUN_DISPATCH_CAPABILITY_ID = "rig.runs.dispatch";
+var RUN_DISPATCH = makeCapabilityId(RUN_DISPATCH_CAPABILITY_ID);
+// packages/contracts/src/run-discovery.ts
+var RUN_DISCOVERY_CAPABILITY_ID = "rig.runs.discovery";
+var RUN_DISCOVERY = makeCapabilityId(RUN_DISCOVERY_CAPABILITY_ID);
+// packages/contracts/src/run-registry-backbone.ts
+var RUN_REGISTRY_BACKBONE_CAPABILITY_ID = "transport.run-registry-backbone";
+var RUN_REGISTRY_BACKBONE = makeCapabilityId(RUN_REGISTRY_BACKBONE_CAPABILITY_ID);
+// packages/contracts/src/tool-materializer.ts
+var TOOL_MATERIALIZER_CAPABILITY_ID = "provider.tool-materializer";
+var TOOL_MATERIALIZER = makeCapabilityId(TOOL_MATERIALIZER_CAPABILITY_ID);
+// packages/contracts/src/toolchain-sources.ts
+var GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID = "rig.toolchain.sources.guard";
+var LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID = "rig.toolchain.sources.lifecycle";
+var GUARD_TOOLCHAIN_SOURCES = makeCapabilityId(GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID);
+var LIFECYCLE_TOOLCHAIN_SOURCES = makeCapabilityId(LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID);
+// packages/contracts/src/cli-runner.ts
+var CLI_RUNNER_CAPABILITY_ID = "rig.cli.runner";
+var CLI_RUNNER = makeCapabilityId(CLI_RUNNER_CAPABILITY_ID);
+})