@h-rig/contracts 0.0.6-alpha.90 → 0.0.6-alpha.92

package/dist/src/run-session-journal.js

@@ -0,0 +1,1582 @@
+// @bun
+// packages/contracts/src/run-journal.ts
+import { Schema as Schema5 } from "effect";
+
+// packages/contracts/src/baseSchemas.ts
+import { Schema } from "effect";
+var TrimmedString = Schema.Trim;
+var TrimmedNonEmptyString = TrimmedString.check(Schema.isNonEmpty());
+var NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+var PositiveInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1));
+var IsoDateTime = Schema.String;
+var makeEntityId = (brand) => TrimmedNonEmptyString.pipe(Schema.brand(brand));
+var ThreadId = makeEntityId("ThreadId");
+var ProjectId = makeEntityId("ProjectId");
+var WorkspaceId = makeEntityId("WorkspaceId");
+var GraphId = makeEntityId("GraphId");
+var TaskId = makeEntityId("TaskId");
+var RunId = makeEntityId("RunId");
+var SafePathSegment = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafePathSegment"));
+var SafeRunId = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(Schema.brand("SafeRunId"));
+var SafeGitRefComponent = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafeGitRefComponent"));
+var EngineRuntimeId = makeEntityId("EngineRuntimeId");
+var ConversationId = makeEntityId("ConversationId");
+var ActionId = makeEntityId("ActionId");
+var ArtifactId = makeEntityId("ArtifactId");
+var WorktreeId = makeEntityId("WorktreeId");
+var ValidationResultId = makeEntityId("ValidationResultId");
+var ReviewResultId = makeEntityId("ReviewResultId");
+var CommandId = makeEntityId("CommandId");
+var EventId = makeEntityId("EventId");
+var MessageId = makeEntityId("MessageId");
+var TurnId = makeEntityId("TurnId");
+var ProviderItemId = makeEntityId("ProviderItemId");
+var RuntimeSessionId = makeEntityId("RuntimeSessionId");
+var RuntimeItemId = makeEntityId("RuntimeItemId");
+var RuntimeRequestId = makeEntityId("RuntimeRequestId");
+var RuntimeTaskId = makeEntityId("RuntimeTaskId");
+var ApprovalRequestId = makeEntityId("ApprovalRequestId");
+var CheckpointRef = makeEntityId("CheckpointRef");
+var RemoteEndpointId = makeEntityId("RemoteEndpointId");
+
+// packages/contracts/src/runtime.ts
+import { Schema as Schema4 } from "effect";
+
+// packages/contracts/src/orchestration.ts
+import { Option, Schema as Schema3, SchemaIssue, Struct } from "effect";
+
+// packages/contracts/src/model.ts
+import { Schema as Schema2 } from "effect";
+var CODEX_REASONING_EFFORT_OPTIONS = ["xhigh", "high", "medium", "low"];
+var CodexModelOptions = Schema2.Struct({
+  reasoningEffort: Schema2.optional(Schema2.Literals(CODEX_REASONING_EFFORT_OPTIONS)),
+  fastMode: Schema2.optional(Schema2.Boolean)
+});
+var ClaudeModelOptions = Schema2.Struct({});
+var ProviderModelOptions = Schema2.Struct({
+  codex: Schema2.optional(CodexModelOptions),
+  claude: Schema2.optional(ClaudeModelOptions)
+});
+
+// packages/contracts/src/orchestration.ts
+var ProviderKind = Schema3.Literals(["codex", "claude"]);
+var ProviderApprovalPolicy = Schema3.Literals([
+  "untrusted",
+  "on-failure",
+  "on-request",
+  "never"
+]);
+var ProviderSandboxMode = Schema3.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var ProviderServiceTier = Schema3.Literals(["fast", "flex"]);
+var RuntimeMode = Schema3.Literals(["approval-required", "full-access"]);
+var DEFAULT_RUNTIME_MODE = "full-access";
+var ProviderInteractionMode = Schema3.Literals(["default", "plan"]);
+var DEFAULT_PROVIDER_INTERACTION_MODE = "default";
+var ProviderRequestKind = Schema3.Literals(["command", "file-read", "file-change"]);
+var AssistantDeliveryMode = Schema3.Literals(["buffered", "streaming"]);
+var ProviderApprovalDecision = Schema3.Literals([
+  "accept",
+  "acceptForSession",
+  "decline",
+  "cancel"
+]);
+var ProviderUserInputAnswers = Schema3.Record(Schema3.String, Schema3.Unknown);
+var PROVIDER_SEND_TURN_MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+var PROVIDER_SEND_TURN_MAX_IMAGE_DATA_URL_CHARS = 14000000;
+var CHAT_ATTACHMENT_ID_MAX_CHARS = 128;
+var ChatAttachmentId = TrimmedNonEmptyString.check(Schema3.isMaxLength(CHAT_ATTACHMENT_ID_MAX_CHARS), Schema3.isPattern(/^[a-z0-9_-]+$/i));
+var ChatImageAttachment = Schema3.Struct({
+  type: Schema3.Literal("image"),
+  id: ChatAttachmentId,
+  name: TrimmedNonEmptyString.check(Schema3.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema3.isMaxLength(100), Schema3.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema3.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES))
+});
+var UploadChatImageAttachment = Schema3.Struct({
+  type: Schema3.Literal("image"),
+  name: TrimmedNonEmptyString.check(Schema3.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema3.isMaxLength(100), Schema3.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema3.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES)),
+  dataUrl: TrimmedNonEmptyString.check(Schema3.isMaxLength(PROVIDER_SEND_TURN_MAX_IMAGE_DATA_URL_CHARS))
+});
+var ChatAttachment = Schema3.Union([ChatImageAttachment]);
+var UploadChatAttachment = Schema3.Union([UploadChatImageAttachment]);
+var ProjectScriptIcon = Schema3.Literals([
+  "play",
+  "test",
+  "lint",
+  "configure",
+  "build",
+  "debug"
+]);
+var ProjectScript = Schema3.Struct({
+  id: TrimmedNonEmptyString,
+  name: TrimmedNonEmptyString,
+  command: TrimmedNonEmptyString,
+  icon: ProjectScriptIcon,
+  runOnWorktreeCreate: Schema3.Boolean
+});
+var OrchestrationProject = Schema3.Struct({
+  id: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema3.NullOr(TrimmedNonEmptyString),
+  scripts: Schema3.Array(ProjectScript),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  deletedAt: Schema3.NullOr(IsoDateTime)
+});
+var OrchestrationMessageRole = Schema3.Literals(["user", "assistant", "system"]);
+var OrchestrationMessage = Schema3.Struct({
+  id: MessageId,
+  role: OrchestrationMessageRole,
+  text: Schema3.String,
+  attachments: Schema3.optional(Schema3.Array(ChatAttachment)),
+  turnId: Schema3.NullOr(TurnId),
+  streaming: Schema3.Boolean,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var OrchestrationProposedPlanId = TrimmedNonEmptyString;
+var OrchestrationProposedPlan = Schema3.Struct({
+  id: OrchestrationProposedPlanId,
+  turnId: Schema3.NullOr(TurnId),
+  planMarkdown: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var OrchestrationSessionStatus = Schema3.Literals([
+  "idle",
+  "starting",
+  "running",
+  "ready",
+  "interrupted",
+  "stopped",
+  "error"
+]);
+var OrchestrationSession = Schema3.Struct({
+  threadId: ThreadId,
+  status: OrchestrationSessionStatus,
+  providerName: Schema3.NullOr(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  activeTurnId: Schema3.NullOr(TurnId),
+  lastError: Schema3.NullOr(TrimmedNonEmptyString),
+  updatedAt: IsoDateTime
+});
+var OrchestrationCheckpointFile = Schema3.Struct({
+  path: TrimmedNonEmptyString,
+  kind: TrimmedNonEmptyString,
+  additions: NonNegativeInt,
+  deletions: NonNegativeInt
+});
+var OrchestrationCheckpointStatus = Schema3.Literals(["ready", "missing", "error"]);
+var OrchestrationCheckpointSummary = Schema3.Struct({
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema3.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema3.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var OrchestrationThreadActivityTone = Schema3.Literals([
+  "info",
+  "tool",
+  "approval",
+  "error"
+]);
+var OrchestrationThreadActivity = Schema3.Struct({
+  id: EventId,
+  tone: OrchestrationThreadActivityTone,
+  kind: TrimmedNonEmptyString,
+  summary: TrimmedNonEmptyString,
+  payload: Schema3.Unknown,
+  turnId: Schema3.NullOr(TurnId),
+  sequence: Schema3.optional(NonNegativeInt),
+  createdAt: IsoDateTime
+});
+var OrchestrationLatestTurnState = Schema3.Literals([
+  "running",
+  "interrupted",
+  "completed",
+  "error"
+]);
+var OrchestrationLatestTurn = Schema3.Struct({
+  turnId: TurnId,
+  state: OrchestrationLatestTurnState,
+  requestedAt: IsoDateTime,
+  startedAt: Schema3.NullOr(IsoDateTime),
+  completedAt: Schema3.NullOr(IsoDateTime),
+  assistantMessageId: Schema3.NullOr(MessageId)
+});
+var OrchestrationThread = Schema3.Struct({
+  id: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema3.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema3.NullOr(TrimmedNonEmptyString),
+  latestTurn: Schema3.NullOr(OrchestrationLatestTurn),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  deletedAt: Schema3.NullOr(IsoDateTime),
+  messages: Schema3.Array(OrchestrationMessage),
+  proposedPlans: Schema3.Array(OrchestrationProposedPlan).pipe(Schema3.withDecodingDefault(() => [])),
+  activities: Schema3.Array(OrchestrationThreadActivity),
+  checkpoints: Schema3.Array(OrchestrationCheckpointSummary),
+  session: Schema3.NullOr(OrchestrationSession)
+});
+var OrchestrationReadModel = Schema3.Struct({
+  snapshotSequence: NonNegativeInt,
+  projects: Schema3.Array(OrchestrationProject),
+  threads: Schema3.Array(OrchestrationThread),
+  updatedAt: IsoDateTime
+});
+var ProjectCreateCommand = Schema3.Struct({
+  type: Schema3.Literal("project.create"),
+  commandId: CommandId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema3.optional(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var ProjectMetaUpdateCommand = Schema3.Struct({
+  type: Schema3.Literal("project.meta.update"),
+  commandId: CommandId,
+  projectId: ProjectId,
+  title: Schema3.optional(TrimmedNonEmptyString),
+  workspaceRoot: Schema3.optional(TrimmedNonEmptyString),
+  defaultModel: Schema3.optional(TrimmedNonEmptyString),
+  scripts: Schema3.optional(Schema3.Array(ProjectScript))
+});
+var ProjectDeleteCommand = Schema3.Struct({
+  type: Schema3.Literal("project.delete"),
+  commandId: CommandId,
+  projectId: ProjectId
+});
+var ThreadCreateCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.create"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema3.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema3.NullOr(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var ThreadDeleteCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.delete"),
+  commandId: CommandId,
+  threadId: ThreadId
+});
+var ThreadMetaUpdateCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.meta.update"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  title: Schema3.optional(TrimmedNonEmptyString),
+  model: Schema3.optional(TrimmedNonEmptyString),
+  branch: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  worktreePath: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString))
+});
+var ThreadRuntimeModeSetCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.runtime-mode.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  runtimeMode: RuntimeMode,
+  createdAt: IsoDateTime
+});
+var ThreadInteractionModeSetCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.interaction-mode.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  interactionMode: ProviderInteractionMode,
+  createdAt: IsoDateTime
+});
+var ThreadTurnStartCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.turn.start"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  message: Schema3.Struct({
+    messageId: MessageId,
+    role: Schema3.Literal("user"),
+    text: Schema3.String,
+    attachments: Schema3.Array(ChatAttachment)
+  }),
+  provider: Schema3.optional(ProviderKind),
+  model: Schema3.optional(TrimmedNonEmptyString),
+  serviceTier: Schema3.optional(Schema3.NullOr(ProviderServiceTier)),
+  modelOptions: Schema3.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema3.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  createdAt: IsoDateTime
+});
+var ClientThreadTurnStartCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.turn.start"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  message: Schema3.Struct({
+    messageId: MessageId,
+    role: Schema3.Literal("user"),
+    text: Schema3.String,
+    attachments: Schema3.Array(UploadChatAttachment)
+  }),
+  provider: Schema3.optional(ProviderKind),
+  model: Schema3.optional(TrimmedNonEmptyString),
+  serviceTier: Schema3.optional(Schema3.NullOr(ProviderServiceTier)),
+  modelOptions: Schema3.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema3.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  createdAt: IsoDateTime
+});
+var ThreadTurnInterruptCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.turn.interrupt"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnId: Schema3.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadApprovalRespondCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.approval.respond"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision,
+  createdAt: IsoDateTime
+});
+var ThreadUserInputRespondCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.user-input.respond"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers,
+  createdAt: IsoDateTime
+});
+var ThreadCheckpointRevertCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.checkpoint.revert"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadSessionStopCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.session.stop"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  createdAt: IsoDateTime
+});
+var DispatchableClientOrchestrationCommand = Schema3.Union([
+  ProjectCreateCommand,
+  ProjectMetaUpdateCommand,
+  ProjectDeleteCommand,
+  ThreadCreateCommand,
+  ThreadDeleteCommand,
+  ThreadMetaUpdateCommand,
+  ThreadRuntimeModeSetCommand,
+  ThreadInteractionModeSetCommand,
+  ThreadTurnStartCommand,
+  ThreadTurnInterruptCommand,
+  ThreadApprovalRespondCommand,
+  ThreadUserInputRespondCommand,
+  ThreadCheckpointRevertCommand,
+  ThreadSessionStopCommand
+]);
+var ClientOrchestrationCommand = Schema3.Union([
+  ProjectCreateCommand,
+  ProjectMetaUpdateCommand,
+  ProjectDeleteCommand,
+  ThreadCreateCommand,
+  ThreadDeleteCommand,
+  ThreadMetaUpdateCommand,
+  ThreadRuntimeModeSetCommand,
+  ThreadInteractionModeSetCommand,
+  ClientThreadTurnStartCommand,
+  ThreadTurnInterruptCommand,
+  ThreadApprovalRespondCommand,
+  ThreadUserInputRespondCommand,
+  ThreadCheckpointRevertCommand,
+  ThreadSessionStopCommand
+]);
+var ThreadSessionSetCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.session.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  session: OrchestrationSession,
+  createdAt: IsoDateTime
+});
+var ThreadMessageAssistantDeltaCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.message.assistant.delta"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  messageId: MessageId,
+  delta: Schema3.String,
+  turnId: Schema3.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadMessageAssistantCompleteCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.message.assistant.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  messageId: MessageId,
+  turnId: Schema3.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadProposedPlanUpsertCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.proposed-plan.upsert"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  proposedPlan: OrchestrationProposedPlan,
+  createdAt: IsoDateTime
+});
+var ThreadTurnDiffCompleteCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.turn.diff.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnId: TurnId,
+  completedAt: IsoDateTime,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema3.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema3.optional(MessageId),
+  checkpointTurnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadActivityAppendCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.activity.append"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  activity: OrchestrationThreadActivity,
+  createdAt: IsoDateTime
+});
+var ThreadRevertCompleteCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.revert.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var InternalOrchestrationCommand = Schema3.Union([
+  ThreadSessionSetCommand,
+  ThreadMessageAssistantDeltaCommand,
+  ThreadMessageAssistantCompleteCommand,
+  ThreadProposedPlanUpsertCommand,
+  ThreadTurnDiffCompleteCommand,
+  ThreadActivityAppendCommand,
+  ThreadRevertCompleteCommand
+]);
+var OrchestrationCommand = Schema3.Union([
+  DispatchableClientOrchestrationCommand,
+  InternalOrchestrationCommand
+]);
+var OrchestrationEventType = Schema3.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 = Schema3.Literals(["project", "thread"]);
+var OrchestrationActorKind = Schema3.Literals(["client", "server", "provider"]);
+var ProjectCreatedPayload = Schema3.Struct({
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema3.NullOr(TrimmedNonEmptyString),
+  scripts: Schema3.Array(ProjectScript),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ProjectMetaUpdatedPayload = Schema3.Struct({
+  projectId: ProjectId,
+  title: Schema3.optional(TrimmedNonEmptyString),
+  workspaceRoot: Schema3.optional(TrimmedNonEmptyString),
+  defaultModel: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  scripts: Schema3.optional(Schema3.Array(ProjectScript)),
+  updatedAt: IsoDateTime
+});
+var ProjectDeletedPayload = Schema3.Struct({
+  projectId: ProjectId,
+  deletedAt: IsoDateTime
+});
+var ThreadCreatedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema3.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema3.NullOr(TrimmedNonEmptyString),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ThreadDeletedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  deletedAt: IsoDateTime
+});
+var ThreadMetaUpdatedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  title: Schema3.optional(TrimmedNonEmptyString),
+  model: Schema3.optional(TrimmedNonEmptyString),
+  branch: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  worktreePath: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  updatedAt: IsoDateTime
+});
+var ThreadRuntimeModeSetPayload = Schema3.Struct({
+  threadId: ThreadId,
+  runtimeMode: RuntimeMode,
+  updatedAt: IsoDateTime
+});
+var ThreadInteractionModeSetPayload = Schema3.Struct({
+  threadId: ThreadId,
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  updatedAt: IsoDateTime
+});
+var ThreadMessageSentPayload = Schema3.Struct({
+  threadId: ThreadId,
+  messageId: MessageId,
+  role: OrchestrationMessageRole,
+  text: Schema3.String,
+  attachments: Schema3.optional(Schema3.Array(ChatAttachment)),
+  turnId: Schema3.NullOr(TurnId),
+  streaming: Schema3.Boolean,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ThreadTurnStartRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  messageId: MessageId,
+  provider: Schema3.optional(ProviderKind),
+  model: Schema3.optional(TrimmedNonEmptyString),
+  serviceTier: Schema3.optional(Schema3.NullOr(ProviderServiceTier)),
+  modelOptions: Schema3.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema3.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  createdAt: IsoDateTime
+});
+var ThreadTurnInterruptRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  turnId: Schema3.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadApprovalResponseRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision,
+  createdAt: IsoDateTime
+});
+var ThreadUserInputResponseRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers,
+  createdAt: IsoDateTime
+});
+var ThreadCheckpointRevertRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadRevertedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  turnCount: NonNegativeInt
+});
+var ThreadSessionStopRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  createdAt: IsoDateTime
+});
+var ThreadSessionSetPayload = Schema3.Struct({
+  threadId: ThreadId,
+  session: OrchestrationSession
+});
+var ThreadProposedPlanUpsertedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  proposedPlan: OrchestrationProposedPlan
+});
+var ThreadTurnDiffCompletedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema3.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema3.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var ThreadActivityAppendedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  activity: OrchestrationThreadActivity
+});
+var OrchestrationEventMetadata = Schema3.Struct({
+  providerTurnId: Schema3.optional(TrimmedNonEmptyString),
+  providerItemId: Schema3.optional(ProviderItemId),
+  adapterKey: Schema3.optional(TrimmedNonEmptyString),
+  requestId: Schema3.optional(ApprovalRequestId),
+  ingestedAt: Schema3.optional(IsoDateTime)
+});
+var EventBaseFields = {
+  sequence: NonNegativeInt,
+  eventId: EventId,
+  aggregateKind: OrchestrationAggregateKind,
+  aggregateId: Schema3.Union([ProjectId, ThreadId]),
+  occurredAt: IsoDateTime,
+  commandId: Schema3.NullOr(CommandId),
+  causationEventId: Schema3.NullOr(EventId),
+  correlationId: Schema3.NullOr(CommandId),
+  metadata: OrchestrationEventMetadata
+};
+var PersistedEventBaseFields = {
+  sequence: NonNegativeInt,
+  eventId: EventId,
+  aggregateKind: OrchestrationAggregateKind,
+  streamId: Schema3.Union([ProjectId, ThreadId]),
+  streamVersion: NonNegativeInt,
+  occurredAt: IsoDateTime,
+  commandId: Schema3.NullOr(CommandId),
+  causationEventId: Schema3.NullOr(EventId),
+  correlationId: Schema3.NullOr(CommandId),
+  actorKind: OrchestrationActorKind,
+  metadata: OrchestrationEventMetadata
+};
+var OrchestrationEvent = Schema3.Union([
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("project.created"),
+    payload: ProjectCreatedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("project.meta-updated"),
+    payload: ProjectMetaUpdatedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("project.deleted"),
+    payload: ProjectDeletedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.created"),
+    payload: ThreadCreatedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.deleted"),
+    payload: ThreadDeletedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.meta-updated"),
+    payload: ThreadMetaUpdatedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.runtime-mode-set"),
+    payload: ThreadRuntimeModeSetPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.interaction-mode-set"),
+    payload: ThreadInteractionModeSetPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.message-sent"),
+    payload: ThreadMessageSentPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.turn-start-requested"),
+    payload: ThreadTurnStartRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.turn-interrupt-requested"),
+    payload: ThreadTurnInterruptRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.approval-response-requested"),
+    payload: ThreadApprovalResponseRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.user-input-response-requested"),
+    payload: ThreadUserInputResponseRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.checkpoint-revert-requested"),
+    payload: ThreadCheckpointRevertRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.reverted"),
+    payload: ThreadRevertedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.session-stop-requested"),
+    payload: ThreadSessionStopRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.session-set"),
+    payload: ThreadSessionSetPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.proposed-plan-upserted"),
+    payload: ThreadProposedPlanUpsertedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.turn-diff-completed"),
+    payload: ThreadTurnDiffCompletedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.activity-appended"),
+    payload: ThreadActivityAppendedPayload
+  })
+]);
+var OrchestrationPersistedEvent = Schema3.Union([
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("project.created"),
+    payload: ProjectCreatedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("project.meta-updated"),
+    payload: ProjectMetaUpdatedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("project.deleted"),
+    payload: ProjectDeletedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.created"),
+    payload: ThreadCreatedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.deleted"),
+    payload: ThreadDeletedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.meta-updated"),
+    payload: ThreadMetaUpdatedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.runtime-mode-set"),
+    payload: ThreadRuntimeModeSetPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.interaction-mode-set"),
+    payload: ThreadInteractionModeSetPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.message-sent"),
+    payload: ThreadMessageSentPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.turn-start-requested"),
+    payload: ThreadTurnStartRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.turn-interrupt-requested"),
+    payload: ThreadTurnInterruptRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.approval-response-requested"),
+    payload: ThreadApprovalResponseRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.user-input-response-requested"),
+    payload: ThreadUserInputResponseRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.checkpoint-revert-requested"),
+    payload: ThreadCheckpointRevertRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.reverted"),
+    payload: ThreadRevertedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.session-stop-requested"),
+    payload: ThreadSessionStopRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.session-set"),
+    payload: ThreadSessionSetPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.proposed-plan-upserted"),
+    payload: ThreadProposedPlanUpsertedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.turn-diff-completed"),
+    payload: ThreadTurnDiffCompletedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.activity-appended"),
+    payload: ThreadActivityAppendedPayload
+  })
+]);
+var OrchestrationCommandReceiptStatus = Schema3.Literals(["accepted", "rejected"]);
+var TurnCountRange = Schema3.Struct({
+  fromTurnCount: NonNegativeInt,
+  toTurnCount: NonNegativeInt
+}).check(Schema3.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: Schema3.String
+}), { unsafePreserveChecks: true });
+var ProviderSessionRuntimeStatus = Schema3.Literals([
+  "starting",
+  "running",
+  "stopped",
+  "error"
+]);
+var ProjectionThreadTurnStatus = Schema3.Literals([
+  "running",
+  "completed",
+  "interrupted",
+  "error"
+]);
+var ProjectionCheckpointRow = Schema3.Struct({
+  threadId: ThreadId,
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema3.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema3.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var ProjectionPendingApprovalStatus = Schema3.Literals(["pending", "resolved"]);
+var ProjectionPendingApprovalDecision = Schema3.NullOr(ProviderApprovalDecision);
+var DispatchResult = Schema3.Struct({
+  sequence: NonNegativeInt
+});
+var OrchestrationGetSnapshotInput = Schema3.Struct({});
+var OrchestrationGetTurnDiffInput = TurnCountRange.mapFields(Struct.assign({ threadId: ThreadId }), { unsafePreserveChecks: true });
+var OrchestrationGetFullThreadDiffInput = Schema3.Struct({
+  threadId: ThreadId,
+  toTurnCount: NonNegativeInt
+});
+var OrchestrationReplayEventsInput = Schema3.Struct({
+  fromSequenceExclusive: NonNegativeInt
+});
+var OrchestrationReplayEventsResult = Schema3.Array(OrchestrationEvent);
+
+// packages/contracts/src/runtime.ts
+var RunKind = Schema4.Literals(["adhoc", "task", "batch", "validation", "review"]);
+var RunMode = Schema4.Literals(["interactive", "autonomous", "supervised"]);
+var RunStatus = Schema4.Literals([
+  "created",
+  "queued",
+  "preparing",
+  "running",
+  "waiting-approval",
+  "waiting-user-input",
+  "paused",
+  "validating",
+  "reviewing",
+  "closing-out",
+  "needs-attention",
+  "completed",
+  "failed",
+  "stopped"
+]);
+var EngineSandboxMode = Schema4.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var IsolationMode = Schema4.Literals(["none", "env", "worktree"]);
+var RuntimeStatus = Schema4.Literals([
+  "prepared",
+  "starting",
+  "running",
+  "interrupted",
+  "exited",
+  "failed",
+  "destroyed"
+]);
+var RunExecutionTarget = Schema4.Literals(["local", "remote"]);
+var RunSummary = Schema4.Struct({
+  id: RunId,
+  workspaceId: WorkspaceId,
+  taskId: Schema4.NullOr(TaskId),
+  title: TrimmedNonEmptyString,
+  runKind: RunKind,
+  mode: RunMode,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  status: RunStatus,
+  runtimeAdapter: TrimmedNonEmptyString,
+  model: Schema4.NullOr(TrimmedNonEmptyString),
+  initialPrompt: Schema4.NullOr(Schema4.String),
+  executionTarget: Schema4.optional(RunExecutionTarget),
+  remoteHostId: Schema4.optional(Schema4.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseId: Schema4.optional(Schema4.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseClaimedAt: Schema4.optional(Schema4.NullOr(IsoDateTime)),
+  activeRuntimeId: Schema4.NullOr(EngineRuntimeId),
+  latestMessageId: Schema4.NullOr(TrimmedNonEmptyString),
+  pendingApprovalCount: NonNegativeInt,
+  pendingUserInputCount: NonNegativeInt,
+  branch: Schema4.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema4.NullOr(TrimmedNonEmptyString),
+  errorText: Schema4.NullOr(Schema4.String),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  startedAt: Schema4.NullOr(IsoDateTime),
+  completedAt: Schema4.NullOr(IsoDateTime)
+});
+var RuntimeSummary = Schema4.Struct({
+  id: EngineRuntimeId,
+  workspaceId: WorkspaceId,
+  runId: RunId,
+  adapterKind: TrimmedNonEmptyString,
+  executionTarget: Schema4.optional(RunExecutionTarget),
+  remoteHostId: Schema4.optional(Schema4.NullOr(TrimmedNonEmptyString)),
+  status: RuntimeStatus,
+  sandboxMode: EngineSandboxMode,
+  isolationMode: IsolationMode,
+  workspaceDir: Schema4.NullOr(TrimmedNonEmptyString),
+  homeDir: Schema4.NullOr(TrimmedNonEmptyString),
+  tmpDir: Schema4.NullOr(TrimmedNonEmptyString),
+  cacheDir: Schema4.NullOr(TrimmedNonEmptyString),
+  logsDir: Schema4.NullOr(TrimmedNonEmptyString),
+  stateDir: Schema4.NullOr(TrimmedNonEmptyString),
+  sessionDir: Schema4.NullOr(TrimmedNonEmptyString),
+  sessionLogPath: Schema4.NullOr(TrimmedNonEmptyString),
+  pid: Schema4.NullOr(NonNegativeInt),
+  startedAt: Schema4.NullOr(IsoDateTime),
+  updatedAt: IsoDateTime,
+  exitedAt: Schema4.NullOr(IsoDateTime)
+});
+var ApprovalStatus = Schema4.Literals(["pending", "resolved"]);
+var ApprovalSummary = Schema4.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  actionId: Schema4.NullOr(TrimmedNonEmptyString),
+  requestKind: TrimmedNonEmptyString,
+  status: ApprovalStatus,
+  payload: Schema4.Unknown,
+  createdAt: IsoDateTime,
+  resolvedAt: Schema4.NullOr(IsoDateTime)
+});
+var UserInputRequestSummary = Schema4.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  status: ApprovalStatus,
+  payload: Schema4.Unknown,
+  createdAt: IsoDateTime,
+  resolvedAt: Schema4.NullOr(IsoDateTime)
+});
+var WorktreeSummary = Schema4.Struct({
+  id: WorktreeId,
+  workspaceId: WorkspaceId,
+  runId: RunId,
+  taskId: Schema4.NullOr(TaskId),
+  branchName: TrimmedNonEmptyString,
+  path: TrimmedNonEmptyString,
+  status: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  cleanedAt: Schema4.NullOr(IsoDateTime)
+});
+
+// packages/contracts/src/run-journal.ts
+var RunActor = Schema5.Struct({
+  kind: Schema5.Literals(["operator", "agent", "server", "system"]),
+  id: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString))
+});
+var RunCloseoutPhase = Schema5.Literals([
+  "queued",
+  "commit",
+  "push",
+  "pr-review-merge",
+  "pr-opened",
+  "merge",
+  "close-source",
+  "completed"
+]);
+var RunCloseoutPhaseOutcome = Schema5.Literals(["started", "completed", "failed"]);
+var RunCloseoutStatus = Schema5.Literals([
+  "pending",
+  "running",
+  "completed",
+  "needs-attention",
+  "failed"
+]);
+var RunCloseoutState = Schema5.Struct({
+  phase: RunCloseoutPhase,
+  status: RunCloseoutStatus,
+  updatedAt: IsoDateTime,
+  taskId: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  runtimeWorkspace: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  branch: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  prUrl: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  artifactRoot: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  iterations: Schema5.optional(Schema5.NullOr(Schema5.Int)),
+  feedback: Schema5.optional(Schema5.Array(Schema5.String)),
+  error: Schema5.optional(Schema5.NullOr(Schema5.String)),
+  reason: Schema5.optional(Schema5.NullOr(Schema5.String)),
+  merged: Schema5.optional(Schema5.Boolean),
+  resumedAt: Schema5.optional(Schema5.NullOr(IsoDateTime)),
+  completedAt: Schema5.optional(Schema5.NullOr(IsoDateTime))
+});
+var ApprovalDecision = Schema5.Literals(["approve", "reject"]);
+var runRecordFields = {
+  runId: TrimmedNonEmptyString,
+  workspaceId: TrimmedNonEmptyString,
+  taskId: Schema5.NullOr(TrimmedNonEmptyString),
+  threadId: Schema5.NullOr(TrimmedNonEmptyString),
+  mode: Schema5.Literals(["local", "remote"]),
+  runtimeAdapter: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  startedAt: Schema5.NullOr(IsoDateTime),
+  completedAt: Schema5.NullOr(IsoDateTime),
+  endpointId: Schema5.NullOr(TrimmedNonEmptyString),
+  hostId: Schema5.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema5.NullOr(TrimmedNonEmptyString),
+  artifactRoot: Schema5.NullOr(TrimmedNonEmptyString),
+  logRoot: Schema5.NullOr(TrimmedNonEmptyString),
+  sessionPath: Schema5.NullOr(TrimmedNonEmptyString),
+  sessionLogPath: Schema5.NullOr(TrimmedNonEmptyString),
+  pid: Schema5.optional(Schema5.NullOr(Schema5.Int)),
+  piSession: Schema5.optional(Schema5.Unknown),
+  piSessionPrivate: Schema5.optional(Schema5.Unknown),
+  updatedAt: IsoDateTime,
+  title: TrimmedNonEmptyString,
+  projectRoot: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  errorText: Schema5.optional(Schema5.NullOr(Schema5.String)),
+  latestMessageId: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  prUrl: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  leaseId: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  serverCloseout: Schema5.optional(Schema5.NullOr(RunCloseoutState)),
+  model: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  runtimeMode: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  interactionMode: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  runMode: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  initialPrompt: Schema5.optional(Schema5.NullOr(Schema5.String)),
+  baselineMode: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  prMode: Schema5.optional(Schema5.NullOr(Schema5.Literals(["auto", "ask", "off"]))),
+  initiatedBy: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  sourceTask: Schema5.optional(Schema5.Unknown),
+  serverPid: Schema5.optional(Schema5.NullOr(Schema5.Int)),
+  latestSteeringAt: Schema5.optional(Schema5.NullOr(IsoDateTime)),
+  latestSteeringDeliveredAt: Schema5.optional(Schema5.NullOr(IsoDateTime)),
+  statusDetail: Schema5.optional(Schema5.NullOr(Schema5.String)),
+  planning: Schema5.optional(Schema5.Unknown),
+  branch: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString))
+};
+var RunJournalRecord = Schema5.Struct({
+  ...runRecordFields,
+  status: RunStatus
+});
+var RunRecordPatch = Schema5.Struct({
+  runId: Schema5.optional(runRecordFields.runId),
+  workspaceId: Schema5.optional(runRecordFields.workspaceId),
+  taskId: Schema5.optional(runRecordFields.taskId),
+  threadId: Schema5.optional(runRecordFields.threadId),
+  mode: Schema5.optional(runRecordFields.mode),
+  runtimeAdapter: Schema5.optional(runRecordFields.runtimeAdapter),
+  createdAt: Schema5.optional(runRecordFields.createdAt),
+  startedAt: Schema5.optional(runRecordFields.startedAt),
+  completedAt: Schema5.optional(runRecordFields.completedAt),
+  endpointId: Schema5.optional(runRecordFields.endpointId),
+  hostId: Schema5.optional(runRecordFields.hostId),
+  worktreePath: Schema5.optional(runRecordFields.worktreePath),
+  artifactRoot: Schema5.optional(runRecordFields.artifactRoot),
+  logRoot: Schema5.optional(runRecordFields.logRoot),
+  sessionPath: Schema5.optional(runRecordFields.sessionPath),
+  sessionLogPath: Schema5.optional(runRecordFields.sessionLogPath),
+  pid: runRecordFields.pid,
+  piSession: runRecordFields.piSession,
+  piSessionPrivate: runRecordFields.piSessionPrivate,
+  updatedAt: Schema5.optional(runRecordFields.updatedAt),
+  title: Schema5.optional(runRecordFields.title),
+  projectRoot: runRecordFields.projectRoot,
+  errorText: runRecordFields.errorText,
+  latestMessageId: runRecordFields.latestMessageId,
+  prUrl: runRecordFields.prUrl,
+  leaseId: runRecordFields.leaseId,
+  serverCloseout: runRecordFields.serverCloseout,
+  model: runRecordFields.model,
+  runtimeMode: runRecordFields.runtimeMode,
+  interactionMode: runRecordFields.interactionMode,
+  runMode: runRecordFields.runMode,
+  initialPrompt: runRecordFields.initialPrompt,
+  baselineMode: runRecordFields.baselineMode,
+  prMode: runRecordFields.prMode,
+  initiatedBy: runRecordFields.initiatedBy,
+  sourceTask: runRecordFields.sourceTask,
+  serverPid: runRecordFields.serverPid,
+  latestSteeringAt: runRecordFields.latestSteeringAt,
+  latestSteeringDeliveredAt: runRecordFields.latestSteeringDeliveredAt,
+  statusDetail: runRecordFields.statusDetail,
+  planning: runRecordFields.planning,
+  branch: runRecordFields.branch
+});
+var journalEnvelopeFields = {
+  v: Schema5.Literal(1),
+  seq: PositiveInt,
+  at: IsoDateTime,
+  runId: RunId
+};
+var RunStatusChangedEvent = Schema5.Struct({
+  ...journalEnvelopeFields,
+  type: Schema5.Literal("status-changed"),
+  from: Schema5.NullOr(RunStatus),
+  to: RunStatus,
+  reason: Schema5.optional(Schema5.NullOr(Schema5.String)),
+  actor: Schema5.optional(RunActor)
+});
+var RunRecordPatchEvent = Schema5.Struct({
+  ...journalEnvelopeFields,
+  type: Schema5.Literal("record-patch"),
+  patch: RunRecordPatch
+});
+var RunTimelineEntryEvent = Schema5.Struct({
+  ...journalEnvelopeFields,
+  type: Schema5.Literal("timeline-entry"),
+  payload: Schema5.Unknown
+});
+var RunLogEntryEvent = Schema5.Struct({
+  ...journalEnvelopeFields,
+  type: Schema5.Literal("log-entry"),
+  payload: Schema5.Unknown
+});
+var RunApprovalRequestedEvent = Schema5.Struct({
+  ...journalEnvelopeFields,
+  type: Schema5.Literal("approval-requested"),
+  requestId: TrimmedNonEmptyString,
+  requestKind: TrimmedNonEmptyString,
+  actionId: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  payload: Schema5.Unknown
+});
+var RunApprovalResolvedEvent = Schema5.Struct({
+  ...journalEnvelopeFields,
+  type: Schema5.Literal("approval-resolved"),
+  requestId: TrimmedNonEmptyString,
+  decision: ApprovalDecision,
+  note: Schema5.optional(Schema5.NullOr(Schema5.String)),
+  actor: RunActor
+});
+var RunInputRequestedEvent = Schema5.Struct({
+  ...journalEnvelopeFields,
+  type: Schema5.Literal("input-requested"),
+  requestId: TrimmedNonEmptyString,
+  payload: Schema5.Unknown
+});
+var RunInputResolvedEvent = Schema5.Struct({
+  ...journalEnvelopeFields,
+  type: Schema5.Literal("input-resolved"),
+  requestId: TrimmedNonEmptyString,
+  answers: Schema5.Record(Schema5.String, Schema5.String),
+  actor: RunActor
+});
+var RunSteeringEvent = Schema5.Struct({
+  ...journalEnvelopeFields,
+  type: Schema5.Literal("steering"),
+  actor: RunActor,
+  text: Schema5.String
+});
+var RunAdoptedEvent = Schema5.Struct({
+  ...journalEnvelopeFields,
+  type: Schema5.Literal("adopted"),
+  pid: Schema5.NullOr(Schema5.Int),
+  serverPid: Schema5.Int
+});
+var RunStallDetectedEvent = Schema5.Struct({
+  ...journalEnvelopeFields,
+  type: Schema5.Literal("stall-detected"),
+  detail: Schema5.String
+});
+var RunCloseoutPhaseEvent = Schema5.Struct({
+  ...journalEnvelopeFields,
+  type: Schema5.Literal("closeout-phase"),
+  phase: RunCloseoutPhase,
+  outcome: RunCloseoutPhaseOutcome,
+  detail: Schema5.optional(Schema5.NullOr(Schema5.String))
+});
+var RunJournalEvent = Schema5.Union([
+  RunStatusChangedEvent,
+  RunRecordPatchEvent,
+  RunTimelineEntryEvent,
+  RunLogEntryEvent,
+  RunApprovalRequestedEvent,
+  RunApprovalResolvedEvent,
+  RunInputRequestedEvent,
+  RunInputResolvedEvent,
+  RunSteeringEvent,
+  RunAdoptedEvent,
+  RunStallDetectedEvent,
+  RunCloseoutPhaseEvent
+]);
+var decodeRunJournalEvent = Schema5.decodeUnknownSync(RunJournalEvent);
+var RUN_STATUS_TRANSITIONS = {
+  created: ["queued", "preparing", "running", "failed", "stopped"],
+  queued: ["preparing", "running", "failed", "stopped"],
+  preparing: ["queued", "running", "needs-attention", "failed", "stopped"],
+  running: [
+    "queued",
+    "waiting-approval",
+    "waiting-user-input",
+    "paused",
+    "validating",
+    "reviewing",
+    "closing-out",
+    "needs-attention",
+    "completed",
+    "failed",
+    "stopped"
+  ],
+  "waiting-approval": ["running", "needs-attention", "failed", "stopped"],
+  "waiting-user-input": ["running", "needs-attention", "failed", "stopped"],
+  paused: ["running", "failed", "stopped"],
+  validating: ["running", "reviewing", "closing-out", "needs-attention", "completed", "failed", "stopped"],
+  reviewing: ["running", "validating", "closing-out", "needs-attention", "completed", "failed", "stopped"],
+  "closing-out": ["running", "needs-attention", "completed", "failed", "stopped"],
+  "needs-attention": ["queued", "preparing", "running", "closing-out", "completed", "failed", "stopped"],
+  completed: [],
+  failed: ["queued", "preparing", "running", "closing-out"],
+  stopped: ["queued", "preparing", "running", "closing-out"]
+};
+var TERMINAL_RUN_STATUSES = ["completed", "failed", "stopped"];
+var ACTIVE_RUN_STATUSES = Object.keys(RUN_STATUS_TRANSITIONS).filter((status) => !TERMINAL_RUN_STATUSES.includes(status));
+function isTerminalRunStatus(status) {
+  return TERMINAL_RUN_STATUSES.includes(status);
+}
+function canTransitionRunStatus(from, to) {
+  if (from === null)
+    return true;
+  if (from === to)
+    return true;
+  return RUN_STATUS_TRANSITIONS[from].includes(to);
+}
+function reduceRunJournal(events) {
+  let record = {};
+  let status = null;
+  const statusHistory = [];
+  const pendingApprovals = new Map;
+  const resolvedApprovals = [];
+  const pendingUserInputs = new Map;
+  const resolvedUserInputs = [];
+  const closeoutPhases = [];
+  const anomalies = [];
+  let steeringCount = 0;
+  let stallCount = 0;
+  let lastSeq = 0;
+  let lastEventAt = null;
+  for (const event of events) {
+    lastSeq = event.seq;
+    lastEventAt = event.at;
+    switch (event.type) {
+      case "status-changed": {
+        if (!canTransitionRunStatus(status, event.to)) {
+          anomalies.push({
+            seq: event.seq,
+            kind: "illegal-transition",
+            detail: `${status ?? "(none)"} -> ${event.to}`
+          });
+        }
+        statusHistory.push({
+          seq: event.seq,
+          at: event.at,
+          from: status,
+          to: event.to,
+          reason: event.reason ?? null
+        });
+        const wasTerminal = status !== null && isTerminalRunStatus(status);
+        status = event.to;
+        record = { ...record, updatedAt: event.at };
+        if (isTerminalRunStatus(event.to) && !record.completedAt) {
+          record = { ...record, completedAt: event.at };
+        }
+        if (!isTerminalRunStatus(event.to) && wasTerminal) {
+          record = { ...record, completedAt: null };
+        }
+        if (event.to === "running" && !record.startedAt) {
+          record = { ...record, startedAt: event.at };
+        }
+        break;
+      }
+      case "record-patch": {
+        const next = { ...record };
+        for (const [key, value] of Object.entries(event.patch)) {
+          if (value !== undefined) {
+            next[key] = value;
+          }
+        }
+        next.updatedAt = event.patch.updatedAt ?? event.at;
+        record = next;
+        break;
+      }
+      case "approval-requested": {
+        pendingApprovals.set(event.requestId, {
+          requestId: event.requestId,
+          requestKind: event.requestKind,
+          actionId: event.actionId ?? null,
+          payload: event.payload,
+          requestedAt: event.at
+        });
+        break;
+      }
+      case "approval-resolved": {
+        const pending = pendingApprovals.get(event.requestId);
+        if (!pending) {
+          const alreadyResolved = resolvedApprovals.some((entry) => entry.requestId === event.requestId);
+          anomalies.push({
+            seq: event.seq,
+            kind: alreadyResolved ? "duplicate-resolution" : "unknown-request",
+            detail: `approval ${event.requestId}`
+          });
+          break;
+        }
+        pendingApprovals.delete(event.requestId);
+        resolvedApprovals.push({
+          ...pending,
+          decision: event.decision,
+          note: event.note ?? null,
+          actor: event.actor,
+          resolvedAt: event.at
+        });
+        break;
+      }
+      case "input-requested": {
+        pendingUserInputs.set(event.requestId, {
+          requestId: event.requestId,
+          requestKind: "user-input",
+          actionId: null,
+          payload: event.payload,
+          requestedAt: event.at
+        });
+        break;
+      }
+      case "input-resolved": {
+        const pending = pendingUserInputs.get(event.requestId);
+        if (!pending) {
+          const alreadyResolved = resolvedUserInputs.some((entry) => entry.requestId === event.requestId);
+          anomalies.push({
+            seq: event.seq,
+            kind: alreadyResolved ? "duplicate-resolution" : "unknown-request",
+            detail: `user-input ${event.requestId}`
+          });
+          break;
+        }
+        pendingUserInputs.delete(event.requestId);
+        resolvedUserInputs.push({
+          ...pending,
+          answers: event.answers,
+          actor: event.actor,
+          resolvedAt: event.at
+        });
+        break;
+      }
+      case "steering": {
+        steeringCount += 1;
+        break;
+      }
+      case "adopted": {
+        record = { ...record, pid: event.pid, updatedAt: event.at };
+        break;
+      }
+      case "stall-detected": {
+        stallCount += 1;
+        break;
+      }
+      case "closeout-phase": {
+        closeoutPhases.push({
+          seq: event.seq,
+          at: event.at,
+          phase: event.phase,
+          outcome: event.outcome,
+          detail: event.detail ?? null
+        });
+        break;
+      }
+      case "timeline-entry":
+      case "log-entry":
+        break;
+    }
+  }
+  return {
+    record,
+    status,
+    statusHistory,
+    pendingApprovals: [...pendingApprovals.values()],
+    resolvedApprovals,
+    pendingUserInputs: [...pendingUserInputs.values()],
+    resolvedUserInputs,
+    steeringCount,
+    stallCount,
+    closeoutPhases,
+    lastSeq,
+    lastEventAt,
+    anomalies
+  };
+}
+
+// packages/contracts/src/run-session-journal.ts
+var RIG_RUN_STATUS_CHANGED = "rig.run.status-changed";
+var RIG_RUN_RECORD_PATCH = "rig.run.record-patch";
+var RIG_RUN_TIMELINE_ENTRY = "rig.run.timeline-entry";
+var RIG_RUN_LOG_ENTRY = "rig.run.log-entry";
+var RIG_RUN_APPROVAL_REQUESTED = "rig.run.approval-requested";
+var RIG_RUN_APPROVAL_RESOLVED = "rig.run.approval-resolved";
+var RIG_RUN_INPUT_REQUESTED = "rig.run.input-requested";
+var RIG_RUN_INPUT_RESOLVED = "rig.run.input-resolved";
+var RIG_RUN_STEERING = "rig.run.steering";
+var RIG_RUN_ADOPTED = "rig.run.adopted";
+var RIG_RUN_STALL_DETECTED = "rig.run.stall-detected";
+var RIG_RUN_CLOSEOUT_PHASE = "rig.run.closeout-phase";
+var RIG_STOP_SENTINEL = "<<RIG_STOP";
+var RIG_STOP_SENTINEL_END = ">>";
+function buildStopSentinel(runId, reason, requestedBy = "rig") {
+  const cleanReason = reason?.replace(/[>\n\r]/g, " ").trim();
+  return `${RIG_STOP_SENTINEL} runId=${runId} requestedBy=${requestedBy}${cleanReason ? ` reason=${cleanReason}` : ""}${RIG_STOP_SENTINEL_END}`;
+}
+function parseStopSentinel(text, expectedRunId) {
+  const start = text.indexOf(RIG_STOP_SENTINEL);
+  if (start < 0)
+    return null;
+  const end = text.indexOf(RIG_STOP_SENTINEL_END, start);
+  const body = text.slice(start + RIG_STOP_SENTINEL.length, end >= 0 ? end : undefined).trim();
+  const runId = body.match(/(?:^|\s)runId=([^\s>]+)/)?.[1] ?? "";
+  if (runId && runId !== expectedRunId)
+    return null;
+  const reason = body.match(/(?:^|\s)reason=(.+)$/)?.[1]?.trim() ?? null;
+  return { reason };
+}
+function sessionIdFromSessionFile(sessionPath) {
+  if (!sessionPath)
+    return null;
+  const file = sessionPath.split(/[\\/]/).pop() ?? "";
+  const match = file.match(/_([0-9a-fA-F][0-9a-fA-F-]{7,})\.jsonl$/);
+  return match?.[1] ?? null;
+}
+var CUSTOM_TYPE_FOR = {
+  "status-changed": RIG_RUN_STATUS_CHANGED,
+  "record-patch": RIG_RUN_RECORD_PATCH,
+  "timeline-entry": RIG_RUN_TIMELINE_ENTRY,
+  "log-entry": RIG_RUN_LOG_ENTRY,
+  "approval-requested": RIG_RUN_APPROVAL_REQUESTED,
+  "approval-resolved": RIG_RUN_APPROVAL_RESOLVED,
+  "input-requested": RIG_RUN_INPUT_REQUESTED,
+  "input-resolved": RIG_RUN_INPUT_RESOLVED,
+  steering: RIG_RUN_STEERING,
+  adopted: RIG_RUN_ADOPTED,
+  "stall-detected": RIG_RUN_STALL_DETECTED,
+  "closeout-phase": RIG_RUN_CLOSEOUT_PHASE
+};
+var TYPE_FOR_CUSTOM = {
+  [RIG_RUN_STATUS_CHANGED]: "status-changed",
+  [RIG_RUN_RECORD_PATCH]: "record-patch",
+  [RIG_RUN_TIMELINE_ENTRY]: "timeline-entry",
+  [RIG_RUN_LOG_ENTRY]: "log-entry",
+  [RIG_RUN_APPROVAL_REQUESTED]: "approval-requested",
+  [RIG_RUN_APPROVAL_RESOLVED]: "approval-resolved",
+  [RIG_RUN_INPUT_REQUESTED]: "input-requested",
+  [RIG_RUN_INPUT_RESOLVED]: "input-resolved",
+  [RIG_RUN_STEERING]: "steering",
+  [RIG_RUN_ADOPTED]: "adopted",
+  [RIG_RUN_STALL_DETECTED]: "stall-detected",
+  [RIG_RUN_CLOSEOUT_PHASE]: "closeout-phase"
+};
+function isRunSessionCustomType(customType) {
+  return customType !== undefined && Object.hasOwn(TYPE_FOR_CUSTOM, customType);
+}
+function foldRunSessionEntries(entries, runId) {
+  const events = [];
+  entries.forEach((entry, index) => {
+    if (entry.type !== "custom" || !isRunSessionCustomType(entry.customType))
+      return;
+    const data = entry.data !== null && typeof entry.data === "object" ? entry.data : {};
+    const stamped = {
+      v: 1,
+      seq: index + 1,
+      at: typeof data.at === "string" ? data.at : new Date(0).toISOString(),
+      runId,
+      ...data,
+      type: TYPE_FOR_CUSTOM[entry.customType]
+    };
+    try {
+      events.push(decodeRunJournalEvent(stamped));
+    } catch {}
+  });
+  return reduceRunJournal(events);
+}
+export {
+  sessionIdFromSessionFile,
+  parseStopSentinel,
+  isRunSessionCustomType,
+  foldRunSessionEntries,
+  buildStopSentinel,
+  TYPE_FOR_CUSTOM,
+  RIG_STOP_SENTINEL_END,
+  RIG_STOP_SENTINEL,
+  RIG_RUN_TIMELINE_ENTRY,
+  RIG_RUN_STEERING,
+  RIG_RUN_STATUS_CHANGED,
+  RIG_RUN_STALL_DETECTED,
+  RIG_RUN_RECORD_PATCH,
+  RIG_RUN_LOG_ENTRY,
+  RIG_RUN_INPUT_RESOLVED,
+  RIG_RUN_INPUT_REQUESTED,
+  RIG_RUN_CLOSEOUT_PHASE,
+  RIG_RUN_APPROVAL_RESOLVED,
+  RIG_RUN_APPROVAL_REQUESTED,
+  RIG_RUN_ADOPTED,
+  CUSTOM_TYPE_FOR
+};