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

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

@@ -1,1603 +1,4 @@
 // @bun
-// packages/contracts/src/run-journal.ts
-import { Schema as Schema6 } 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: Schema4.Literal("pi"),
-  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: Schema4.Literal("pi"),
-  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/stage.ts
-import { Schema as Schema5 } from "effect";
-var StageKind = Schema5.Literals(["transform", "gate", "observe"]);
-var StageId = TrimmedNonEmptyString.pipe(Schema5.brand("StageId"));
-var StageContext = Schema5.Struct({
-  runId: RunId,
-  taskId: Schema5.optional(Schema5.NullOr(TaskId)),
-  state: Schema5.Unknown,
-  metadata: Schema5.optional(Schema5.Record(Schema5.String, Schema5.Unknown))
-});
-var StageDescriptor = Schema5.Struct({
-  id: StageId,
-  kind: StageKind,
-  before: Schema5.optional(Schema5.Array(StageId)),
-  after: Schema5.optional(Schema5.Array(StageId)),
-  priority: Schema5.Number.pipe(Schema5.withDecodingDefault(() => 0)),
-  protected: Schema5.Boolean.pipe(Schema5.withDecodingDefault(() => false))
-});
-var StageContinueResult = Schema5.Struct({
-  kind: Schema5.Literal("continue"),
-  ctx: StageContext
-});
-var StageAllowResult = Schema5.Struct({
-  kind: Schema5.Literal("allow")
-});
-var StageBlockResult = Schema5.Struct({
-  kind: Schema5.Literal("block"),
-  reason: TrimmedNonEmptyString
-});
-var StageResult = Schema5.Union([
-  StageContinueResult,
-  StageAllowResult,
-  StageBlockResult
-]);
-var StageWrapperDescriptor = Schema5.Struct({
-  id: TrimmedNonEmptyString,
-  priority: Schema5.Number.pipe(Schema5.withDecodingDefault(() => 0))
-});
-var StageMutationOp = Schema5.Literals(["insert", "remove", "replace", "wrap", "reorder"]);
-var InsertStageMutation = Schema5.Struct({
-  op: Schema5.Literal("insert"),
-  stage: StageDescriptor,
-  contributedBy: Schema5.optional(TrimmedNonEmptyString)
-});
-var RemoveStageMutation = Schema5.Struct({
-  op: Schema5.Literal("remove"),
-  id: StageId,
-  contributedBy: Schema5.optional(TrimmedNonEmptyString)
-});
-var ReplaceStageMutation = Schema5.Struct({
-  op: Schema5.Literal("replace"),
-  id: StageId,
-  stage: StageDescriptor,
-  contributedBy: Schema5.optional(TrimmedNonEmptyString)
-});
-var WrapStageMutation = Schema5.Struct({
-  op: Schema5.Literal("wrap"),
-  id: StageId,
-  around: StageWrapperDescriptor,
-  contributedBy: Schema5.optional(TrimmedNonEmptyString)
-});
-var ReorderStageMutation = Schema5.Struct({
-  op: Schema5.Literal("reorder"),
-  id: StageId,
-  before: Schema5.optional(Schema5.Array(StageId)),
-  after: Schema5.optional(Schema5.Array(StageId)),
-  contributedBy: Schema5.optional(TrimmedNonEmptyString)
-});
-var StageMutation = Schema5.Union([
-  InsertStageMutation,
-  RemoveStageMutation,
-  ReplaceStageMutation,
-  WrapStageMutation,
-  ReorderStageMutation
-]);
-var ResolutionGrantUse = Schema5.Struct({
-  kind: Schema5.Literal("kernel-replacement"),
-  target: TrimmedNonEmptyString,
-  pluginId: TrimmedNonEmptyString
-});
-var ResolutionRecordEntry = Schema5.Struct({
-  stageId: StageId,
-  contributedBy: TrimmedNonEmptyString,
-  removedBy: Schema5.optional(TrimmedNonEmptyString),
-  replacedBy: Schema5.optional(TrimmedNonEmptyString),
-  wrappedBy: Schema5.optional(Schema5.Array(TrimmedNonEmptyString)),
-  droppedAnchors: Schema5.optional(Schema5.Array(StageId)),
-  isProtected: Schema5.Boolean
-});
-var ResolvedPipeline = Schema5.Struct({
-  runId: Schema5.optional(RunId),
-  order: Schema5.Array(StageId),
-  record: Schema5.Array(ResolutionRecordEntry),
-  cycles: Schema5.Array(Schema5.Array(StageId)),
-  grantUses: Schema5.optional(Schema5.Array(ResolutionGrantUse)),
-  resolvedAt: Schema5.optional(IsoDateTime)
-});
-var StageRunOutcome = Schema5.Struct({
-  stageId: StageId,
-  result: StageResult,
-  startedAt: IsoDateTime,
-  finishedAt: IsoDateTime
-});
-
-// packages/contracts/src/run-journal.ts
-var RunActor = Schema6.Struct({
-  kind: Schema6.Literals(["operator", "agent", "server", "system"]),
-  id: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString))
-});
-var RunCloseoutPhase = Schema6.Literals([
-  "queued",
-  "commit",
-  "push",
-  "pr-review-merge",
-  "pr-opened",
-  "merge",
-  "close-source",
-  "completed"
-]);
-var RunCloseoutPhaseOutcome = Schema6.Literals(["started", "completed", "failed"]);
-var RunCloseoutStatus = Schema6.Literals([
-  "pending",
-  "running",
-  "completed",
-  "needs-attention",
-  "failed"
-]);
-var RunCloseoutState = Schema6.Struct({
-  phase: RunCloseoutPhase,
-  status: RunCloseoutStatus,
-  updatedAt: IsoDateTime,
-  taskId: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
-  runtimeWorkspace: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
-  branch: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
-  prUrl: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
-  artifactRoot: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
-  iterations: Schema6.optional(Schema6.NullOr(Schema6.Int)),
-  feedback: Schema6.optional(Schema6.Array(Schema6.String)),
-  error: Schema6.optional(Schema6.NullOr(Schema6.String)),
-  reason: Schema6.optional(Schema6.NullOr(Schema6.String)),
-  merged: Schema6.optional(Schema6.Boolean),
-  resumedAt: Schema6.optional(Schema6.NullOr(IsoDateTime)),
-  completedAt: Schema6.optional(Schema6.NullOr(IsoDateTime))
-});
-var ApprovalDecision = Schema6.Literals(["approve", "reject"]);
-var runRecordFields = {
-  runId: TrimmedNonEmptyString,
-  workspaceId: TrimmedNonEmptyString,
-  taskId: Schema6.NullOr(TrimmedNonEmptyString),
-  threadId: Schema6.NullOr(TrimmedNonEmptyString),
-  mode: Schema6.Literals(["local", "remote"]),
-  runtimeAdapter: Schema6.Literal("pi"),
-  createdAt: IsoDateTime,
-  startedAt: Schema6.NullOr(IsoDateTime),
-  completedAt: Schema6.NullOr(IsoDateTime),
-  endpointId: Schema6.NullOr(TrimmedNonEmptyString),
-  hostId: Schema6.NullOr(TrimmedNonEmptyString),
-  worktreePath: Schema6.NullOr(TrimmedNonEmptyString),
-  artifactRoot: Schema6.NullOr(TrimmedNonEmptyString),
-  logRoot: Schema6.NullOr(TrimmedNonEmptyString),
-  sessionPath: Schema6.NullOr(TrimmedNonEmptyString),
-  sessionLogPath: Schema6.NullOr(TrimmedNonEmptyString),
-  pid: Schema6.optional(Schema6.NullOr(Schema6.Int)),
-  piSession: Schema6.optional(Schema6.Unknown),
-  piSessionPrivate: Schema6.optional(Schema6.Unknown),
-  updatedAt: IsoDateTime,
-  title: TrimmedNonEmptyString,
-  projectRoot: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
-  errorText: Schema6.optional(Schema6.NullOr(Schema6.String)),
-  latestMessageId: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
-  prUrl: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
-  leaseId: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
-  serverCloseout: Schema6.optional(Schema6.NullOr(RunCloseoutState)),
-  model: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
-  runtimeMode: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
-  interactionMode: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
-  runMode: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
-  initialPrompt: Schema6.optional(Schema6.NullOr(Schema6.String)),
-  baselineMode: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
-  prMode: Schema6.optional(Schema6.NullOr(Schema6.Literals(["auto", "ask", "off"]))),
-  initiatedBy: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
-  sourceTask: Schema6.optional(Schema6.Unknown),
-  serverPid: Schema6.optional(Schema6.NullOr(Schema6.Int)),
-  latestSteeringAt: Schema6.optional(Schema6.NullOr(IsoDateTime)),
-  latestSteeringDeliveredAt: Schema6.optional(Schema6.NullOr(IsoDateTime)),
-  statusDetail: Schema6.optional(Schema6.NullOr(Schema6.String)),
-  planning: Schema6.optional(Schema6.Unknown),
-  branch: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString))
-};
-var RunJournalRecord = Schema6.Struct({
-  ...runRecordFields,
-  status: RunStatus
-});
-var RunRecordPatch = Schema6.Struct({
-  runId: Schema6.optional(runRecordFields.runId),
-  workspaceId: Schema6.optional(runRecordFields.workspaceId),
-  taskId: Schema6.optional(runRecordFields.taskId),
-  threadId: Schema6.optional(runRecordFields.threadId),
-  mode: Schema6.optional(runRecordFields.mode),
-  runtimeAdapter: Schema6.optional(runRecordFields.runtimeAdapter),
-  createdAt: Schema6.optional(runRecordFields.createdAt),
-  startedAt: Schema6.optional(runRecordFields.startedAt),
-  completedAt: Schema6.optional(runRecordFields.completedAt),
-  endpointId: Schema6.optional(runRecordFields.endpointId),
-  hostId: Schema6.optional(runRecordFields.hostId),
-  worktreePath: Schema6.optional(runRecordFields.worktreePath),
-  artifactRoot: Schema6.optional(runRecordFields.artifactRoot),
-  logRoot: Schema6.optional(runRecordFields.logRoot),
-  sessionPath: Schema6.optional(runRecordFields.sessionPath),
-  sessionLogPath: Schema6.optional(runRecordFields.sessionLogPath),
-  pid: runRecordFields.pid,
-  piSession: runRecordFields.piSession,
-  piSessionPrivate: runRecordFields.piSessionPrivate,
-  updatedAt: Schema6.optional(runRecordFields.updatedAt),
-  title: Schema6.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: Schema6.Literal(1),
-  seq: PositiveInt,
-  at: IsoDateTime,
-  runId: RunId
-};
-var RunStatusChangedEvent = Schema6.Struct({
-  ...journalEnvelopeFields,
-  type: Schema6.Literal("status-changed"),
-  from: Schema6.NullOr(RunStatus),
-  to: RunStatus,
-  reason: Schema6.optional(Schema6.NullOr(Schema6.String)),
-  actor: Schema6.optional(RunActor)
-});
-var RunRecordPatchEvent = Schema6.Struct({
-  ...journalEnvelopeFields,
-  type: Schema6.Literal("record-patch"),
-  patch: RunRecordPatch
-});
-var RunTimelineEntryEvent = Schema6.Struct({
-  ...journalEnvelopeFields,
-  type: Schema6.Literal("timeline-entry"),
-  payload: Schema6.Unknown
-});
-var RunLogEntryEvent = Schema6.Struct({
-  ...journalEnvelopeFields,
-  type: Schema6.Literal("log-entry"),
-  payload: Schema6.Unknown
-});
-var RunApprovalRequestedEvent = Schema6.Struct({
-  ...journalEnvelopeFields,
-  type: Schema6.Literal("approval-requested"),
-  requestId: TrimmedNonEmptyString,
-  requestKind: TrimmedNonEmptyString,
-  actionId: Schema6.optional(Schema6.NullOr(TrimmedNonEmptyString)),
-  payload: Schema6.Unknown
-});
-var RunApprovalResolvedEvent = Schema6.Struct({
-  ...journalEnvelopeFields,
-  type: Schema6.Literal("approval-resolved"),
-  requestId: TrimmedNonEmptyString,
-  decision: ApprovalDecision,
-  note: Schema6.optional(Schema6.NullOr(Schema6.String)),
-  actor: RunActor
-});
-var RunInputRequestedEvent = Schema6.Struct({
-  ...journalEnvelopeFields,
-  type: Schema6.Literal("input-requested"),
-  requestId: TrimmedNonEmptyString,
-  payload: Schema6.Unknown
-});
-var RunInputResolvedEvent = Schema6.Struct({
-  ...journalEnvelopeFields,
-  type: Schema6.Literal("input-resolved"),
-  requestId: TrimmedNonEmptyString,
-  answers: Schema6.Record(Schema6.String, Schema6.String),
-  actor: RunActor
-});
-var RunSteeringEvent = Schema6.Struct({
-  ...journalEnvelopeFields,
-  type: Schema6.Literal("steering"),
-  actor: RunActor,
-  text: Schema6.String
-});
-var RunAdoptedEvent = Schema6.Struct({
-  ...journalEnvelopeFields,
-  type: Schema6.Literal("adopted"),
-  pid: Schema6.NullOr(Schema6.Int),
-  serverPid: Schema6.Int
-});
-var RunStallDetectedEvent = Schema6.Struct({
-  ...journalEnvelopeFields,
-  type: Schema6.Literal("stall-detected"),
-  detail: Schema6.String
-});
-var RunCloseoutPhaseEvent = Schema6.Struct({
-  ...journalEnvelopeFields,
-  type: Schema6.Literal("closeout-phase"),
-  phase: RunCloseoutPhase,
-  outcome: RunCloseoutPhaseOutcome,
-  detail: Schema6.optional(Schema6.NullOr(Schema6.String))
-});
-var RunPipelineResolvedEvent = Schema6.Struct({
-  ...journalEnvelopeFields,
-  type: Schema6.Literal("pipeline-resolved"),
-  pipeline: ResolvedPipeline
-});
-var RunStageOutcomeEvent = Schema6.Struct({
-  ...journalEnvelopeFields,
-  type: Schema6.Literal("stage-outcome"),
-  outcome: StageRunOutcome
-});
-var RunJournalEvent = Schema6.Union([
-  RunStatusChangedEvent,
-  RunRecordPatchEvent,
-  RunTimelineEntryEvent,
-  RunLogEntryEvent,
-  RunApprovalRequestedEvent,
-  RunApprovalResolvedEvent,
-  RunInputRequestedEvent,
-  RunInputResolvedEvent,
-  RunSteeringEvent,
-  RunAdoptedEvent,
-  RunStallDetectedEvent,
-  RunCloseoutPhaseEvent,
-  RunPipelineResolvedEvent,
-  RunStageOutcomeEvent
-]);
-var decodeRunJournalEvent = Schema6.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, runId = null) {
-  let record = {};
-  let status = null;
-  const statusHistory = [];
-  const pendingApprovals = new Map;
-  const resolvedApprovals = [];
-  const pendingUserInputs = new Map;
-  const resolvedUserInputs = [];
-  const closeoutPhases = [];
-  let resolvedPipeline = null;
-  const stageOutcomes = [];
-  const anomalies = [];
-  let steeringCount = 0;
-  let stallCount = 0;
-  let lastSeq = 0;
-  let lastEventAt = null;
-  const projectedRunId = runId ?? events[0]?.runId ?? 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 "pipeline-resolved": {
-        resolvedPipeline = event.pipeline;
-        break;
-      }
-      case "stage-outcome": {
-        stageOutcomes.push({ seq: event.seq, at: event.at, outcome: event.outcome });
-        break;
-      }
-      case "timeline-entry":
-      case "log-entry":
-        break;
-    }
-  }
-  return {
-    runId: projectedRunId,
-    record,
-    status,
-    statusHistory,
-    pendingApprovals: [...pendingApprovals.values()],
-    resolvedApprovals,
-    pendingUserInputs: [...pendingUserInputs.values()],
-    resolvedUserInputs,
-    steeringCount,
-    stallCount,
-    closeoutPhases,
-    resolvedPipeline,
-    stageOutcomes,
-    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";
@@ -1615,108 +16,10 @@ var RIG_RUN_PIPELINE_RESOLVED = "rig.run.pipeline-resolved";
 var RIG_RUN_STAGE_OUTCOME = "rig.run.stage-outcome";
 var RIG_STOP_SENTINEL = "<<RIG_STOP";
 var RIG_STOP_SENTINEL_END = ">>";
-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 };
-}
 var RIG_PAUSE_SENTINEL = "<<RIG_PAUSE";
 var RIG_RESUME_SENTINEL = "<<RIG_RESUME";
 var RIG_CONTROL_SENTINEL_END = ">>";
-function buildControlSentinel(marker, runId, requestedBy) {
-  return `${marker} runId=${runId} requestedBy=${requestedBy}${RIG_CONTROL_SENTINEL_END}`;
-}
-function parseControlSentinel(marker, text, expectedRunId) {
-  const start = text.indexOf(marker);
-  if (start < 0)
-    return null;
-  const end = text.indexOf(RIG_CONTROL_SENTINEL_END, start);
-  const body = text.slice(start + marker.length, end >= 0 ? end : undefined).trim();
-  const runId = body.match(/(?:^|\s)runId=([^\s>]+)/)?.[1] ?? "";
-  if (runId && runId !== expectedRunId)
-    return null;
-  const requestedBy = body.match(/(?:^|\s)requestedBy=([^\s>]+)/)?.[1] ?? null;
-  return { requestedBy };
-}
-function buildPauseSentinel(runId, requestedBy = "rig") {
-  return buildControlSentinel(RIG_PAUSE_SENTINEL, runId, requestedBy);
-}
-function parsePauseSentinel(text, expectedRunId) {
-  return parseControlSentinel(RIG_PAUSE_SENTINEL, text, expectedRunId);
-}
-function buildResumeSentinel(runId, requestedBy = "rig") {
-  return buildControlSentinel(RIG_RESUME_SENTINEL, runId, requestedBy);
-}
-function parseResumeSentinel(text, expectedRunId) {
-  return parseControlSentinel(RIG_RESUME_SENTINEL, text, expectedRunId);
-}
 var RIG_INBOX_RESOLUTION_SENTINEL = "<<RIG_INBOX_RESOLUTION";
-function encodeInboxResolutionPayload(payload) {
-  return encodeURIComponent(JSON.stringify(payload));
-}
-function decodeInboxResolutionPayload(payload) {
-  try {
-    const parsed = JSON.parse(decodeURIComponent(payload));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-      return null;
-    const record = parsed;
-    if (record.kind === "approval") {
-      const requestId = typeof record.requestId === "string" ? record.requestId.trim() : "";
-      const decision = record.decision === "approve" || record.decision === "reject" ? record.decision : null;
-      const note = typeof record.note === "string" ? record.note : record.note === null ? null : undefined;
-      if (!requestId || !decision)
-        return null;
-      return { kind: "approval", requestId, decision, ...note !== undefined ? { note } : {} };
-    }
-    if (record.kind === "input") {
-      const requestId = typeof record.requestId === "string" ? record.requestId.trim() : "";
-      const answers = record.answers && typeof record.answers === "object" && !Array.isArray(record.answers) ? Object.fromEntries(Object.entries(record.answers).filter((entry) => typeof entry[1] === "string")) : null;
-      if (!requestId || !answers)
-        return null;
-      return { kind: "input", requestId, answers };
-    }
-  } catch {
-    return null;
-  }
-  return null;
-}
-function buildInboxResolutionSentinel(runId, resolution, requestedBy = "rig") {
-  return `${RIG_INBOX_RESOLUTION_SENTINEL} runId=${runId} requestedBy=${requestedBy} data=${encodeInboxResolutionPayload(resolution)}${RIG_CONTROL_SENTINEL_END}`;
-}
-function parseInboxResolutionSentinel(text, expectedRunId) {
-  const start = text.indexOf(RIG_INBOX_RESOLUTION_SENTINEL);
-  if (start < 0)
-    return null;
-  const end = text.indexOf(RIG_CONTROL_SENTINEL_END, start);
-  const body = text.slice(start + RIG_INBOX_RESOLUTION_SENTINEL.length, end >= 0 ? end : undefined).trim();
-  const runId = body.match(/(?:^|\s)runId=([^\s>]+)/)?.[1] ?? "";
-  if (runId && runId !== expectedRunId)
-    return null;
-  const requestedBy = body.match(/(?:^|\s)requestedBy=([^\s>]+)/)?.[1] ?? null;
-  const payload = body.match(/(?:^|\s)data=([^\s>]+)/)?.[1] ?? "";
-  const decoded = decodeInboxResolutionPayload(payload);
-  if (!decoded)
-    return null;
-  return { ...decoded, requestedBy };
-}
-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,
@@ -1749,41 +52,7 @@ var TYPE_FOR_CUSTOM = {
   [RIG_RUN_PIPELINE_RESOLVED]: "pipeline-resolved",
   [RIG_RUN_STAGE_OUTCOME]: "stage-outcome"
 };
-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, runId);
-}
 export {
-  sessionIdFromSessionFile,
-  parseStopSentinel,
-  parseResumeSentinel,
-  parsePauseSentinel,
-  parseInboxResolutionSentinel,
-  isRunSessionCustomType,
-  foldRunSessionEntries,
-  buildStopSentinel,
-  buildResumeSentinel,
-  buildPauseSentinel,
-  buildInboxResolutionSentinel,
   TYPE_FOR_CUSTOM,
   RIG_STOP_SENTINEL_END,
   RIG_STOP_SENTINEL,