@h-rig/contracts 0.0.6-alpha.157 → 0.0.6-alpha.158

package/dist/src/config.js

@@ -1,6 +1,6 @@
 // @bun
 // packages/contracts/src/config.ts
-import { Schema as Schema9 } from "effect";
+import { Schema as Schema8 } from "effect";
 
 // packages/contracts/src/plugin.ts
 import { Schema as Schema4 } from "effect";
@@ -45,6 +45,11 @@ var ApprovalRequestId = makeEntityId("ApprovalRequestId");
 var CheckpointRef = makeEntityId("CheckpointRef");
 var RemoteEndpointId = makeEntityId("RemoteEndpointId");
 
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
 // packages/contracts/src/stage.ts
 import { Schema as Schema2 } from "effect";
 var StageKind = Schema2.Literals(["transform", "gate", "observe"]);
@@ -219,6 +224,7 @@ var JournalEvent = Schema3.Struct({
   at: IsoDateTime,
   payload: Schema3.Unknown
 });
+var PLACEMENT_RUN_TRANSPORT = makeCapabilityId("transport.placement-run");
 
 // packages/contracts/src/plugin.ts
 var ValidatorCategory = Schema4.Literals([
@@ -291,14 +297,19 @@ var CliCommandRegistration = Schema4.Struct({
   description: Schema4.optional(Schema4.String),
   usage: Schema4.optional(Schema4.String),
   aliases: Schema4.optional(Schema4.Array(Schema4.String)),
-  projectRequired: Schema4.optional(Schema4.Boolean)
+  projectRequired: Schema4.optional(Schema4.Boolean),
+  rootDefault: Schema4.optional(Schema4.Boolean),
+  productRoot: Schema4.optional(Schema4.Boolean),
+  subcommands: Schema4.optional(Schema4.Array(Schema4.String))
 });
+var CapabilityRunSchema = Schema4.declare((u) => typeof u === "function", { identifier: "CapabilityRun" });
 var ProductCapabilityRegistration = Schema4.Struct({
   id: Schema4.String,
   title: Schema4.String,
   description: Schema4.optional(Schema4.String),
   commandId: Schema4.optional(Schema4.String),
-  panelId: Schema4.optional(Schema4.String)
+  panelId: Schema4.optional(Schema4.String),
+  run: Schema4.optional(CapabilityRunSchema)
 });
 var PanelRegistration = Schema4.Struct({
   id: Schema4.String,
@@ -318,6 +329,13 @@ var SessionExtensionRegistration = Schema4.Struct({
   id: Schema4.String,
   description: Schema4.optional(Schema4.String)
 });
+var SeedEntrypointRegistration = Schema4.Struct({
+  id: Schema4.String,
+  description: Schema4.optional(Schema4.String),
+  basename: Schema4.optional(Schema4.String),
+  workerArg: Schema4.optional(Schema4.String),
+  insidePty: Schema4.optional(Schema4.Boolean)
+});
 var PluginContributes = Schema4.Struct({
   validators: Schema4.optional(Schema4.Array(ValidatorRegistration)),
   hooks: Schema4.optional(Schema4.Array(HookRegistration)),
@@ -332,7 +350,8 @@ var PluginContributes = Schema4.Struct({
   capabilities: Schema4.optional(Schema4.Array(ProductCapabilityRegistration)),
   panels: Schema4.optional(Schema4.Array(PanelRegistration)),
   blockerClassifiers: Schema4.optional(Schema4.Array(BlockerClassifierRegistration)),
-  sessionExtensions: Schema4.optional(Schema4.Array(SessionExtensionRegistration))
+  sessionExtensions: Schema4.optional(Schema4.Array(SessionExtensionRegistration)),
+  seedEntrypoints: Schema4.optional(Schema4.Array(SeedEntrypointRegistration))
 });
 var RigPlugin = Schema4.Struct({
   name: Schema4.String,
@@ -344,890 +363,52 @@ var RigPlugin = Schema4.Struct({
 });
 
 // packages/contracts/src/supervisor-journal.ts
-import { Schema as Schema8 } from "effect";
+import { Schema as Schema7 } from "effect";
 
 // packages/contracts/src/runtime.ts
-import { Schema as Schema7 } from "effect";
+import { Schema as Schema6 } 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([
+var ProviderKind = Schema5.Literals(["codex", "claude"]);
+var ProviderApprovalPolicy = Schema5.Literals([
   "untrusted",
   "on-failure",
   "on-request",
   "never"
 ]);
-var ProviderSandboxMode = Schema6.Literals([
+var ProviderSandboxMode = Schema5.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([
+var ProviderServiceTier = Schema5.Literals(["fast", "flex"]);
+var RuntimeMode = Schema5.Literals(["approval-required", "full-access"]);
+var ProviderInteractionMode = Schema5.Literals(["default", "plan"]);
+var ProviderRequestKind = Schema5.Literals(["command", "file-read", "file-change"]);
+var ProviderApprovalDecision = Schema5.Literals([
   "accept",
   "acceptForSession",
   "decline",
   "cancel"
 ]);
-var ProviderUserInputAnswers = Schema6.Record(Schema6.String, Schema6.Unknown);
+var ProviderUserInputAnswers = Schema5.Record(Schema5.String, Schema5.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"),
+var ChatAttachmentId = TrimmedNonEmptyString.check(Schema5.isMaxLength(CHAT_ATTACHMENT_ID_MAX_CHARS), Schema5.isPattern(/^[a-z0-9_-]+$/i));
+var ChatImageAttachment = Schema5.Struct({
+  type: Schema5.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
+  name: TrimmedNonEmptyString.check(Schema5.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema5.isMaxLength(100), Schema5.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema5.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES))
 });
-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);
+var ChatAttachment = Schema5.Union([ChatImageAttachment]);
 
 // 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([
+var RunKind = Schema6.Literals(["adhoc", "task", "batch", "validation", "review"]);
+var RunMode = Schema6.Literals(["interactive", "autonomous", "supervised"]);
+var RunStatus = Schema6.Literals([
   "created",
   "queued",
   "preparing",
@@ -1243,13 +424,13 @@ var RunStatus = Schema7.Literals([
   "failed",
   "stopped"
 ]);
-var EngineSandboxMode = Schema7.Literals([
+var EngineSandboxMode = Schema6.Literals([
   "read-only",
   "workspace-write",
   "danger-full-access"
 ]);
-var IsolationMode = Schema7.Literals(["none", "env", "worktree"]);
-var RuntimeStatus = Schema7.Literals([
+var IsolationMode = Schema6.Literals(["none", "env", "worktree"]);
+var RuntimeStatus = Schema6.Literals([
   "prepared",
   "starting",
   "running",
@@ -1258,92 +439,92 @@ var RuntimeStatus = Schema7.Literals([
   "failed",
   "destroyed"
 ]);
-var RunExecutionTarget = Schema7.Literals(["local", "remote"]);
-var RunSummary = Schema7.Struct({
+var RunExecutionTarget = Schema6.Literals(["local", "remote"]);
+var RunSummary = Schema6.Struct({
   id: RunId,
   workspaceId: WorkspaceId,
-  taskId: Schema7.NullOr(TaskId),
+  taskId: Schema6.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),
+  runtimeAdapter: Schema6.Literal("pi"),
+  model: Schema6.NullOr(TrimmedNonEmptyString),
+  initialPrompt: Schema6.NullOr(Schema6.String),
+  executionTarget: Schema6.optional(RunExecutionTarget),
+  remoteHostId: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseId: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseClaimedAt: Schema6.optional(Schema6.NullOr(IsoDateTime)),
+  activeRuntimeId: Schema6.NullOr(EngineRuntimeId),
+  latestMessageId: Schema6.NullOr(TrimmedNonEmptyString),
   pendingApprovalCount: NonNegativeInt,
   pendingUserInputCount: NonNegativeInt,
-  branch: Schema7.NullOr(TrimmedNonEmptyString),
-  worktreePath: Schema7.NullOr(TrimmedNonEmptyString),
-  errorText: Schema7.NullOr(Schema7.String),
+  branch: Schema6.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema6.NullOr(TrimmedNonEmptyString),
+  errorText: Schema6.NullOr(Schema6.String),
   createdAt: IsoDateTime,
   updatedAt: IsoDateTime,
-  startedAt: Schema7.NullOr(IsoDateTime),
-  completedAt: Schema7.NullOr(IsoDateTime)
+  startedAt: Schema6.NullOr(IsoDateTime),
+  completedAt: Schema6.NullOr(IsoDateTime)
 });
-var RuntimeSummary = Schema7.Struct({
+var RuntimeSummary = Schema6.Struct({
   id: EngineRuntimeId,
   workspaceId: WorkspaceId,
   runId: RunId,
-  adapterKind: Schema7.Literal("pi"),
-  executionTarget: Schema7.optional(RunExecutionTarget),
-  remoteHostId: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  adapterKind: Schema6.Literal("pi"),
+  executionTarget: Schema6.optional(RunExecutionTarget),
+  remoteHostId: Schema6.optional(Schema6.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),
+  workspaceDir: Schema6.NullOr(TrimmedNonEmptyString),
+  homeDir: Schema6.NullOr(TrimmedNonEmptyString),
+  tmpDir: Schema6.NullOr(TrimmedNonEmptyString),
+  cacheDir: Schema6.NullOr(TrimmedNonEmptyString),
+  logsDir: Schema6.NullOr(TrimmedNonEmptyString),
+  stateDir: Schema6.NullOr(TrimmedNonEmptyString),
+  sessionDir: Schema6.NullOr(TrimmedNonEmptyString),
+  sessionLogPath: Schema6.NullOr(TrimmedNonEmptyString),
+  pid: Schema6.NullOr(NonNegativeInt),
+  startedAt: Schema6.NullOr(IsoDateTime),
   updatedAt: IsoDateTime,
-  exitedAt: Schema7.NullOr(IsoDateTime)
+  exitedAt: Schema6.NullOr(IsoDateTime)
 });
-var ApprovalStatus = Schema7.Literals(["pending", "resolved"]);
-var ApprovalSummary = Schema7.Struct({
+var ApprovalStatus = Schema6.Literals(["pending", "resolved"]);
+var ApprovalSummary = Schema6.Struct({
   id: TrimmedNonEmptyString,
   runId: RunId,
-  actionId: Schema7.NullOr(TrimmedNonEmptyString),
+  actionId: Schema6.NullOr(TrimmedNonEmptyString),
   requestKind: TrimmedNonEmptyString,
   status: ApprovalStatus,
-  payload: Schema7.Unknown,
+  payload: Schema6.Unknown,
   createdAt: IsoDateTime,
-  resolvedAt: Schema7.NullOr(IsoDateTime)
+  resolvedAt: Schema6.NullOr(IsoDateTime)
 });
-var UserInputRequestSummary = Schema7.Struct({
+var UserInputRequestSummary = Schema6.Struct({
   id: TrimmedNonEmptyString,
   runId: RunId,
   status: ApprovalStatus,
-  payload: Schema7.Unknown,
+  payload: Schema6.Unknown,
   createdAt: IsoDateTime,
-  resolvedAt: Schema7.NullOr(IsoDateTime)
+  resolvedAt: Schema6.NullOr(IsoDateTime)
 });
-var WorktreeSummary = Schema7.Struct({
+var WorktreeSummary = Schema6.Struct({
   id: WorktreeId,
   workspaceId: WorkspaceId,
   runId: RunId,
-  taskId: Schema7.NullOr(TaskId),
+  taskId: Schema6.NullOr(TaskId),
   branchName: TrimmedNonEmptyString,
   path: TrimmedNonEmptyString,
   status: TrimmedNonEmptyString,
   createdAt: IsoDateTime,
-  cleanedAt: Schema7.NullOr(IsoDateTime)
+  cleanedAt: Schema6.NullOr(IsoDateTime)
 });
 
 // packages/contracts/src/supervisor-journal.ts
-var SupervisorStopReason = Schema8.Literals([
+var SupervisorStopReason = Schema7.Literals([
   "all-done",
   "all-human-blocked",
   "max-tasks",
@@ -1352,87 +533,87 @@ var SupervisorStopReason = Schema8.Literals([
   "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({
+var SupervisorSelectionPolicy = Schema7.Literals(["rank", "max-unblock", "blocking-only"]);
+var SupervisorStatus = Schema7.Literals(["running", "idle", "stopped", "finished"]);
+var TaskClosureSummary = Schema7.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
+  prUrl: Schema7.NullOr(Schema7.String),
+  mergeGate: Schema7.NullOr(Schema7.Literals(["passed", "blocked", "skipped"])),
+  acceptanceChecked: Schema7.Array(Schema7.Struct({
+    item: Schema7.String,
+    met: Schema7.Boolean
   })),
-  unblockedTaskIds: Schema8.Array(TaskId)
+  unblockedTaskIds: Schema7.Array(TaskId)
 });
-var SupervisorStartedEvent = Schema8.Struct({
-  kind: Schema8.Literal("supervisor.started"),
+var SupervisorStartedEvent = Schema7.Struct({
+  kind: Schema7.Literal("supervisor.started"),
   at: IsoDateTime,
-  options: Schema8.Unknown
+  options: Schema7.Unknown
 });
-var SupervisorSelectionPlannedEvent = Schema8.Struct({
-  kind: Schema8.Literal("supervisor.selection-planned"),
+var SupervisorSelectionPlannedEvent = Schema7.Struct({
+  kind: Schema7.Literal("supervisor.selection-planned"),
   at: IsoDateTime,
-  taskIds: Schema8.Array(TaskId),
+  taskIds: Schema7.Array(TaskId),
   policy: SupervisorSelectionPolicy
 });
-var SupervisorDispatchStartedEvent = Schema8.Struct({
-  kind: Schema8.Literal("supervisor.dispatch-started"),
+var SupervisorDispatchStartedEvent = Schema7.Struct({
+  kind: Schema7.Literal("supervisor.dispatch-started"),
   at: IsoDateTime,
   taskId: TaskId,
   score: NonNegativeInt
 });
-var SupervisorDispatchConfirmedEvent = Schema8.Struct({
-  kind: Schema8.Literal("supervisor.dispatch-confirmed"),
+var SupervisorDispatchConfirmedEvent = Schema7.Struct({
+  kind: Schema7.Literal("supervisor.dispatch-confirmed"),
   at: IsoDateTime,
   taskId: TaskId,
   runId: RunId,
-  dispatchHandle: Schema8.optional(Schema8.NullOr(Schema8.String))
+  dispatchHandle: Schema7.optional(Schema7.NullOr(Schema7.String))
 });
-var SupervisorDispatchEvent = Schema8.Struct({
-  kind: Schema8.Literal("supervisor.dispatch"),
+var SupervisorDispatchEvent = Schema7.Struct({
+  kind: Schema7.Literal("supervisor.dispatch"),
   at: IsoDateTime,
   taskId: TaskId,
   runId: RunId,
   score: NonNegativeInt,
-  dispatchHandle: Schema8.optional(Schema8.NullOr(Schema8.String))
+  dispatchHandle: Schema7.optional(Schema7.NullOr(Schema7.String))
 });
-var SupervisorOutcomeEvent = Schema8.Struct({
-  kind: Schema8.Literal("supervisor.outcome"),
+var SupervisorOutcomeEvent = Schema7.Struct({
+  kind: Schema7.Literal("supervisor.outcome"),
   at: IsoDateTime,
   taskId: TaskId,
   runId: RunId,
   status: RunStatus,
-  failed: Schema8.Boolean,
-  unblockedTaskIds: Schema8.Array(TaskId),
-  closure: Schema8.optional(TaskClosureSummary)
+  failed: Schema7.Boolean,
+  unblockedTaskIds: Schema7.Array(TaskId),
+  closure: Schema7.optional(TaskClosureSummary)
 });
-var SupervisorSkippedEvent = Schema8.Struct({
-  kind: Schema8.Literal("supervisor.skipped"),
+var SupervisorSkippedEvent = Schema7.Struct({
+  kind: Schema7.Literal("supervisor.skipped"),
   at: IsoDateTime,
   taskId: TaskId,
-  reason: Schema8.String
+  reason: Schema7.String
 });
-var SupervisorIdleEvent = Schema8.Struct({
-  kind: Schema8.Literal("supervisor.idle"),
+var SupervisorIdleEvent = Schema7.Struct({
+  kind: Schema7.Literal("supervisor.idle"),
   at: IsoDateTime,
   reason: SupervisorStopReason
 });
-var SupervisorStoppedEvent = Schema8.Struct({
-  kind: Schema8.Literal("supervisor.stopped"),
+var SupervisorStoppedEvent = Schema7.Struct({
+  kind: Schema7.Literal("supervisor.stopped"),
   at: IsoDateTime,
   reason: SupervisorStopReason
 });
-var SupervisorFinishedEvent = Schema8.Struct({
-  kind: Schema8.Literal("supervisor.finished"),
+var SupervisorFinishedEvent = Schema7.Struct({
+  kind: Schema7.Literal("supervisor.finished"),
   at: IsoDateTime,
   processed: NonNegativeInt,
   succeeded: NonNegativeInt,
   failed: NonNegativeInt,
-  skipped: Schema8.optional(NonNegativeInt),
-  idleReason: Schema8.NullOr(SupervisorStopReason)
+  skipped: Schema7.optional(NonNegativeInt),
+  idleReason: Schema7.NullOr(SupervisorStopReason)
 });
-var SupervisorEvent = Schema8.Union([
+var SupervisorEvent = Schema7.Union([
   SupervisorStartedEvent,
   SupervisorSelectionPlannedEvent,
   SupervisorDispatchStartedEvent,
@@ -1444,171 +625,171 @@ var SupervisorEvent = Schema8.Union([
   SupervisorStoppedEvent,
   SupervisorFinishedEvent
 ]);
-var SupervisorProjection = Schema8.Struct({
+var SupervisorProjection = Schema7.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)
+  current: Schema7.NullOr(Schema7.Struct({ taskId: TaskId, runId: RunId })),
+  plannedOrder: Schema7.Array(TaskId),
+  selectionPolicy: Schema7.NullOr(SupervisorSelectionPolicy),
+  concurrency: Schema7.NullOr(NonNegativeInt),
+  idleReason: Schema7.NullOr(SupervisorStopReason),
+  stopReason: Schema7.NullOr(SupervisorStopReason),
+  closures: Schema7.Array(TaskClosureSummary),
+  anomalies: Schema7.Array(Schema7.String)
 });
 
 // packages/contracts/src/config.ts
-var WorkspaceIsolation = Schema9.Literals([
+var WorkspaceIsolation = Schema8.Literals([
   "worktree",
   "directory"
 ]);
 var WorkspaceCheckout = WorkspaceIsolation;
-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 WorkspaceSandbox = Schema8.Literals(["enforce", "auto", "off"]);
+var ScopeSearchPrefix = Schema8.Struct({
+  prefix: Schema8.String,
+  matchStartsWith: Schema8.optional(Schema8.Array(Schema8.String)),
+  matchExact: Schema8.optional(Schema8.Array(Schema8.String))
+});
+var ScopeNormalizationRules = Schema8.Struct({
+  stripPrefixes: Schema8.optional(Schema8.Array(Schema8.String)),
+  searchPrefixes: Schema8.optional(Schema8.Array(ScopeSearchPrefix))
+});
+var WorkspaceConfig = Schema8.Struct({
+  mainRepo: Schema8.String,
+  checkout: Schema8.optional(WorkspaceCheckout),
+  isolation: Schema8.optional(WorkspaceIsolation),
+  sandbox: Schema8.optional(WorkspaceSandbox),
+  scopeNormalization: Schema8.optional(ScopeNormalizationRules)
+});
+var TaskSourceConfig = Schema8.Struct({
+  kind: Schema8.String,
+  path: Schema8.optional(Schema8.String),
+  owner: Schema8.optional(Schema8.String),
+  repo: Schema8.optional(Schema8.String),
+  labels: Schema8.optional(Schema8.Array(Schema8.String)),
+  state: Schema8.optional(Schema8.Literals(["open", "closed", "all"])),
+  url: Schema8.optional(Schema8.String),
+  options: Schema8.optional(Schema8.Record(Schema8.String, Schema8.Unknown))
+});
+var RuntimeHarness = Schema8.Literal("pi");
+var RigRuntimeMode = Schema8.Literals(["yolo", "approval-required"]);
+var PiRuntimeConfig = Schema8.Struct({
+  packages: Schema8.optional(Schema8.Array(Schema8.String))
+});
+var RigServerConfig = Schema8.Struct({
+  host: Schema8.optional(Schema8.String),
+  relayUrl: Schema8.optional(Schema8.String),
+  registryUrl: Schema8.optional(Schema8.String),
+  sshTarget: Schema8.optional(Schema8.String),
+  checkout: Schema8.optional(Schema8.String)
+});
+var RuntimePositiveInt = Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(1));
+var RuntimeSupervisorConfig = Schema8.Struct({
+  concurrency: Schema8.optional(RuntimePositiveInt),
+  pauseOnAttention: Schema8.optional(Schema8.Boolean),
+  stopWhen: Schema8.optional(Schema8.Array(SupervisorStopReason)),
+  maxTasks: Schema8.optional(RuntimePositiveInt),
+  selectionPolicy: Schema8.optional(SupervisorSelectionPolicy),
+  failFast: Schema8.optional(Schema8.Boolean)
+});
+var RuntimeDriftConfig = Schema8.Struct({
+  enabled: Schema8.optional(Schema8.Boolean),
+  failOnDrift: Schema8.optional(Schema8.Boolean),
+  docsGlobs: Schema8.optional(Schema8.Array(Schema8.String)),
+  ignoreGlobs: Schema8.optional(Schema8.Array(Schema8.String)),
+  judge: Schema8.optional(Schema8.Boolean)
+});
+var RuntimePlanningConfig = Schema8.Struct({
+  architectRole: Schema8.optional(Schema8.String),
+  autoResolveFromCode: Schema8.optional(Schema8.Boolean),
+  materialize: Schema8.optional(Schema8.Literals(["dry-run", "create"]))
+});
+var RuntimeConfig = Schema8.Struct({
+  agentRoles: Schema8.optional(Schema8.Record(Schema8.String, Schema8.Unknown)),
+  timeouts: Schema8.optional(Schema8.Record(Schema8.String, Schema8.Number)),
+  harness: Schema8.optional(RuntimeHarness),
+  model: Schema8.optional(Schema8.String),
+  mode: Schema8.optional(RigRuntimeMode),
+  pi: Schema8.optional(PiRuntimeConfig),
+  server: Schema8.optional(RigServerConfig),
+  capabilities: Schema8.optional(CapabilityGrants),
+  supervisor: Schema8.optional(RuntimeSupervisorConfig),
+  drift: Schema8.optional(RuntimeDriftConfig),
+  planning: Schema8.optional(RuntimePlanningConfig)
+});
+var ProjectIdentity = Schema8.Struct({
+  name: Schema8.String,
+  repo: Schema8.optional(Schema8.String)
+});
+var PlanningConfig = Schema8.Struct({
+  mode: Schema8.optional(Schema8.Literals(["auto", "always", "off"])),
+  requireForLabels: Schema8.optional(Schema8.Array(Schema8.String)),
+  skipForLabels: Schema8.optional(Schema8.Array(Schema8.String))
+});
+var GitHubProjectStatusConfig = Schema8.Struct({
+  enabled: Schema8.optional(Schema8.Boolean),
+  projectId: Schema8.optional(Schema8.String),
+  statusFieldId: Schema8.optional(Schema8.String),
+  statuses: Schema8.optional(Schema8.Struct({
+    running: Schema8.optional(Schema8.String),
+    prOpen: Schema8.optional(Schema8.String),
+    ciFixing: Schema8.optional(Schema8.String),
+    merging: Schema8.optional(Schema8.String),
+    done: Schema8.optional(Schema8.String),
+    needsAttention: Schema8.optional(Schema8.String)
   }))
 });
-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({
+var GitHubConfig = Schema8.Struct({
+  issueUpdates: Schema8.optional(Schema8.Literals(["lifecycle", "minimal", "off"])),
+  projects: Schema8.optional(GitHubProjectStatusConfig)
+});
+var AutomationConfig = Schema8.Struct({
+  maxValidationAttempts: Schema8.optional(Schema8.Number),
+  maxPrFixIterations: Schema8.optional(Schema8.Number)
+});
+var PullRequestConfig = Schema8.Struct({
+  mode: Schema8.optional(Schema8.Literals(["auto", "ask", "off"])),
+  watchChecks: Schema8.optional(Schema8.Boolean),
+  autoFixChecks: Schema8.optional(Schema8.Boolean),
+  autoFixReview: Schema8.optional(Schema8.Boolean),
+  pendingTimeoutMs: Schema8.optional(Schema8.Number),
+  pendingPollMs: Schema8.optional(Schema8.Number)
+});
+var MergeConfig = Schema8.Struct({
+  mode: Schema8.optional(Schema8.Literals(["auto", "off", "pr-ready"])),
+  method: Schema8.optional(Schema8.Literals(["repo-default", "squash", "merge", "rebase"])),
+  deleteBranch: Schema8.optional(Schema8.Union([Schema8.Literal("repo-default"), Schema8.Boolean])),
+  allowedFailures: Schema8.optional(Schema8.Array(Schema8.String)),
+  bypass: Schema8.optional(Schema8.Boolean)
+});
+var IssueAnalysisConfig = Schema8.Struct({
+  enabled: Schema8.optional(Schema8.Boolean),
+  harness: Schema8.optional(Schema8.Literal("pi")),
+  model: Schema8.optional(Schema8.String),
+  mode: Schema8.optional(Schema8.Literals(["continuous", "off"]))
+});
+var ReviewConfig = Schema8.Struct({
+  mode: Schema8.optional(Schema8.Literals(["off", "advisory", "required"])),
+  provider: Schema8.optional(Schema8.Literals(["greptile", "github"]))
+});
+var RigConfig = Schema8.Struct({
   project: ProjectIdentity,
-  plugins: Schema9.Array(RigPlugin),
+  plugins: Schema8.Array(RigPlugin),
   taskSource: TaskSourceConfig,
   workspace: WorkspaceConfig,
-  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))
+  runtime: Schema8.optional(RuntimeConfig),
+  planning: Schema8.optional(PlanningConfig),
+  github: Schema8.optional(GitHubConfig),
+  automation: Schema8.optional(AutomationConfig),
+  pr: Schema8.optional(PullRequestConfig),
+  merge: Schema8.optional(MergeConfig),
+  review: Schema8.optional(ReviewConfig),
+  issueAnalysis: Schema8.optional(IssueAnalysisConfig),
+  capabilities: Schema8.optional(CapabilityGrants),
+  env: Schema8.optional(Schema8.Record(Schema8.String, Schema8.String))
 });
 export {
   WorkspaceSandbox,