@h-rig/contracts 0.0.6-alpha.131 → 0.0.6-alpha.133

package/dist/src/config.js

@@ -1,10 +1,248 @@
 // @bun
 // packages/contracts/src/config.ts
-import { Schema as Schema2 } from "effect";
+import { Schema as Schema9 } from "effect";
 
 // packages/contracts/src/plugin.ts
+import { Schema as Schema4 } from "effect";
+
+// packages/contracts/src/kernel.ts
+import { Schema as Schema3 } from "effect";
+
+// packages/contracts/src/baseSchemas.ts
 import { Schema } from "effect";
-var ValidatorCategory = Schema.Literals([
+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/stage.ts
+import { Schema as Schema2 } from "effect";
+var StageKind = Schema2.Literals(["transform", "gate", "observe"]);
+var StageId = TrimmedNonEmptyString.pipe(Schema2.brand("StageId"));
+var StageContext = Schema2.Struct({
+  runId: RunId,
+  taskId: Schema2.optional(Schema2.NullOr(TaskId)),
+  state: Schema2.Unknown,
+  metadata: Schema2.optional(Schema2.Record(Schema2.String, Schema2.Unknown))
+});
+var StageDescriptor = Schema2.Struct({
+  id: StageId,
+  kind: StageKind,
+  before: Schema2.optional(Schema2.Array(StageId)),
+  after: Schema2.optional(Schema2.Array(StageId)),
+  priority: Schema2.Number.pipe(Schema2.withDecodingDefault(() => 0)),
+  protected: Schema2.Boolean.pipe(Schema2.withDecodingDefault(() => false))
+});
+var StageContinueResult = Schema2.Struct({
+  kind: Schema2.Literal("continue"),
+  ctx: StageContext
+});
+var StageAllowResult = Schema2.Struct({
+  kind: Schema2.Literal("allow")
+});
+var StageBlockResult = Schema2.Struct({
+  kind: Schema2.Literal("block"),
+  reason: TrimmedNonEmptyString
+});
+var StageResult = Schema2.Union([
+  StageContinueResult,
+  StageAllowResult,
+  StageBlockResult
+]);
+var StageWrapperDescriptor = Schema2.Struct({
+  id: TrimmedNonEmptyString,
+  priority: Schema2.Number.pipe(Schema2.withDecodingDefault(() => 0))
+});
+var StageMutationOp = Schema2.Literals(["insert", "remove", "replace", "wrap", "reorder"]);
+var InsertStageMutation = Schema2.Struct({
+  op: Schema2.Literal("insert"),
+  stage: StageDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var RemoveStageMutation = Schema2.Struct({
+  op: Schema2.Literal("remove"),
+  id: StageId,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var ReplaceStageMutation = Schema2.Struct({
+  op: Schema2.Literal("replace"),
+  id: StageId,
+  stage: StageDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var WrapStageMutation = Schema2.Struct({
+  op: Schema2.Literal("wrap"),
+  id: StageId,
+  around: StageWrapperDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var ReorderStageMutation = Schema2.Struct({
+  op: Schema2.Literal("reorder"),
+  id: StageId,
+  before: Schema2.optional(Schema2.Array(StageId)),
+  after: Schema2.optional(Schema2.Array(StageId)),
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var StageMutation = Schema2.Union([
+  InsertStageMutation,
+  RemoveStageMutation,
+  ReplaceStageMutation,
+  WrapStageMutation,
+  ReorderStageMutation
+]);
+var ResolutionGrantUse = Schema2.Struct({
+  kind: Schema2.Literals(["protected-stage", "kernel-replacement"]),
+  target: TrimmedNonEmptyString,
+  pluginId: TrimmedNonEmptyString
+});
+var ResolutionRecordEntry = Schema2.Struct({
+  stageId: StageId,
+  contributedBy: TrimmedNonEmptyString,
+  removedBy: Schema2.optional(TrimmedNonEmptyString),
+  replacedBy: Schema2.optional(TrimmedNonEmptyString),
+  wrappedBy: Schema2.optional(Schema2.Array(TrimmedNonEmptyString)),
+  droppedAnchors: Schema2.optional(Schema2.Array(StageId)),
+  isProtected: Schema2.Boolean
+});
+var ResolvedPipeline = Schema2.Struct({
+  runId: Schema2.optional(RunId),
+  order: Schema2.Array(StageId),
+  record: Schema2.Array(ResolutionRecordEntry),
+  cycles: Schema2.Array(Schema2.Array(StageId)),
+  grantUses: Schema2.optional(Schema2.Array(ResolutionGrantUse)),
+  resolvedAt: Schema2.optional(IsoDateTime)
+});
+var StageRunOutcome = Schema2.Struct({
+  stageId: StageId,
+  result: StageResult,
+  startedAt: IsoDateTime,
+  finishedAt: IsoDateTime
+});
+
+// packages/contracts/src/kernel.ts
+var CapabilityTag = Schema3.Literals([
+  "kernel",
+  "journal",
+  "stage-runner",
+  "transport",
+  "loader-policy"
+]);
+var CapabilityProviderRef = Schema3.Struct({
+  capability: CapabilityTag,
+  pluginId: TrimmedNonEmptyString
+});
+var CapabilityReplacement = Schema3.Struct({
+  capability: CapabilityTag,
+  providerPluginId: TrimmedNonEmptyString
+});
+var CapabilityReplacementSpec = Schema3.Union([
+  CapabilityReplacement,
+  TrimmedNonEmptyString
+]);
+var PluginMeta = Schema3.Struct({
+  id: TrimmedNonEmptyString,
+  version: TrimmedNonEmptyString,
+  provides: Schema3.Array(CapabilityTag),
+  requires: Schema3.optional(Schema3.Array(CapabilityTag)),
+  replaces: Schema3.optional(Schema3.Array(CapabilityReplacementSpec))
+});
+var LoadedPluginDescriptor = Schema3.Struct({
+  meta: PluginMeta,
+  provides: Schema3.Array(CapabilityTag),
+  contributes: Schema3.Unknown,
+  runtime: Schema3.Unknown
+});
+var ProtectedStageGrant = Schema3.Struct({
+  stageId: TrimmedNonEmptyString,
+  pluginId: TrimmedNonEmptyString,
+  operations: Schema3.Array(Schema3.Literals(["remove", "replace"])),
+  grantedBy: Schema3.optional(TrimmedNonEmptyString),
+  reason: Schema3.optional(Schema3.String)
+});
+var KernelReplacementGrant = Schema3.Struct({
+  pluginId: TrimmedNonEmptyString,
+  grantedBy: Schema3.optional(TrimmedNonEmptyString),
+  reason: Schema3.optional(Schema3.String)
+});
+var CapabilityGrants = Schema3.Struct({
+  capabilityPrecedence: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Array(TrimmedNonEmptyString))),
+  protectedStageGrants: Schema3.optional(Schema3.Array(ProtectedStageGrant)),
+  kernelReplacementGrants: Schema3.optional(Schema3.Array(KernelReplacementGrant))
+});
+var KernelBootErrorCode = Schema3.Literals([
+  "BootIncoherent",
+  "AmbiguousCapability",
+  "MissingCapability",
+  "ProtectedStageViolation",
+  "KernelReplacementDenied",
+  "PipelineUnresolvable"
+]);
+var KernelBootError = Schema3.Struct({
+  code: KernelBootErrorCode,
+  message: TrimmedNonEmptyString,
+  capability: Schema3.optional(CapabilityTag),
+  stageId: Schema3.optional(TrimmedNonEmptyString),
+  pluginIds: Schema3.optional(Schema3.Array(TrimmedNonEmptyString))
+});
+var CapabilityResolutionStatus = Schema3.Literals(["resolved", "ambiguous", "missing", "replaced"]);
+var CapabilityResolutionRecord = Schema3.Struct({
+  capability: CapabilityTag,
+  status: CapabilityResolutionStatus,
+  selectedPluginId: Schema3.NullOr(TrimmedNonEmptyString),
+  candidatePluginIds: Schema3.Array(TrimmedNonEmptyString),
+  precedenceUsed: Schema3.Boolean,
+  replacementUsed: Schema3.optional(CapabilityReplacement),
+  error: Schema3.optional(Schema3.String)
+});
+var KernelResolutionRecord = Schema3.Struct({
+  resolvedAt: IsoDateTime,
+  capabilities: Schema3.Array(CapabilityResolutionRecord),
+  pipeline: Schema3.optional(ResolvedPipeline)
+});
+var BootResultDescriptor = Schema3.Struct({
+  kernelPluginId: TrimmedNonEmptyString,
+  pluginIds: Schema3.Array(TrimmedNonEmptyString),
+  resolution: KernelResolutionRecord
+});
+var JournalEvent = Schema3.Struct({
+  type: TrimmedNonEmptyString,
+  runId: Schema3.optional(RunId),
+  at: IsoDateTime,
+  payload: Schema3.Unknown
+});
+
+// packages/contracts/src/plugin.ts
+var ValidatorCategory = Schema4.Literals([
   "boundary",
   "contract",
   "integration",
@@ -12,12 +250,12 @@ var ValidatorCategory = Schema.Literals([
   "external",
   "custom"
 ]);
-var ValidatorRegistration = Schema.Struct({
-  id: Schema.String,
+var ValidatorRegistration = Schema4.Struct({
+  id: Schema4.String,
   category: ValidatorCategory,
-  description: Schema.optional(Schema.String)
+  description: Schema4.optional(Schema4.String)
 });
-var HookEvent = Schema.Literals([
+var AgentSessionHookEvent = Schema4.Literals([
   "PreToolUse",
   "PostToolUse",
   "UserPromptSubmit",
@@ -25,192 +263,1339 @@ var HookEvent = Schema.Literals([
   "SessionStart",
   "SessionEnd"
 ]);
-var HookMatcher = Schema.Union([
-  Schema.Struct({ kind: Schema.Literal("all") }),
-  Schema.Struct({ kind: Schema.Literal("tool"), name: Schema.String }),
-  Schema.Struct({ kind: Schema.Literal("glob"), pattern: Schema.String })
+var HookMatcher = Schema4.Union([
+  Schema4.Struct({ kind: Schema4.Literal("all") }),
+  Schema4.Struct({ kind: Schema4.Literal("tool"), name: Schema4.String }),
+  Schema4.Struct({ kind: Schema4.Literal("glob"), pattern: Schema4.String })
 ]);
-var HookRegistration = Schema.Struct({
-  id: Schema.String,
-  event: HookEvent,
+var HookRegistration = Schema4.Struct({
+  id: Schema4.String,
+  event: AgentSessionHookEvent,
   matcher: HookMatcher,
-  command: Schema.optional(Schema.String),
-  description: Schema.optional(Schema.String)
-});
-var SkillRegistration = Schema.Struct({
-  id: Schema.String,
-  path: Schema.String,
-  description: Schema.optional(Schema.String)
-});
-var RepoSourceRegistration = Schema.Struct({
-  id: Schema.String,
-  url: Schema.String,
-  defaultPath: Schema.optional(Schema.String),
-  description: Schema.optional(Schema.String),
-  defaultBranch: Schema.optional(Schema.String),
-  remoteEnvVar: Schema.optional(Schema.String),
-  checkoutEnvVar: Schema.optional(Schema.String)
-});
-var AgentRoleRegistration = Schema.Struct({
-  id: Schema.String,
-  defaultModel: Schema.optional(Schema.String),
-  description: Schema.optional(Schema.String)
-});
-var TaskFieldExtension = Schema.Struct({
-  id: Schema.String,
-  fieldName: Schema.String,
-  schemaJson: Schema.String
-});
-var TaskSourceKind = Schema.String;
-var TaskSourceRegistration = Schema.Struct({
-  id: Schema.String,
-  kind: Schema.String,
-  description: Schema.optional(Schema.String)
-});
-var CliCommandRegistration = Schema.Struct({
-  id: Schema.String,
-  command: Schema.String,
-  description: Schema.optional(Schema.String)
-});
-var PluginContributes = Schema.Struct({
-  validators: Schema.optional(Schema.Array(ValidatorRegistration)),
-  hooks: Schema.optional(Schema.Array(HookRegistration)),
-  skills: Schema.optional(Schema.Array(SkillRegistration)),
-  repoSources: Schema.optional(Schema.Array(RepoSourceRegistration)),
-  agentRoles: Schema.optional(Schema.Array(AgentRoleRegistration)),
-  taskFieldSchemas: Schema.optional(Schema.Array(TaskFieldExtension)),
-  taskSources: Schema.optional(Schema.Array(TaskSourceRegistration)),
-  cliCommands: Schema.optional(Schema.Array(CliCommandRegistration))
-});
-var RigPlugin = Schema.Struct({
-  name: Schema.String,
-  version: Schema.String,
-  contributes: Schema.optional(PluginContributes)
+  command: Schema4.optional(Schema4.String),
+  description: Schema4.optional(Schema4.String)
+});
+var SkillRegistration = Schema4.Struct({
+  id: Schema4.String,
+  path: Schema4.String,
+  description: Schema4.optional(Schema4.String)
+});
+var RepoSourceRegistration = Schema4.Struct({
+  id: Schema4.String,
+  url: Schema4.String,
+  defaultPath: Schema4.optional(Schema4.String),
+  description: Schema4.optional(Schema4.String),
+  defaultBranch: Schema4.optional(Schema4.String),
+  remoteEnvVar: Schema4.optional(Schema4.String),
+  checkoutEnvVar: Schema4.optional(Schema4.String)
+});
+var AgentRoleRegistration = Schema4.Struct({
+  id: Schema4.String,
+  defaultModel: Schema4.optional(Schema4.String),
+  description: Schema4.optional(Schema4.String)
+});
+var TaskFieldExtension = Schema4.Struct({
+  id: Schema4.String,
+  fieldName: Schema4.String,
+  schemaJson: Schema4.String
+});
+var TaskSourceKind = Schema4.String;
+var TaskSourceRegistration = Schema4.Struct({
+  id: Schema4.String,
+  kind: Schema4.String,
+  description: Schema4.optional(Schema4.String)
+});
+var CliCommandRegistration = Schema4.Struct({
+  id: Schema4.String,
+  command: Schema4.String,
+  description: Schema4.optional(Schema4.String)
+});
+var PluginContributes = Schema4.Struct({
+  validators: Schema4.optional(Schema4.Array(ValidatorRegistration)),
+  hooks: Schema4.optional(Schema4.Array(HookRegistration)),
+  skills: Schema4.optional(Schema4.Array(SkillRegistration)),
+  repoSources: Schema4.optional(Schema4.Array(RepoSourceRegistration)),
+  agentRoles: Schema4.optional(Schema4.Array(AgentRoleRegistration)),
+  taskFieldSchemas: Schema4.optional(Schema4.Array(TaskFieldExtension)),
+  taskSources: Schema4.optional(Schema4.Array(TaskSourceRegistration)),
+  cliCommands: Schema4.optional(Schema4.Array(CliCommandRegistration)),
+  stageMutations: Schema4.optional(Schema4.Array(StageMutation))
+});
+var RigPlugin = Schema4.Struct({
+  name: Schema4.String,
+  version: Schema4.String,
+  provides: Schema4.optional(Schema4.Array(CapabilityTag)),
+  requires: Schema4.optional(Schema4.Array(CapabilityTag)),
+  replaces: Schema4.optional(Schema4.Array(CapabilityReplacementSpec)),
+  contributes: Schema4.optional(PluginContributes)
+});
+
+// packages/contracts/src/supervisor-journal.ts
+import { Schema as Schema8 } from "effect";
+
+// packages/contracts/src/runtime.ts
+import { Schema as Schema7 } from "effect";
+
+// packages/contracts/src/orchestration.ts
+import { Option, Schema as Schema6, SchemaIssue, Struct } from "effect";
+
+// packages/contracts/src/model.ts
+import { Schema as Schema5 } from "effect";
+var CODEX_REASONING_EFFORT_OPTIONS = ["xhigh", "high", "medium", "low"];
+var CodexModelOptions = Schema5.Struct({
+  reasoningEffort: Schema5.optional(Schema5.Literals(CODEX_REASONING_EFFORT_OPTIONS)),
+  fastMode: Schema5.optional(Schema5.Boolean)
+});
+var ClaudeModelOptions = Schema5.Struct({});
+var ProviderModelOptions = Schema5.Struct({
+  codex: Schema5.optional(CodexModelOptions),
+  claude: Schema5.optional(ClaudeModelOptions)
+});
+
+// packages/contracts/src/orchestration.ts
+var ProviderKind = Schema6.Literals(["codex", "claude"]);
+var ProviderApprovalPolicy = Schema6.Literals([
+  "untrusted",
+  "on-failure",
+  "on-request",
+  "never"
+]);
+var ProviderSandboxMode = Schema6.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var ProviderServiceTier = Schema6.Literals(["fast", "flex"]);
+var RuntimeMode = Schema6.Literals(["approval-required", "full-access"]);
+var DEFAULT_RUNTIME_MODE = "full-access";
+var ProviderInteractionMode = Schema6.Literals(["default", "plan"]);
+var DEFAULT_PROVIDER_INTERACTION_MODE = "default";
+var ProviderRequestKind = Schema6.Literals(["command", "file-read", "file-change"]);
+var AssistantDeliveryMode = Schema6.Literals(["buffered", "streaming"]);
+var ProviderApprovalDecision = Schema6.Literals([
+  "accept",
+  "acceptForSession",
+  "decline",
+  "cancel"
+]);
+var ProviderUserInputAnswers = Schema6.Record(Schema6.String, Schema6.Unknown);
+var PROVIDER_SEND_TURN_MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+var PROVIDER_SEND_TURN_MAX_IMAGE_DATA_URL_CHARS = 14000000;
+var CHAT_ATTACHMENT_ID_MAX_CHARS = 128;
+var ChatAttachmentId = TrimmedNonEmptyString.check(Schema6.isMaxLength(CHAT_ATTACHMENT_ID_MAX_CHARS), Schema6.isPattern(/^[a-z0-9_-]+$/i));
+var ChatImageAttachment = Schema6.Struct({
+  type: Schema6.Literal("image"),
+  id: ChatAttachmentId,
+  name: TrimmedNonEmptyString.check(Schema6.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema6.isMaxLength(100), Schema6.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema6.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES))
+});
+var UploadChatImageAttachment = Schema6.Struct({
+  type: Schema6.Literal("image"),
+  name: TrimmedNonEmptyString.check(Schema6.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema6.isMaxLength(100), Schema6.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema6.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES)),
+  dataUrl: TrimmedNonEmptyString.check(Schema6.isMaxLength(PROVIDER_SEND_TURN_MAX_IMAGE_DATA_URL_CHARS))
+});
+var ChatAttachment = Schema6.Union([ChatImageAttachment]);
+var UploadChatAttachment = Schema6.Union([UploadChatImageAttachment]);
+var ProjectScriptIcon = Schema6.Literals([
+  "play",
+  "test",
+  "lint",
+  "configure",
+  "build",
+  "debug"
+]);
+var ProjectScript = Schema6.Struct({
+  id: TrimmedNonEmptyString,
+  name: TrimmedNonEmptyString,
+  command: TrimmedNonEmptyString,
+  icon: ProjectScriptIcon,
+  runOnWorktreeCreate: Schema6.Boolean
+});
+var OrchestrationProject = Schema6.Struct({
+  id: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema6.NullOr(TrimmedNonEmptyString),
+  scripts: Schema6.Array(ProjectScript),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  deletedAt: Schema6.NullOr(IsoDateTime)
+});
+var OrchestrationMessageRole = Schema6.Literals(["user", "assistant", "system"]);
+var OrchestrationMessage = Schema6.Struct({
+  id: MessageId,
+  role: OrchestrationMessageRole,
+  text: Schema6.String,
+  attachments: Schema6.optional(Schema6.Array(ChatAttachment)),
+  turnId: Schema6.NullOr(TurnId),
+  streaming: Schema6.Boolean,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var OrchestrationProposedPlanId = TrimmedNonEmptyString;
+var OrchestrationProposedPlan = Schema6.Struct({
+  id: OrchestrationProposedPlanId,
+  turnId: Schema6.NullOr(TurnId),
+  planMarkdown: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var OrchestrationSessionStatus = Schema6.Literals([
+  "idle",
+  "starting",
+  "running",
+  "ready",
+  "interrupted",
+  "stopped",
+  "error"
+]);
+var OrchestrationSession = Schema6.Struct({
+  threadId: ThreadId,
+  status: OrchestrationSessionStatus,
+  providerName: Schema6.NullOr(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode.pipe(Schema6.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  activeTurnId: Schema6.NullOr(TurnId),
+  lastError: Schema6.NullOr(TrimmedNonEmptyString),
+  updatedAt: IsoDateTime
+});
+var OrchestrationCheckpointFile = Schema6.Struct({
+  path: TrimmedNonEmptyString,
+  kind: TrimmedNonEmptyString,
+  additions: NonNegativeInt,
+  deletions: NonNegativeInt
+});
+var OrchestrationCheckpointStatus = Schema6.Literals(["ready", "missing", "error"]);
+var OrchestrationCheckpointSummary = Schema6.Struct({
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema6.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema6.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var OrchestrationThreadActivityTone = Schema6.Literals([
+  "info",
+  "tool",
+  "approval",
+  "error"
+]);
+var OrchestrationThreadActivity = Schema6.Struct({
+  id: EventId,
+  tone: OrchestrationThreadActivityTone,
+  kind: TrimmedNonEmptyString,
+  summary: TrimmedNonEmptyString,
+  payload: Schema6.Unknown,
+  turnId: Schema6.NullOr(TurnId),
+  sequence: Schema6.optional(NonNegativeInt),
+  createdAt: IsoDateTime
+});
+var OrchestrationLatestTurnState = Schema6.Literals([
+  "running",
+  "interrupted",
+  "completed",
+  "error"
+]);
+var OrchestrationLatestTurn = Schema6.Struct({
+  turnId: TurnId,
+  state: OrchestrationLatestTurnState,
+  requestedAt: IsoDateTime,
+  startedAt: Schema6.NullOr(IsoDateTime),
+  completedAt: Schema6.NullOr(IsoDateTime),
+  assistantMessageId: Schema6.NullOr(MessageId)
+});
+var OrchestrationThread = Schema6.Struct({
+  id: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode.pipe(Schema6.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema6.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema6.NullOr(TrimmedNonEmptyString),
+  latestTurn: Schema6.NullOr(OrchestrationLatestTurn),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  deletedAt: Schema6.NullOr(IsoDateTime),
+  messages: Schema6.Array(OrchestrationMessage),
+  proposedPlans: Schema6.Array(OrchestrationProposedPlan).pipe(Schema6.withDecodingDefault(() => [])),
+  activities: Schema6.Array(OrchestrationThreadActivity),
+  checkpoints: Schema6.Array(OrchestrationCheckpointSummary),
+  session: Schema6.NullOr(OrchestrationSession)
+});
+var OrchestrationReadModel = Schema6.Struct({
+  snapshotSequence: NonNegativeInt,
+  projects: Schema6.Array(OrchestrationProject),
+  threads: Schema6.Array(OrchestrationThread),
+  updatedAt: IsoDateTime
+});
+var ProjectCreateCommand = Schema6.Struct({
+  type: Schema6.Literal("project.create"),
+  commandId: CommandId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema6.optional(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var ProjectMetaUpdateCommand = Schema6.Struct({
+  type: Schema6.Literal("project.meta.update"),
+  commandId: CommandId,
+  projectId: ProjectId,
+  title: Schema6.optional(TrimmedNonEmptyString),
+  workspaceRoot: Schema6.optional(TrimmedNonEmptyString),
+  defaultModel: Schema6.optional(TrimmedNonEmptyString),
+  scripts: Schema6.optional(Schema6.Array(ProjectScript))
+});
+var ProjectDeleteCommand = Schema6.Struct({
+  type: Schema6.Literal("project.delete"),
+  commandId: CommandId,
+  projectId: ProjectId
+});
+var ThreadCreateCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.create"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode.pipe(Schema6.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema6.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema6.NullOr(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var ThreadDeleteCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.delete"),
+  commandId: CommandId,
+  threadId: ThreadId
+});
+var ThreadMetaUpdateCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.meta.update"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  title: Schema6.optional(TrimmedNonEmptyString),
+  model: Schema6.optional(TrimmedNonEmptyString),
+  branch: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
+  worktreePath: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString))
+});
+var ThreadRuntimeModeSetCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.runtime-mode.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  runtimeMode: RuntimeMode,
+  createdAt: IsoDateTime
+});
+var ThreadInteractionModeSetCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.interaction-mode.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  interactionMode: ProviderInteractionMode,
+  createdAt: IsoDateTime
+});
+var ThreadTurnStartCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.turn.start"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  message: Schema6.Struct({
+    messageId: MessageId,
+    role: Schema6.Literal("user"),
+    text: Schema6.String,
+    attachments: Schema6.Array(ChatAttachment)
+  }),
+  provider: Schema6.optional(ProviderKind),
+  model: Schema6.optional(TrimmedNonEmptyString),
+  serviceTier: Schema6.optional(Schema6.NullOr(ProviderServiceTier)),
+  modelOptions: Schema6.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema6.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode.pipe(Schema6.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema6.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  createdAt: IsoDateTime
+});
+var ClientThreadTurnStartCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.turn.start"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  message: Schema6.Struct({
+    messageId: MessageId,
+    role: Schema6.Literal("user"),
+    text: Schema6.String,
+    attachments: Schema6.Array(UploadChatAttachment)
+  }),
+  provider: Schema6.optional(ProviderKind),
+  model: Schema6.optional(TrimmedNonEmptyString),
+  serviceTier: Schema6.optional(Schema6.NullOr(ProviderServiceTier)),
+  modelOptions: Schema6.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema6.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  createdAt: IsoDateTime
+});
+var ThreadTurnInterruptCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.turn.interrupt"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnId: Schema6.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadApprovalRespondCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.approval.respond"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision,
+  createdAt: IsoDateTime
+});
+var ThreadUserInputRespondCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.user-input.respond"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers,
+  createdAt: IsoDateTime
+});
+var ThreadCheckpointRevertCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.checkpoint.revert"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadSessionStopCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.session.stop"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  createdAt: IsoDateTime
+});
+var DispatchableClientOrchestrationCommand = Schema6.Union([
+  ProjectCreateCommand,
+  ProjectMetaUpdateCommand,
+  ProjectDeleteCommand,
+  ThreadCreateCommand,
+  ThreadDeleteCommand,
+  ThreadMetaUpdateCommand,
+  ThreadRuntimeModeSetCommand,
+  ThreadInteractionModeSetCommand,
+  ThreadTurnStartCommand,
+  ThreadTurnInterruptCommand,
+  ThreadApprovalRespondCommand,
+  ThreadUserInputRespondCommand,
+  ThreadCheckpointRevertCommand,
+  ThreadSessionStopCommand
+]);
+var ClientOrchestrationCommand = Schema6.Union([
+  ProjectCreateCommand,
+  ProjectMetaUpdateCommand,
+  ProjectDeleteCommand,
+  ThreadCreateCommand,
+  ThreadDeleteCommand,
+  ThreadMetaUpdateCommand,
+  ThreadRuntimeModeSetCommand,
+  ThreadInteractionModeSetCommand,
+  ClientThreadTurnStartCommand,
+  ThreadTurnInterruptCommand,
+  ThreadApprovalRespondCommand,
+  ThreadUserInputRespondCommand,
+  ThreadCheckpointRevertCommand,
+  ThreadSessionStopCommand
+]);
+var ThreadSessionSetCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.session.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  session: OrchestrationSession,
+  createdAt: IsoDateTime
+});
+var ThreadMessageAssistantDeltaCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.message.assistant.delta"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  messageId: MessageId,
+  delta: Schema6.String,
+  turnId: Schema6.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadMessageAssistantCompleteCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.message.assistant.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  messageId: MessageId,
+  turnId: Schema6.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadProposedPlanUpsertCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.proposed-plan.upsert"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  proposedPlan: OrchestrationProposedPlan,
+  createdAt: IsoDateTime
+});
+var ThreadTurnDiffCompleteCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.turn.diff.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnId: TurnId,
+  completedAt: IsoDateTime,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema6.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema6.optional(MessageId),
+  checkpointTurnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadActivityAppendCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.activity.append"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  activity: OrchestrationThreadActivity,
+  createdAt: IsoDateTime
+});
+var ThreadRevertCompleteCommand = Schema6.Struct({
+  type: Schema6.Literal("thread.revert.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var InternalOrchestrationCommand = Schema6.Union([
+  ThreadSessionSetCommand,
+  ThreadMessageAssistantDeltaCommand,
+  ThreadMessageAssistantCompleteCommand,
+  ThreadProposedPlanUpsertCommand,
+  ThreadTurnDiffCompleteCommand,
+  ThreadActivityAppendCommand,
+  ThreadRevertCompleteCommand
+]);
+var OrchestrationCommand = Schema6.Union([
+  DispatchableClientOrchestrationCommand,
+  InternalOrchestrationCommand
+]);
+var OrchestrationEventType = Schema6.Literals([
+  "project.created",
+  "project.meta-updated",
+  "project.deleted",
+  "thread.created",
+  "thread.deleted",
+  "thread.meta-updated",
+  "thread.runtime-mode-set",
+  "thread.interaction-mode-set",
+  "thread.message-sent",
+  "thread.turn-start-requested",
+  "thread.turn-interrupt-requested",
+  "thread.approval-response-requested",
+  "thread.user-input-response-requested",
+  "thread.checkpoint-revert-requested",
+  "thread.reverted",
+  "thread.session-stop-requested",
+  "thread.session-set",
+  "thread.proposed-plan-upserted",
+  "thread.turn-diff-completed",
+  "thread.activity-appended"
+]);
+var OrchestrationAggregateKind = Schema6.Literals(["project", "thread"]);
+var OrchestrationActorKind = Schema6.Literals(["client", "server", "provider"]);
+var ProjectCreatedPayload = Schema6.Struct({
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema6.NullOr(TrimmedNonEmptyString),
+  scripts: Schema6.Array(ProjectScript),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ProjectMetaUpdatedPayload = Schema6.Struct({
+  projectId: ProjectId,
+  title: Schema6.optional(TrimmedNonEmptyString),
+  workspaceRoot: Schema6.optional(TrimmedNonEmptyString),
+  defaultModel: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
+  scripts: Schema6.optional(Schema6.Array(ProjectScript)),
+  updatedAt: IsoDateTime
+});
+var ProjectDeletedPayload = Schema6.Struct({
+  projectId: ProjectId,
+  deletedAt: IsoDateTime
+});
+var ThreadCreatedPayload = Schema6.Struct({
+  threadId: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode.pipe(Schema6.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema6.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema6.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema6.NullOr(TrimmedNonEmptyString),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ThreadDeletedPayload = Schema6.Struct({
+  threadId: ThreadId,
+  deletedAt: IsoDateTime
+});
+var ThreadMetaUpdatedPayload = Schema6.Struct({
+  threadId: ThreadId,
+  title: Schema6.optional(TrimmedNonEmptyString),
+  model: Schema6.optional(TrimmedNonEmptyString),
+  branch: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
+  worktreePath: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
+  updatedAt: IsoDateTime
+});
+var ThreadRuntimeModeSetPayload = Schema6.Struct({
+  threadId: ThreadId,
+  runtimeMode: RuntimeMode,
+  updatedAt: IsoDateTime
+});
+var ThreadInteractionModeSetPayload = Schema6.Struct({
+  threadId: ThreadId,
+  interactionMode: ProviderInteractionMode.pipe(Schema6.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  updatedAt: IsoDateTime
+});
+var ThreadMessageSentPayload = Schema6.Struct({
+  threadId: ThreadId,
+  messageId: MessageId,
+  role: OrchestrationMessageRole,
+  text: Schema6.String,
+  attachments: Schema6.optional(Schema6.Array(ChatAttachment)),
+  turnId: Schema6.NullOr(TurnId),
+  streaming: Schema6.Boolean,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ThreadTurnStartRequestedPayload = Schema6.Struct({
+  threadId: ThreadId,
+  messageId: MessageId,
+  provider: Schema6.optional(ProviderKind),
+  model: Schema6.optional(TrimmedNonEmptyString),
+  serviceTier: Schema6.optional(Schema6.NullOr(ProviderServiceTier)),
+  modelOptions: Schema6.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema6.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode.pipe(Schema6.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema6.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  createdAt: IsoDateTime
+});
+var ThreadTurnInterruptRequestedPayload = Schema6.Struct({
+  threadId: ThreadId,
+  turnId: Schema6.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadApprovalResponseRequestedPayload = Schema6.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision,
+  createdAt: IsoDateTime
+});
+var ThreadUserInputResponseRequestedPayload = Schema6.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers,
+  createdAt: IsoDateTime
+});
+var ThreadCheckpointRevertRequestedPayload = Schema6.Struct({
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadRevertedPayload = Schema6.Struct({
+  threadId: ThreadId,
+  turnCount: NonNegativeInt
+});
+var ThreadSessionStopRequestedPayload = Schema6.Struct({
+  threadId: ThreadId,
+  createdAt: IsoDateTime
+});
+var ThreadSessionSetPayload = Schema6.Struct({
+  threadId: ThreadId,
+  session: OrchestrationSession
+});
+var ThreadProposedPlanUpsertedPayload = Schema6.Struct({
+  threadId: ThreadId,
+  proposedPlan: OrchestrationProposedPlan
+});
+var ThreadTurnDiffCompletedPayload = Schema6.Struct({
+  threadId: ThreadId,
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema6.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema6.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var ThreadActivityAppendedPayload = Schema6.Struct({
+  threadId: ThreadId,
+  activity: OrchestrationThreadActivity
+});
+var OrchestrationEventMetadata = Schema6.Struct({
+  providerTurnId: Schema6.optional(TrimmedNonEmptyString),
+  providerItemId: Schema6.optional(ProviderItemId),
+  adapterKey: Schema6.optional(TrimmedNonEmptyString),
+  requestId: Schema6.optional(ApprovalRequestId),
+  ingestedAt: Schema6.optional(IsoDateTime)
+});
+var EventBaseFields = {
+  sequence: NonNegativeInt,
+  eventId: EventId,
+  aggregateKind: OrchestrationAggregateKind,
+  aggregateId: Schema6.Union([ProjectId, ThreadId]),
+  occurredAt: IsoDateTime,
+  commandId: Schema6.NullOr(CommandId),
+  causationEventId: Schema6.NullOr(EventId),
+  correlationId: Schema6.NullOr(CommandId),
+  metadata: OrchestrationEventMetadata
+};
+var PersistedEventBaseFields = {
+  sequence: NonNegativeInt,
+  eventId: EventId,
+  aggregateKind: OrchestrationAggregateKind,
+  streamId: Schema6.Union([ProjectId, ThreadId]),
+  streamVersion: NonNegativeInt,
+  occurredAt: IsoDateTime,
+  commandId: Schema6.NullOr(CommandId),
+  causationEventId: Schema6.NullOr(EventId),
+  correlationId: Schema6.NullOr(CommandId),
+  actorKind: OrchestrationActorKind,
+  metadata: OrchestrationEventMetadata
+};
+var OrchestrationEvent = Schema6.Union([
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("project.created"),
+    payload: ProjectCreatedPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("project.meta-updated"),
+    payload: ProjectMetaUpdatedPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("project.deleted"),
+    payload: ProjectDeletedPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("thread.created"),
+    payload: ThreadCreatedPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("thread.deleted"),
+    payload: ThreadDeletedPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("thread.meta-updated"),
+    payload: ThreadMetaUpdatedPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("thread.runtime-mode-set"),
+    payload: ThreadRuntimeModeSetPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("thread.interaction-mode-set"),
+    payload: ThreadInteractionModeSetPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("thread.message-sent"),
+    payload: ThreadMessageSentPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("thread.turn-start-requested"),
+    payload: ThreadTurnStartRequestedPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("thread.turn-interrupt-requested"),
+    payload: ThreadTurnInterruptRequestedPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("thread.approval-response-requested"),
+    payload: ThreadApprovalResponseRequestedPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("thread.user-input-response-requested"),
+    payload: ThreadUserInputResponseRequestedPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("thread.checkpoint-revert-requested"),
+    payload: ThreadCheckpointRevertRequestedPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("thread.reverted"),
+    payload: ThreadRevertedPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("thread.session-stop-requested"),
+    payload: ThreadSessionStopRequestedPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("thread.session-set"),
+    payload: ThreadSessionSetPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("thread.proposed-plan-upserted"),
+    payload: ThreadProposedPlanUpsertedPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("thread.turn-diff-completed"),
+    payload: ThreadTurnDiffCompletedPayload
+  }),
+  Schema6.Struct({
+    ...EventBaseFields,
+    type: Schema6.Literal("thread.activity-appended"),
+    payload: ThreadActivityAppendedPayload
+  })
+]);
+var OrchestrationPersistedEvent = Schema6.Union([
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("project.created"),
+    payload: ProjectCreatedPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("project.meta-updated"),
+    payload: ProjectMetaUpdatedPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("project.deleted"),
+    payload: ProjectDeletedPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("thread.created"),
+    payload: ThreadCreatedPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("thread.deleted"),
+    payload: ThreadDeletedPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("thread.meta-updated"),
+    payload: ThreadMetaUpdatedPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("thread.runtime-mode-set"),
+    payload: ThreadRuntimeModeSetPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("thread.interaction-mode-set"),
+    payload: ThreadInteractionModeSetPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("thread.message-sent"),
+    payload: ThreadMessageSentPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("thread.turn-start-requested"),
+    payload: ThreadTurnStartRequestedPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("thread.turn-interrupt-requested"),
+    payload: ThreadTurnInterruptRequestedPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("thread.approval-response-requested"),
+    payload: ThreadApprovalResponseRequestedPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("thread.user-input-response-requested"),
+    payload: ThreadUserInputResponseRequestedPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("thread.checkpoint-revert-requested"),
+    payload: ThreadCheckpointRevertRequestedPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("thread.reverted"),
+    payload: ThreadRevertedPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("thread.session-stop-requested"),
+    payload: ThreadSessionStopRequestedPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("thread.session-set"),
+    payload: ThreadSessionSetPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("thread.proposed-plan-upserted"),
+    payload: ThreadProposedPlanUpsertedPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("thread.turn-diff-completed"),
+    payload: ThreadTurnDiffCompletedPayload
+  }),
+  Schema6.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema6.Literal("thread.activity-appended"),
+    payload: ThreadActivityAppendedPayload
+  })
+]);
+var OrchestrationCommandReceiptStatus = Schema6.Literals(["accepted", "rejected"]);
+var TurnCountRange = Schema6.Struct({
+  fromTurnCount: NonNegativeInt,
+  toTurnCount: NonNegativeInt
+}).check(Schema6.makeFilter((input) => input.fromTurnCount <= input.toTurnCount || new SchemaIssue.InvalidValue(Option.some(input.fromTurnCount), {
+  message: "fromTurnCount must be less than or equal to toTurnCount"
+}), { identifier: "OrchestrationTurnDiffRange" }));
+var ThreadTurnDiff = TurnCountRange.mapFields(Struct.assign({
+  threadId: ThreadId,
+  diff: Schema6.String
+}), { unsafePreserveChecks: true });
+var ProviderSessionRuntimeStatus = Schema6.Literals([
+  "starting",
+  "running",
+  "stopped",
+  "error"
+]);
+var ProjectionThreadTurnStatus = Schema6.Literals([
+  "running",
+  "completed",
+  "interrupted",
+  "error"
+]);
+var ProjectionCheckpointRow = Schema6.Struct({
+  threadId: ThreadId,
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema6.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema6.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var ProjectionPendingApprovalStatus = Schema6.Literals(["pending", "resolved"]);
+var ProjectionPendingApprovalDecision = Schema6.NullOr(ProviderApprovalDecision);
+var DispatchResult = Schema6.Struct({
+  sequence: NonNegativeInt
+});
+var OrchestrationGetSnapshotInput = Schema6.Struct({});
+var OrchestrationGetTurnDiffInput = TurnCountRange.mapFields(Struct.assign({ threadId: ThreadId }), { unsafePreserveChecks: true });
+var OrchestrationGetFullThreadDiffInput = Schema6.Struct({
+  threadId: ThreadId,
+  toTurnCount: NonNegativeInt
+});
+var OrchestrationReplayEventsInput = Schema6.Struct({
+  fromSequenceExclusive: NonNegativeInt
+});
+var OrchestrationReplayEventsResult = Schema6.Array(OrchestrationEvent);
+
+// packages/contracts/src/runtime.ts
+var RunKind = Schema7.Literals(["adhoc", "task", "batch", "validation", "review"]);
+var RunMode = Schema7.Literals(["interactive", "autonomous", "supervised"]);
+var RunStatus = Schema7.Literals([
+  "created",
+  "queued",
+  "preparing",
+  "running",
+  "waiting-approval",
+  "waiting-user-input",
+  "paused",
+  "validating",
+  "reviewing",
+  "closing-out",
+  "needs-attention",
+  "completed",
+  "failed",
+  "stopped"
+]);
+var EngineSandboxMode = Schema7.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var IsolationMode = Schema7.Literals(["none", "env", "worktree"]);
+var RuntimeStatus = Schema7.Literals([
+  "prepared",
+  "starting",
+  "running",
+  "interrupted",
+  "exited",
+  "failed",
+  "destroyed"
+]);
+var RunExecutionTarget = Schema7.Literals(["local", "remote"]);
+var RunSummary = Schema7.Struct({
+  id: RunId,
+  workspaceId: WorkspaceId,
+  taskId: Schema7.NullOr(TaskId),
+  title: TrimmedNonEmptyString,
+  runKind: RunKind,
+  mode: RunMode,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  status: RunStatus,
+  runtimeAdapter: Schema7.Literal("pi"),
+  model: Schema7.NullOr(TrimmedNonEmptyString),
+  initialPrompt: Schema7.NullOr(Schema7.String),
+  executionTarget: Schema7.optional(RunExecutionTarget),
+  remoteHostId: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseId: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseClaimedAt: Schema7.optional(Schema7.NullOr(IsoDateTime)),
+  activeRuntimeId: Schema7.NullOr(EngineRuntimeId),
+  latestMessageId: Schema7.NullOr(TrimmedNonEmptyString),
+  pendingApprovalCount: NonNegativeInt,
+  pendingUserInputCount: NonNegativeInt,
+  branch: Schema7.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema7.NullOr(TrimmedNonEmptyString),
+  errorText: Schema7.NullOr(Schema7.String),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  startedAt: Schema7.NullOr(IsoDateTime),
+  completedAt: Schema7.NullOr(IsoDateTime)
+});
+var RuntimeSummary = Schema7.Struct({
+  id: EngineRuntimeId,
+  workspaceId: WorkspaceId,
+  runId: RunId,
+  adapterKind: Schema7.Literal("pi"),
+  executionTarget: Schema7.optional(RunExecutionTarget),
+  remoteHostId: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  status: RuntimeStatus,
+  sandboxMode: EngineSandboxMode,
+  isolationMode: IsolationMode,
+  workspaceDir: Schema7.NullOr(TrimmedNonEmptyString),
+  homeDir: Schema7.NullOr(TrimmedNonEmptyString),
+  tmpDir: Schema7.NullOr(TrimmedNonEmptyString),
+  cacheDir: Schema7.NullOr(TrimmedNonEmptyString),
+  logsDir: Schema7.NullOr(TrimmedNonEmptyString),
+  stateDir: Schema7.NullOr(TrimmedNonEmptyString),
+  sessionDir: Schema7.NullOr(TrimmedNonEmptyString),
+  sessionLogPath: Schema7.NullOr(TrimmedNonEmptyString),
+  pid: Schema7.NullOr(NonNegativeInt),
+  startedAt: Schema7.NullOr(IsoDateTime),
+  updatedAt: IsoDateTime,
+  exitedAt: Schema7.NullOr(IsoDateTime)
+});
+var ApprovalStatus = Schema7.Literals(["pending", "resolved"]);
+var ApprovalSummary = Schema7.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  actionId: Schema7.NullOr(TrimmedNonEmptyString),
+  requestKind: TrimmedNonEmptyString,
+  status: ApprovalStatus,
+  payload: Schema7.Unknown,
+  createdAt: IsoDateTime,
+  resolvedAt: Schema7.NullOr(IsoDateTime)
+});
+var UserInputRequestSummary = Schema7.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  status: ApprovalStatus,
+  payload: Schema7.Unknown,
+  createdAt: IsoDateTime,
+  resolvedAt: Schema7.NullOr(IsoDateTime)
+});
+var WorktreeSummary = Schema7.Struct({
+  id: WorktreeId,
+  workspaceId: WorkspaceId,
+  runId: RunId,
+  taskId: Schema7.NullOr(TaskId),
+  branchName: TrimmedNonEmptyString,
+  path: TrimmedNonEmptyString,
+  status: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  cleanedAt: Schema7.NullOr(IsoDateTime)
+});
+
+// packages/contracts/src/supervisor-journal.ts
+var SupervisorStopReason = Schema8.Literals([
+  "all-done",
+  "all-human-blocked",
+  "max-tasks",
+  "budget",
+  "judge-stop",
+  "operator-stop",
+  "source-error"
+]);
+var SupervisorSelectionPolicy = Schema8.Literals(["rank", "max-unblock", "blocking-only"]);
+var SupervisorStatus = Schema8.Literals(["running", "idle", "stopped", "finished"]);
+var TaskClosureSummary = Schema8.Struct({
+  taskId: TaskId,
+  runId: RunId,
+  prUrl: Schema8.NullOr(Schema8.String),
+  mergeGate: Schema8.NullOr(Schema8.Literals(["passed", "blocked", "skipped"])),
+  acceptanceChecked: Schema8.Array(Schema8.Struct({
+    item: Schema8.String,
+    met: Schema8.Boolean
+  })),
+  unblockedTaskIds: Schema8.Array(TaskId)
+});
+var SupervisorStartedEvent = Schema8.Struct({
+  kind: Schema8.Literal("supervisor.started"),
+  at: IsoDateTime,
+  options: Schema8.Unknown
+});
+var SupervisorSelectionPlannedEvent = Schema8.Struct({
+  kind: Schema8.Literal("supervisor.selection-planned"),
+  at: IsoDateTime,
+  taskIds: Schema8.Array(TaskId),
+  policy: SupervisorSelectionPolicy
+});
+var SupervisorDispatchStartedEvent = Schema8.Struct({
+  kind: Schema8.Literal("supervisor.dispatch-started"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  score: NonNegativeInt
+});
+var SupervisorDispatchConfirmedEvent = Schema8.Struct({
+  kind: Schema8.Literal("supervisor.dispatch-confirmed"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  runId: RunId,
+  dispatchHandle: Schema8.optional(Schema8.NullOr(Schema8.String))
+});
+var SupervisorDispatchEvent = Schema8.Struct({
+  kind: Schema8.Literal("supervisor.dispatch"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  runId: RunId,
+  score: NonNegativeInt,
+  dispatchHandle: Schema8.optional(Schema8.NullOr(Schema8.String))
+});
+var SupervisorOutcomeEvent = Schema8.Struct({
+  kind: Schema8.Literal("supervisor.outcome"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  runId: RunId,
+  status: RunStatus,
+  failed: Schema8.Boolean,
+  unblockedTaskIds: Schema8.Array(TaskId),
+  closure: Schema8.optional(TaskClosureSummary)
+});
+var SupervisorSkippedEvent = Schema8.Struct({
+  kind: Schema8.Literal("supervisor.skipped"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  reason: Schema8.String
+});
+var SupervisorIdleEvent = Schema8.Struct({
+  kind: Schema8.Literal("supervisor.idle"),
+  at: IsoDateTime,
+  reason: SupervisorStopReason
+});
+var SupervisorStoppedEvent = Schema8.Struct({
+  kind: Schema8.Literal("supervisor.stopped"),
+  at: IsoDateTime,
+  reason: SupervisorStopReason
+});
+var SupervisorFinishedEvent = Schema8.Struct({
+  kind: Schema8.Literal("supervisor.finished"),
+  at: IsoDateTime,
+  processed: NonNegativeInt,
+  succeeded: NonNegativeInt,
+  failed: NonNegativeInt,
+  skipped: Schema8.optional(NonNegativeInt),
+  idleReason: Schema8.NullOr(SupervisorStopReason)
+});
+var SupervisorEvent = Schema8.Union([
+  SupervisorStartedEvent,
+  SupervisorSelectionPlannedEvent,
+  SupervisorDispatchStartedEvent,
+  SupervisorDispatchConfirmedEvent,
+  SupervisorDispatchEvent,
+  SupervisorOutcomeEvent,
+  SupervisorSkippedEvent,
+  SupervisorIdleEvent,
+  SupervisorStoppedEvent,
+  SupervisorFinishedEvent
+]);
+var SupervisorProjection = Schema8.Struct({
+  status: SupervisorStatus,
+  processed: NonNegativeInt,
+  succeeded: NonNegativeInt,
+  failed: NonNegativeInt,
+  skipped: NonNegativeInt,
+  current: Schema8.NullOr(Schema8.Struct({ taskId: TaskId, runId: RunId })),
+  plannedOrder: Schema8.Array(TaskId),
+  selectionPolicy: Schema8.NullOr(SupervisorSelectionPolicy),
+  concurrency: Schema8.NullOr(NonNegativeInt),
+  idleReason: Schema8.NullOr(SupervisorStopReason),
+  stopReason: Schema8.NullOr(SupervisorStopReason),
+  closures: Schema8.Array(TaskClosureSummary),
+  anomalies: Schema8.Array(Schema8.String)
 });
 
 // packages/contracts/src/config.ts
-var WorkspaceIsolation = Schema2.Literals([
+var WorkspaceIsolation = Schema9.Literals([
   "worktree",
   "directory"
 ]);
 var WorkspaceCheckout = WorkspaceIsolation;
-var WorkspaceSandbox = Schema2.Literals(["enforce", "auto", "off"]);
-var ScopeSearchPrefix = Schema2.Struct({
-  prefix: Schema2.String,
-  matchStartsWith: Schema2.optional(Schema2.Array(Schema2.String)),
-  matchExact: Schema2.optional(Schema2.Array(Schema2.String))
-});
-var ScopeNormalizationRules = Schema2.Struct({
-  stripPrefixes: Schema2.optional(Schema2.Array(Schema2.String)),
-  searchPrefixes: Schema2.optional(Schema2.Array(ScopeSearchPrefix))
-});
-var WorkspaceConfig = Schema2.Struct({
-  mainRepo: Schema2.String,
-  checkout: Schema2.optional(WorkspaceCheckout),
-  isolation: Schema2.optional(WorkspaceIsolation),
-  sandbox: Schema2.optional(WorkspaceSandbox),
-  scopeNormalization: Schema2.optional(ScopeNormalizationRules)
-});
-var TaskSourceConfig = Schema2.Struct({
-  kind: Schema2.String,
-  path: Schema2.optional(Schema2.String),
-  owner: Schema2.optional(Schema2.String),
-  repo: Schema2.optional(Schema2.String),
-  labels: Schema2.optional(Schema2.Array(Schema2.String)),
-  state: Schema2.optional(Schema2.Literals(["open", "closed", "all"])),
-  url: Schema2.optional(Schema2.String),
-  options: Schema2.optional(Schema2.Record(Schema2.String, Schema2.Unknown))
-});
-var RuntimeHarness = Schema2.Literal("pi");
-var RigRuntimeMode = Schema2.Literals(["yolo", "approval-required"]);
-var PiRuntimeConfig = Schema2.Struct({
-  packages: Schema2.optional(Schema2.Array(Schema2.String))
-});
-var RigServerConfig = Schema2.Struct({
-  host: Schema2.optional(Schema2.String),
-  relayUrl: Schema2.optional(Schema2.String),
-  registryUrl: Schema2.optional(Schema2.String),
-  sshTarget: Schema2.optional(Schema2.String),
-  checkout: Schema2.optional(Schema2.String)
-});
-var RuntimeConfig = Schema2.Struct({
-  agentRoles: Schema2.optional(Schema2.Record(Schema2.String, Schema2.Unknown)),
-  timeouts: Schema2.optional(Schema2.Record(Schema2.String, Schema2.Number)),
-  harness: Schema2.optional(RuntimeHarness),
-  model: Schema2.optional(Schema2.String),
-  mode: Schema2.optional(RigRuntimeMode),
-  pi: Schema2.optional(PiRuntimeConfig),
-  server: Schema2.optional(RigServerConfig)
-});
-var ProjectIdentity = Schema2.Struct({
-  name: Schema2.String,
-  repo: Schema2.optional(Schema2.String)
-});
-var PlanningConfig = Schema2.Struct({
-  mode: Schema2.optional(Schema2.Literals(["auto", "always", "off"])),
-  requireForLabels: Schema2.optional(Schema2.Array(Schema2.String)),
-  skipForLabels: Schema2.optional(Schema2.Array(Schema2.String))
-});
-var GitHubProjectStatusConfig = Schema2.Struct({
-  enabled: Schema2.optional(Schema2.Boolean),
-  projectId: Schema2.optional(Schema2.String),
-  statusFieldId: Schema2.optional(Schema2.String),
-  statuses: Schema2.optional(Schema2.Struct({
-    running: Schema2.optional(Schema2.String),
-    prOpen: Schema2.optional(Schema2.String),
-    ciFixing: Schema2.optional(Schema2.String),
-    merging: Schema2.optional(Schema2.String),
-    done: Schema2.optional(Schema2.String),
-    needsAttention: Schema2.optional(Schema2.String)
+var WorkspaceSandbox = Schema9.Literals(["enforce", "auto", "off"]);
+var ScopeSearchPrefix = Schema9.Struct({
+  prefix: Schema9.String,
+  matchStartsWith: Schema9.optional(Schema9.Array(Schema9.String)),
+  matchExact: Schema9.optional(Schema9.Array(Schema9.String))
+});
+var ScopeNormalizationRules = Schema9.Struct({
+  stripPrefixes: Schema9.optional(Schema9.Array(Schema9.String)),
+  searchPrefixes: Schema9.optional(Schema9.Array(ScopeSearchPrefix))
+});
+var WorkspaceConfig = Schema9.Struct({
+  mainRepo: Schema9.String,
+  checkout: Schema9.optional(WorkspaceCheckout),
+  isolation: Schema9.optional(WorkspaceIsolation),
+  sandbox: Schema9.optional(WorkspaceSandbox),
+  scopeNormalization: Schema9.optional(ScopeNormalizationRules)
+});
+var TaskSourceConfig = Schema9.Struct({
+  kind: Schema9.String,
+  path: Schema9.optional(Schema9.String),
+  owner: Schema9.optional(Schema9.String),
+  repo: Schema9.optional(Schema9.String),
+  labels: Schema9.optional(Schema9.Array(Schema9.String)),
+  state: Schema9.optional(Schema9.Literals(["open", "closed", "all"])),
+  url: Schema9.optional(Schema9.String),
+  options: Schema9.optional(Schema9.Record(Schema9.String, Schema9.Unknown))
+});
+var RuntimeHarness = Schema9.Literal("pi");
+var RigRuntimeMode = Schema9.Literals(["yolo", "approval-required"]);
+var PiRuntimeConfig = Schema9.Struct({
+  packages: Schema9.optional(Schema9.Array(Schema9.String))
+});
+var RigServerConfig = Schema9.Struct({
+  host: Schema9.optional(Schema9.String),
+  relayUrl: Schema9.optional(Schema9.String),
+  registryUrl: Schema9.optional(Schema9.String),
+  sshTarget: Schema9.optional(Schema9.String),
+  checkout: Schema9.optional(Schema9.String)
+});
+var RuntimePositiveInt = Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(1));
+var RuntimeSupervisorConfig = Schema9.Struct({
+  concurrency: Schema9.optional(RuntimePositiveInt),
+  pauseOnAttention: Schema9.optional(Schema9.Boolean),
+  stopWhen: Schema9.optional(Schema9.Array(SupervisorStopReason)),
+  maxTasks: Schema9.optional(RuntimePositiveInt),
+  selectionPolicy: Schema9.optional(SupervisorSelectionPolicy),
+  failFast: Schema9.optional(Schema9.Boolean)
+});
+var RuntimeDriftConfig = Schema9.Struct({
+  enabled: Schema9.optional(Schema9.Boolean),
+  failOnDrift: Schema9.optional(Schema9.Boolean),
+  docsGlobs: Schema9.optional(Schema9.Array(Schema9.String)),
+  ignoreGlobs: Schema9.optional(Schema9.Array(Schema9.String)),
+  judge: Schema9.optional(Schema9.Boolean)
+});
+var RuntimePlanningConfig = Schema9.Struct({
+  architectRole: Schema9.optional(Schema9.String),
+  autoResolveFromCode: Schema9.optional(Schema9.Boolean),
+  materialize: Schema9.optional(Schema9.Literals(["dry-run", "create"]))
+});
+var RuntimeConfig = Schema9.Struct({
+  agentRoles: Schema9.optional(Schema9.Record(Schema9.String, Schema9.Unknown)),
+  timeouts: Schema9.optional(Schema9.Record(Schema9.String, Schema9.Number)),
+  harness: Schema9.optional(RuntimeHarness),
+  model: Schema9.optional(Schema9.String),
+  mode: Schema9.optional(RigRuntimeMode),
+  pi: Schema9.optional(PiRuntimeConfig),
+  server: Schema9.optional(RigServerConfig),
+  capabilities: Schema9.optional(CapabilityGrants),
+  supervisor: Schema9.optional(RuntimeSupervisorConfig),
+  drift: Schema9.optional(RuntimeDriftConfig),
+  planning: Schema9.optional(RuntimePlanningConfig)
+});
+var ProjectIdentity = Schema9.Struct({
+  name: Schema9.String,
+  repo: Schema9.optional(Schema9.String)
+});
+var PlanningConfig = Schema9.Struct({
+  mode: Schema9.optional(Schema9.Literals(["auto", "always", "off"])),
+  requireForLabels: Schema9.optional(Schema9.Array(Schema9.String)),
+  skipForLabels: Schema9.optional(Schema9.Array(Schema9.String))
+});
+var GitHubProjectStatusConfig = Schema9.Struct({
+  enabled: Schema9.optional(Schema9.Boolean),
+  projectId: Schema9.optional(Schema9.String),
+  statusFieldId: Schema9.optional(Schema9.String),
+  statuses: Schema9.optional(Schema9.Struct({
+    running: Schema9.optional(Schema9.String),
+    prOpen: Schema9.optional(Schema9.String),
+    ciFixing: Schema9.optional(Schema9.String),
+    merging: Schema9.optional(Schema9.String),
+    done: Schema9.optional(Schema9.String),
+    needsAttention: Schema9.optional(Schema9.String)
   }))
 });
-var GitHubConfig = Schema2.Struct({
-  issueUpdates: Schema2.optional(Schema2.Literals(["lifecycle", "minimal", "off"])),
-  projects: Schema2.optional(GitHubProjectStatusConfig)
-});
-var AutomationConfig = Schema2.Struct({
-  maxValidationAttempts: Schema2.optional(Schema2.Number),
-  maxPrFixIterations: Schema2.optional(Schema2.Number)
-});
-var PullRequestConfig = Schema2.Struct({
-  mode: Schema2.optional(Schema2.Literals(["auto", "ask", "off"])),
-  watchChecks: Schema2.optional(Schema2.Boolean),
-  autoFixChecks: Schema2.optional(Schema2.Boolean),
-  autoFixReview: Schema2.optional(Schema2.Boolean),
-  pendingTimeoutMs: Schema2.optional(Schema2.Number),
-  pendingPollMs: Schema2.optional(Schema2.Number)
-});
-var MergeConfig = Schema2.Struct({
-  mode: Schema2.optional(Schema2.Literals(["auto", "off", "pr-ready"])),
-  method: Schema2.optional(Schema2.Literals(["repo-default", "squash", "merge", "rebase"])),
-  deleteBranch: Schema2.optional(Schema2.Union([Schema2.Literal("repo-default"), Schema2.Boolean])),
-  allowedFailures: Schema2.optional(Schema2.Array(Schema2.String)),
-  bypass: Schema2.optional(Schema2.Boolean)
-});
-var IssueAnalysisConfig = Schema2.Struct({
-  enabled: Schema2.optional(Schema2.Boolean),
-  harness: Schema2.optional(Schema2.Literal("pi")),
-  model: Schema2.optional(Schema2.String),
-  mode: Schema2.optional(Schema2.Literals(["continuous", "off"]))
-});
-var ReviewConfig = Schema2.Struct({
-  mode: Schema2.optional(Schema2.Literals(["off", "advisory", "required"])),
-  provider: Schema2.optional(Schema2.Literals(["greptile", "github"]))
-});
-var RigConfig = Schema2.Struct({
+var GitHubConfig = Schema9.Struct({
+  issueUpdates: Schema9.optional(Schema9.Literals(["lifecycle", "minimal", "off"])),
+  projects: Schema9.optional(GitHubProjectStatusConfig)
+});
+var AutomationConfig = Schema9.Struct({
+  maxValidationAttempts: Schema9.optional(Schema9.Number),
+  maxPrFixIterations: Schema9.optional(Schema9.Number)
+});
+var PullRequestConfig = Schema9.Struct({
+  mode: Schema9.optional(Schema9.Literals(["auto", "ask", "off"])),
+  watchChecks: Schema9.optional(Schema9.Boolean),
+  autoFixChecks: Schema9.optional(Schema9.Boolean),
+  autoFixReview: Schema9.optional(Schema9.Boolean),
+  pendingTimeoutMs: Schema9.optional(Schema9.Number),
+  pendingPollMs: Schema9.optional(Schema9.Number)
+});
+var MergeConfig = Schema9.Struct({
+  mode: Schema9.optional(Schema9.Literals(["auto", "off", "pr-ready"])),
+  method: Schema9.optional(Schema9.Literals(["repo-default", "squash", "merge", "rebase"])),
+  deleteBranch: Schema9.optional(Schema9.Union([Schema9.Literal("repo-default"), Schema9.Boolean])),
+  allowedFailures: Schema9.optional(Schema9.Array(Schema9.String)),
+  bypass: Schema9.optional(Schema9.Boolean)
+});
+var IssueAnalysisConfig = Schema9.Struct({
+  enabled: Schema9.optional(Schema9.Boolean),
+  harness: Schema9.optional(Schema9.Literal("pi")),
+  model: Schema9.optional(Schema9.String),
+  mode: Schema9.optional(Schema9.Literals(["continuous", "off"]))
+});
+var ReviewConfig = Schema9.Struct({
+  mode: Schema9.optional(Schema9.Literals(["off", "advisory", "required"])),
+  provider: Schema9.optional(Schema9.Literals(["greptile", "github"]))
+});
+var RigConfig = Schema9.Struct({
   project: ProjectIdentity,
-  plugins: Schema2.Array(RigPlugin),
+  plugins: Schema9.Array(RigPlugin),
   taskSource: TaskSourceConfig,
   workspace: WorkspaceConfig,
-  runtime: Schema2.optional(RuntimeConfig),
-  planning: Schema2.optional(PlanningConfig),
-  github: Schema2.optional(GitHubConfig),
-  automation: Schema2.optional(AutomationConfig),
-  pr: Schema2.optional(PullRequestConfig),
-  merge: Schema2.optional(MergeConfig),
-  review: Schema2.optional(ReviewConfig),
-  issueAnalysis: Schema2.optional(IssueAnalysisConfig),
-  env: Schema2.optional(Schema2.Record(Schema2.String, Schema2.String))
+  runtime: Schema9.optional(RuntimeConfig),
+  planning: Schema9.optional(PlanningConfig),
+  github: Schema9.optional(GitHubConfig),
+  automation: Schema9.optional(AutomationConfig),
+  pr: Schema9.optional(PullRequestConfig),
+  merge: Schema9.optional(MergeConfig),
+  review: Schema9.optional(ReviewConfig),
+  issueAnalysis: Schema9.optional(IssueAnalysisConfig),
+  capabilities: Schema9.optional(CapabilityGrants),
+  env: Schema9.optional(Schema9.Record(Schema9.String, Schema9.String))
 });
 export {
   WorkspaceSandbox,
@@ -220,7 +1605,10 @@ export {
   TaskSourceConfig,
   ScopeSearchPrefix,
   ScopeNormalizationRules,
+  RuntimeSupervisorConfig,
+  RuntimePlanningConfig,
   RuntimeHarness,
+  RuntimeDriftConfig,
   RuntimeConfig,
   RigServerConfig,
   RigRuntimeMode,