@h-rig/contracts 0.0.6-alpha.18 → 0.0.6-alpha.181

package/dist/src/run-journal.js

@@ -0,0 +1,569 @@
+// @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 Schema3 } from "effect";
+
+// packages/contracts/src/orchestration.ts
+import { Schema as Schema2 } from "effect";
+var ProviderKind = Schema2.Literals(["codex", "claude"]);
+var ProviderApprovalPolicy = Schema2.Literals([
+  "untrusted",
+  "on-failure",
+  "on-request",
+  "never"
+]);
+var ProviderSandboxMode = Schema2.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var ProviderServiceTier = Schema2.Literals(["fast", "flex"]);
+var RuntimeMode = Schema2.Literals(["approval-required", "full-access"]);
+var ProviderInteractionMode = Schema2.Literals(["default", "plan"]);
+var ProviderRequestKind = Schema2.Literals(["command", "file-read", "file-change"]);
+var ProviderApprovalDecision = Schema2.Literals([
+  "accept",
+  "acceptForSession",
+  "decline",
+  "cancel"
+]);
+var ProviderUserInputAnswers = Schema2.Record(Schema2.String, Schema2.Unknown);
+var PROVIDER_SEND_TURN_MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+var CHAT_ATTACHMENT_ID_MAX_CHARS = 128;
+var ChatAttachmentId = TrimmedNonEmptyString.check(Schema2.isMaxLength(CHAT_ATTACHMENT_ID_MAX_CHARS), Schema2.isPattern(/^[a-z0-9_-]+$/i));
+var ChatImageAttachment = Schema2.Struct({
+  type: Schema2.Literal("image"),
+  id: ChatAttachmentId,
+  name: TrimmedNonEmptyString.check(Schema2.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema2.isMaxLength(100), Schema2.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema2.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES))
+});
+var ChatAttachment = Schema2.Union([ChatImageAttachment]);
+
+// packages/contracts/src/runtime.ts
+var RunKind = Schema3.Literals(["adhoc", "task", "batch", "validation", "review"]);
+var RunMode = Schema3.Literals(["interactive", "autonomous", "supervised"]);
+var RunStatus = Schema3.Literals([
+  "created",
+  "queued",
+  "preparing",
+  "running",
+  "waiting-approval",
+  "waiting-user-input",
+  "paused",
+  "validating",
+  "reviewing",
+  "closing-out",
+  "needs-attention",
+  "completed",
+  "failed",
+  "stopped"
+]);
+var EngineSandboxMode = Schema3.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var IsolationMode = Schema3.Literals(["none", "env", "worktree"]);
+var RuntimeStatus = Schema3.Literals([
+  "prepared",
+  "starting",
+  "running",
+  "interrupted",
+  "exited",
+  "failed",
+  "destroyed"
+]);
+var RunExecutionTarget = Schema3.Literals(["local", "remote"]);
+var RunSummary = Schema3.Struct({
+  id: RunId,
+  workspaceId: WorkspaceId,
+  taskId: Schema3.NullOr(TaskId),
+  title: TrimmedNonEmptyString,
+  runKind: RunKind,
+  mode: RunMode,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  status: RunStatus,
+  runtimeAdapter: Schema3.Literal("pi"),
+  model: Schema3.NullOr(TrimmedNonEmptyString),
+  initialPrompt: Schema3.NullOr(Schema3.String),
+  executionTarget: Schema3.optional(RunExecutionTarget),
+  remoteHostId: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseId: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseClaimedAt: Schema3.optional(Schema3.NullOr(IsoDateTime)),
+  activeRuntimeId: Schema3.NullOr(EngineRuntimeId),
+  latestMessageId: Schema3.NullOr(TrimmedNonEmptyString),
+  pendingApprovalCount: NonNegativeInt,
+  pendingUserInputCount: NonNegativeInt,
+  branch: Schema3.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema3.NullOr(TrimmedNonEmptyString),
+  errorText: Schema3.NullOr(Schema3.String),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  startedAt: Schema3.NullOr(IsoDateTime),
+  completedAt: Schema3.NullOr(IsoDateTime)
+});
+var RuntimeSummary = Schema3.Struct({
+  id: EngineRuntimeId,
+  workspaceId: WorkspaceId,
+  runId: RunId,
+  adapterKind: Schema3.Literal("pi"),
+  executionTarget: Schema3.optional(RunExecutionTarget),
+  remoteHostId: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  status: RuntimeStatus,
+  sandboxMode: EngineSandboxMode,
+  isolationMode: IsolationMode,
+  workspaceDir: Schema3.NullOr(TrimmedNonEmptyString),
+  homeDir: Schema3.NullOr(TrimmedNonEmptyString),
+  tmpDir: Schema3.NullOr(TrimmedNonEmptyString),
+  cacheDir: Schema3.NullOr(TrimmedNonEmptyString),
+  logsDir: Schema3.NullOr(TrimmedNonEmptyString),
+  stateDir: Schema3.NullOr(TrimmedNonEmptyString),
+  sessionDir: Schema3.NullOr(TrimmedNonEmptyString),
+  sessionLogPath: Schema3.NullOr(TrimmedNonEmptyString),
+  pid: Schema3.NullOr(NonNegativeInt),
+  startedAt: Schema3.NullOr(IsoDateTime),
+  updatedAt: IsoDateTime,
+  exitedAt: Schema3.NullOr(IsoDateTime)
+});
+var ApprovalStatus = Schema3.Literals(["pending", "resolved"]);
+var ApprovalSummary = Schema3.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  actionId: Schema3.NullOr(TrimmedNonEmptyString),
+  requestKind: TrimmedNonEmptyString,
+  status: ApprovalStatus,
+  payload: Schema3.Unknown,
+  createdAt: IsoDateTime,
+  resolvedAt: Schema3.NullOr(IsoDateTime)
+});
+var UserInputRequestSummary = Schema3.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  status: ApprovalStatus,
+  payload: Schema3.Unknown,
+  createdAt: IsoDateTime,
+  resolvedAt: Schema3.NullOr(IsoDateTime)
+});
+var WorktreeSummary = Schema3.Struct({
+  id: WorktreeId,
+  workspaceId: WorkspaceId,
+  runId: RunId,
+  taskId: Schema3.NullOr(TaskId),
+  branchName: TrimmedNonEmptyString,
+  path: TrimmedNonEmptyString,
+  status: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  cleanedAt: Schema3.NullOr(IsoDateTime)
+});
+
+// packages/contracts/src/stage.ts
+import { Schema as Schema4 } from "effect";
+var StageKind = Schema4.Literals(["transform", "gate", "observe"]);
+var StageId = TrimmedNonEmptyString.pipe(Schema4.brand("StageId"));
+var StageContext = Schema4.Struct({
+  runId: RunId,
+  taskId: Schema4.optional(Schema4.NullOr(TaskId)),
+  state: Schema4.Unknown,
+  metadata: Schema4.optional(Schema4.Record(Schema4.String, Schema4.Unknown))
+});
+var StageDescriptor = Schema4.Struct({
+  id: StageId,
+  kind: StageKind,
+  before: Schema4.optional(Schema4.Array(StageId)),
+  after: Schema4.optional(Schema4.Array(StageId)),
+  priority: Schema4.Number.pipe(Schema4.withDecodingDefault(() => 0)),
+  protected: Schema4.Boolean.pipe(Schema4.withDecodingDefault(() => false))
+});
+var StageContinueResult = Schema4.Struct({
+  kind: Schema4.Literal("continue"),
+  ctx: StageContext
+});
+var StageAllowResult = Schema4.Struct({
+  kind: Schema4.Literal("allow")
+});
+var StageBlockResult = Schema4.Struct({
+  kind: Schema4.Literal("block"),
+  reason: TrimmedNonEmptyString
+});
+var StageResult = Schema4.Union([
+  StageContinueResult,
+  StageAllowResult,
+  StageBlockResult
+]);
+var StageWrapperDescriptor = Schema4.Struct({
+  id: TrimmedNonEmptyString,
+  priority: Schema4.Number.pipe(Schema4.withDecodingDefault(() => 0))
+});
+var StageMutationOp = Schema4.Literals(["insert", "remove", "replace", "wrap", "reorder"]);
+var InsertStageMutation = Schema4.Struct({
+  op: Schema4.Literal("insert"),
+  stage: StageDescriptor,
+  contributedBy: Schema4.optional(TrimmedNonEmptyString)
+});
+var RemoveStageMutation = Schema4.Struct({
+  op: Schema4.Literal("remove"),
+  id: StageId,
+  contributedBy: Schema4.optional(TrimmedNonEmptyString)
+});
+var ReplaceStageMutation = Schema4.Struct({
+  op: Schema4.Literal("replace"),
+  id: StageId,
+  stage: StageDescriptor,
+  contributedBy: Schema4.optional(TrimmedNonEmptyString)
+});
+var WrapStageMutation = Schema4.Struct({
+  op: Schema4.Literal("wrap"),
+  id: StageId,
+  around: StageWrapperDescriptor,
+  contributedBy: Schema4.optional(TrimmedNonEmptyString)
+});
+var ReorderStageMutation = Schema4.Struct({
+  op: Schema4.Literal("reorder"),
+  id: StageId,
+  before: Schema4.optional(Schema4.Array(StageId)),
+  after: Schema4.optional(Schema4.Array(StageId)),
+  contributedBy: Schema4.optional(TrimmedNonEmptyString)
+});
+var StageMutation = Schema4.Union([
+  InsertStageMutation,
+  RemoveStageMutation,
+  ReplaceStageMutation,
+  WrapStageMutation,
+  ReorderStageMutation
+]);
+var ResolutionGrantUse = Schema4.Struct({
+  kind: Schema4.Literal("kernel-replacement"),
+  target: TrimmedNonEmptyString,
+  pluginId: TrimmedNonEmptyString
+});
+var ResolutionRecordEntry = Schema4.Struct({
+  stageId: StageId,
+  contributedBy: TrimmedNonEmptyString,
+  removedBy: Schema4.optional(TrimmedNonEmptyString),
+  replacedBy: Schema4.optional(TrimmedNonEmptyString),
+  wrappedBy: Schema4.optional(Schema4.Array(TrimmedNonEmptyString)),
+  droppedAnchors: Schema4.optional(Schema4.Array(StageId)),
+  isProtected: Schema4.Boolean
+});
+var ResolvedPipeline = Schema4.Struct({
+  runId: Schema4.optional(RunId),
+  order: Schema4.Array(StageId),
+  record: Schema4.Array(ResolutionRecordEntry),
+  cycles: Schema4.Array(Schema4.Array(StageId)),
+  grantUses: Schema4.optional(Schema4.Array(ResolutionGrantUse)),
+  resolvedAt: Schema4.optional(IsoDateTime)
+});
+var StageRunOutcome = Schema4.Struct({
+  stageId: StageId,
+  result: StageResult,
+  startedAt: IsoDateTime,
+  finishedAt: 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: Schema5.Literal("pi"),
+  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 RunPipelineResolvedEvent = Schema5.Struct({
+  ...journalEnvelopeFields,
+  type: Schema5.Literal("pipeline-resolved"),
+  pipeline: ResolvedPipeline
+});
+var RunStageOutcomeEvent = Schema5.Struct({
+  ...journalEnvelopeFields,
+  type: Schema5.Literal("stage-outcome"),
+  outcome: StageRunOutcome
+});
+var RunJournalEvent = Schema5.Union([
+  RunStatusChangedEvent,
+  RunRecordPatchEvent,
+  RunTimelineEntryEvent,
+  RunLogEntryEvent,
+  RunApprovalRequestedEvent,
+  RunApprovalResolvedEvent,
+  RunInputRequestedEvent,
+  RunInputResolvedEvent,
+  RunSteeringEvent,
+  RunAdoptedEvent,
+  RunStallDetectedEvent,
+  RunCloseoutPhaseEvent,
+  RunPipelineResolvedEvent,
+  RunStageOutcomeEvent
+]);
+export {
+  RunTimelineEntryEvent,
+  RunSteeringEvent,
+  RunStatusChangedEvent,
+  RunStallDetectedEvent,
+  RunStageOutcomeEvent,
+  RunRecordPatchEvent,
+  RunRecordPatch,
+  RunPipelineResolvedEvent,
+  RunLogEntryEvent,
+  RunJournalRecord,
+  RunJournalEvent,
+  RunInputResolvedEvent,
+  RunInputRequestedEvent,
+  RunCloseoutStatus,
+  RunCloseoutState,
+  RunCloseoutPhaseOutcome,
+  RunCloseoutPhaseEvent,
+  RunCloseoutPhase,
+  RunApprovalResolvedEvent,
+  RunApprovalRequestedEvent,
+  RunAdoptedEvent,
+  RunActor,
+  ApprovalDecision
+};

package/dist/src/run-queue.d.ts

@@ -0,0 +1,36 @@
+/**
+ * run-queue.ts — scheduler-owned run queue capability vocabulary.
+ *
+ * Contracts keeps only the typed id and data shapes. Ranking, packing, and
+ * admission behavior lives in @rig/scheduler-plugin and is consumed by
+ * supervisor/CLI surfaces through this capability.
+ */
+import type { CapabilityId } from "./capability-id";
+import type { TaskDependencyProjection } from "./task-graph-primitives";
+import type { SupervisorSelectionPolicy } from "./supervisor-journal";
+export interface RunQueueRankedTask<T extends TaskDependencyProjection = TaskDependencyProjection> {
+    readonly task: T;
+    readonly score: number;
+    readonly priority: number;
+    readonly unblockCount: number;
+    readonly scope: readonly string[];
+}
+export interface RunQueuePlanInput<T extends TaskDependencyProjection = TaskDependencyProjection> {
+    readonly tasks: readonly T[];
+    readonly activeTaskIds?: Iterable<string>;
+    readonly excludeTaskIds?: Iterable<string>;
+    readonly candidateTaskIds?: Iterable<string>;
+    readonly selectionPolicy?: SupervisorSelectionPolicy;
+    readonly requireDisjointScopes?: boolean;
+    readonly disjointWithScopes?: Iterable<string>;
+    readonly limit?: number;
+}
+export interface RunQueuePlan<T extends TaskDependencyProjection = TaskDependencyProjection> {
+    readonly plannedOrder: readonly string[];
+    readonly ranked: readonly RunQueueRankedTask<T>[];
+}
+export interface RunQueueService {
+    readonly planReadyTasks: <T extends TaskDependencyProjection>(input: RunQueuePlanInput<T>) => RunQueuePlan<T>;
+}
+export declare const RUN_QUEUE_CAPABILITY_ID = "rig.scheduler.run-queue";
+export declare const RUN_QUEUE: CapabilityId<RunQueueService>;

package/dist/src/run-queue.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/run-queue.ts
+var RUN_QUEUE_CAPABILITY_ID = "rig.scheduler.run-queue";
+var RUN_QUEUE = makeCapabilityId(RUN_QUEUE_CAPABILITY_ID);
+export {
+  RUN_QUEUE_CAPABILITY_ID,
+  RUN_QUEUE
+};