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

package/dist/index.mjs

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