@h-rig/contracts 0.0.6-alpha.17 → 0.0.6-alpha.171

package/dist/src/supervisor-journal.d.ts

@@ -0,0 +1,204 @@
+import { Schema } from "effect";
+export declare const SupervisorStopReason: Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>;
+export type SupervisorStopReason = typeof SupervisorStopReason.Type;
+export declare const SupervisorSelectionPolicy: Schema.Literals<readonly ["rank", "max-unblock", "blocking-only"]>;
+export type SupervisorSelectionPolicy = typeof SupervisorSelectionPolicy.Type;
+export declare const SupervisorStatus: Schema.Literals<readonly ["running", "idle", "stopped", "finished"]>;
+export type SupervisorStatus = typeof SupervisorStatus.Type;
+export declare const TaskClosureSummary: Schema.Struct<{
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly prUrl: Schema.NullOr<Schema.String>;
+    readonly mergeGate: Schema.NullOr<Schema.Literals<readonly ["passed", "blocked", "skipped"]>>;
+    readonly acceptanceChecked: Schema.$Array<Schema.Struct<{
+        readonly item: Schema.String;
+        readonly met: Schema.Boolean;
+    }>>;
+    readonly unblockedTaskIds: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
+}>;
+export type TaskClosureSummary = typeof TaskClosureSummary.Type;
+export declare const SupervisorStartedEvent: Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.started">;
+    readonly at: Schema.String;
+    readonly options: Schema.Unknown;
+}>;
+export type SupervisorStartedEvent = typeof SupervisorStartedEvent.Type;
+export declare const SupervisorSelectionPlannedEvent: Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.selection-planned">;
+    readonly at: Schema.String;
+    readonly taskIds: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly policy: Schema.Literals<readonly ["rank", "max-unblock", "blocking-only"]>;
+}>;
+export type SupervisorSelectionPlannedEvent = typeof SupervisorSelectionPlannedEvent.Type;
+export declare const SupervisorDispatchStartedEvent: Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.dispatch-started">;
+    readonly at: Schema.String;
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly score: Schema.Int;
+}>;
+export type SupervisorDispatchStartedEvent = typeof SupervisorDispatchStartedEvent.Type;
+export declare const SupervisorDispatchConfirmedEvent: Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.dispatch-confirmed">;
+    readonly at: Schema.String;
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly dispatchHandle: Schema.optional<Schema.NullOr<Schema.String>>;
+}>;
+export type SupervisorDispatchConfirmedEvent = typeof SupervisorDispatchConfirmedEvent.Type;
+export declare const SupervisorDispatchEvent: Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.dispatch">;
+    readonly at: Schema.String;
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly score: Schema.Int;
+    readonly dispatchHandle: Schema.optional<Schema.NullOr<Schema.String>>;
+}>;
+export type SupervisorDispatchEvent = typeof SupervisorDispatchEvent.Type;
+export declare const SupervisorOutcomeEvent: Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.outcome">;
+    readonly at: Schema.String;
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly status: Schema.Literals<readonly ["created", "queued", "preparing", "running", "waiting-approval", "waiting-user-input", "paused", "validating", "reviewing", "closing-out", "needs-attention", "completed", "failed", "stopped"]>;
+    readonly failed: Schema.Boolean;
+    readonly unblockedTaskIds: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly closure: Schema.optional<Schema.Struct<{
+        readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly prUrl: Schema.NullOr<Schema.String>;
+        readonly mergeGate: Schema.NullOr<Schema.Literals<readonly ["passed", "blocked", "skipped"]>>;
+        readonly acceptanceChecked: Schema.$Array<Schema.Struct<{
+            readonly item: Schema.String;
+            readonly met: Schema.Boolean;
+        }>>;
+        readonly unblockedTaskIds: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
+    }>>;
+}>;
+export type SupervisorOutcomeEvent = typeof SupervisorOutcomeEvent.Type;
+export declare const SupervisorSkippedEvent: Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.skipped">;
+    readonly at: Schema.String;
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly reason: Schema.String;
+}>;
+export type SupervisorSkippedEvent = typeof SupervisorSkippedEvent.Type;
+export declare const SupervisorIdleEvent: Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.idle">;
+    readonly at: Schema.String;
+    readonly reason: Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>;
+}>;
+export type SupervisorIdleEvent = typeof SupervisorIdleEvent.Type;
+export declare const SupervisorStoppedEvent: Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.stopped">;
+    readonly at: Schema.String;
+    readonly reason: Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>;
+}>;
+export type SupervisorStoppedEvent = typeof SupervisorStoppedEvent.Type;
+export declare const SupervisorFinishedEvent: Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.finished">;
+    readonly at: Schema.String;
+    readonly processed: Schema.Int;
+    readonly succeeded: Schema.Int;
+    readonly failed: Schema.Int;
+    readonly skipped: Schema.optional<Schema.Int>;
+    readonly idleReason: Schema.NullOr<Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>>;
+}>;
+export type SupervisorFinishedEvent = typeof SupervisorFinishedEvent.Type;
+export declare const SupervisorEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.started">;
+    readonly at: Schema.String;
+    readonly options: Schema.Unknown;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.selection-planned">;
+    readonly at: Schema.String;
+    readonly taskIds: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly policy: Schema.Literals<readonly ["rank", "max-unblock", "blocking-only"]>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.dispatch-started">;
+    readonly at: Schema.String;
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly score: Schema.Int;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.dispatch-confirmed">;
+    readonly at: Schema.String;
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly dispatchHandle: Schema.optional<Schema.NullOr<Schema.String>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.dispatch">;
+    readonly at: Schema.String;
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly score: Schema.Int;
+    readonly dispatchHandle: Schema.optional<Schema.NullOr<Schema.String>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.outcome">;
+    readonly at: Schema.String;
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly status: Schema.Literals<readonly ["created", "queued", "preparing", "running", "waiting-approval", "waiting-user-input", "paused", "validating", "reviewing", "closing-out", "needs-attention", "completed", "failed", "stopped"]>;
+    readonly failed: Schema.Boolean;
+    readonly unblockedTaskIds: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly closure: Schema.optional<Schema.Struct<{
+        readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly prUrl: Schema.NullOr<Schema.String>;
+        readonly mergeGate: Schema.NullOr<Schema.Literals<readonly ["passed", "blocked", "skipped"]>>;
+        readonly acceptanceChecked: Schema.$Array<Schema.Struct<{
+            readonly item: Schema.String;
+            readonly met: Schema.Boolean;
+        }>>;
+        readonly unblockedTaskIds: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
+    }>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.skipped">;
+    readonly at: Schema.String;
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly reason: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.idle">;
+    readonly at: Schema.String;
+    readonly reason: Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.stopped">;
+    readonly at: Schema.String;
+    readonly reason: Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"supervisor.finished">;
+    readonly at: Schema.String;
+    readonly processed: Schema.Int;
+    readonly succeeded: Schema.Int;
+    readonly failed: Schema.Int;
+    readonly skipped: Schema.optional<Schema.Int>;
+    readonly idleReason: Schema.NullOr<Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>>;
+}>]>;
+export type SupervisorEvent = typeof SupervisorEvent.Type;
+export declare const SupervisorProjection: Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["running", "idle", "stopped", "finished"]>;
+    readonly processed: Schema.Int;
+    readonly succeeded: Schema.Int;
+    readonly failed: Schema.Int;
+    readonly skipped: Schema.Int;
+    readonly current: Schema.NullOr<Schema.Struct<{
+        readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    }>>;
+    readonly plannedOrder: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly selectionPolicy: Schema.NullOr<Schema.Literals<readonly ["rank", "max-unblock", "blocking-only"]>>;
+    readonly concurrency: Schema.NullOr<Schema.Int>;
+    readonly idleReason: Schema.NullOr<Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>>;
+    readonly stopReason: Schema.NullOr<Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>>;
+    readonly closures: Schema.$Array<Schema.Struct<{
+        readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly prUrl: Schema.NullOr<Schema.String>;
+        readonly mergeGate: Schema.NullOr<Schema.Literals<readonly ["passed", "blocked", "skipped"]>>;
+        readonly acceptanceChecked: Schema.$Array<Schema.Struct<{
+            readonly item: Schema.String;
+            readonly met: Schema.Boolean;
+        }>>;
+        readonly unblockedTaskIds: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
+    }>>;
+    readonly anomalies: Schema.$Array<Schema.String>;
+}>;
+export type SupervisorProjection = typeof SupervisorProjection.Type;

package/dist/src/supervisor-journal.js

@@ -0,0 +1,334 @@
+// @bun
+// packages/contracts/src/supervisor-journal.ts
+import { Schema as Schema4 } 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/supervisor-journal.ts
+var SupervisorStopReason = Schema4.Literals([
+  "all-done",
+  "all-human-blocked",
+  "max-tasks",
+  "budget",
+  "judge-stop",
+  "operator-stop",
+  "source-error"
+]);
+var SupervisorSelectionPolicy = Schema4.Literals(["rank", "max-unblock", "blocking-only"]);
+var SupervisorStatus = Schema4.Literals(["running", "idle", "stopped", "finished"]);
+var TaskClosureSummary = Schema4.Struct({
+  taskId: TaskId,
+  runId: RunId,
+  prUrl: Schema4.NullOr(Schema4.String),
+  mergeGate: Schema4.NullOr(Schema4.Literals(["passed", "blocked", "skipped"])),
+  acceptanceChecked: Schema4.Array(Schema4.Struct({
+    item: Schema4.String,
+    met: Schema4.Boolean
+  })),
+  unblockedTaskIds: Schema4.Array(TaskId)
+});
+var SupervisorStartedEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.started"),
+  at: IsoDateTime,
+  options: Schema4.Unknown
+});
+var SupervisorSelectionPlannedEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.selection-planned"),
+  at: IsoDateTime,
+  taskIds: Schema4.Array(TaskId),
+  policy: SupervisorSelectionPolicy
+});
+var SupervisorDispatchStartedEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.dispatch-started"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  score: NonNegativeInt
+});
+var SupervisorDispatchConfirmedEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.dispatch-confirmed"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  runId: RunId,
+  dispatchHandle: Schema4.optional(Schema4.NullOr(Schema4.String))
+});
+var SupervisorDispatchEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.dispatch"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  runId: RunId,
+  score: NonNegativeInt,
+  dispatchHandle: Schema4.optional(Schema4.NullOr(Schema4.String))
+});
+var SupervisorOutcomeEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.outcome"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  runId: RunId,
+  status: RunStatus,
+  failed: Schema4.Boolean,
+  unblockedTaskIds: Schema4.Array(TaskId),
+  closure: Schema4.optional(TaskClosureSummary)
+});
+var SupervisorSkippedEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.skipped"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  reason: Schema4.String
+});
+var SupervisorIdleEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.idle"),
+  at: IsoDateTime,
+  reason: SupervisorStopReason
+});
+var SupervisorStoppedEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.stopped"),
+  at: IsoDateTime,
+  reason: SupervisorStopReason
+});
+var SupervisorFinishedEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.finished"),
+  at: IsoDateTime,
+  processed: NonNegativeInt,
+  succeeded: NonNegativeInt,
+  failed: NonNegativeInt,
+  skipped: Schema4.optional(NonNegativeInt),
+  idleReason: Schema4.NullOr(SupervisorStopReason)
+});
+var SupervisorEvent = Schema4.Union([
+  SupervisorStartedEvent,
+  SupervisorSelectionPlannedEvent,
+  SupervisorDispatchStartedEvent,
+  SupervisorDispatchConfirmedEvent,
+  SupervisorDispatchEvent,
+  SupervisorOutcomeEvent,
+  SupervisorSkippedEvent,
+  SupervisorIdleEvent,
+  SupervisorStoppedEvent,
+  SupervisorFinishedEvent
+]);
+var SupervisorProjection = Schema4.Struct({
+  status: SupervisorStatus,
+  processed: NonNegativeInt,
+  succeeded: NonNegativeInt,
+  failed: NonNegativeInt,
+  skipped: NonNegativeInt,
+  current: Schema4.NullOr(Schema4.Struct({ taskId: TaskId, runId: RunId })),
+  plannedOrder: Schema4.Array(TaskId),
+  selectionPolicy: Schema4.NullOr(SupervisorSelectionPolicy),
+  concurrency: Schema4.NullOr(NonNegativeInt),
+  idleReason: Schema4.NullOr(SupervisorStopReason),
+  stopReason: Schema4.NullOr(SupervisorStopReason),
+  closures: Schema4.Array(TaskClosureSummary),
+  anomalies: Schema4.Array(Schema4.String)
+});
+export {
+  TaskClosureSummary,
+  SupervisorStoppedEvent,
+  SupervisorStopReason,
+  SupervisorStatus,
+  SupervisorStartedEvent,
+  SupervisorSkippedEvent,
+  SupervisorSelectionPolicy,
+  SupervisorSelectionPlannedEvent,
+  SupervisorProjection,
+  SupervisorOutcomeEvent,
+  SupervisorIdleEvent,
+  SupervisorFinishedEvent,
+  SupervisorEvent,
+  SupervisorDispatchStartedEvent,
+  SupervisorDispatchEvent,
+  SupervisorDispatchConfirmedEvent
+};

package/dist/src/task-artifacts.d.ts

@@ -0,0 +1,33 @@
+import type { CapabilityId } from "./capability-id";
+import type { TaskArtifactReadResult } from "./task-data";
+export type TaskArtifactRef = {
+    readonly projectRoot: string;
+    readonly taskId?: string;
+};
+export type TaskArtifactListEntry = {
+    readonly path: string;
+    readonly sizeBytes: number;
+    readonly kind: "file" | "directory" | "other";
+    readonly modifiedAt?: string | null;
+};
+export type TaskArtifactWriteInput = TaskArtifactRef & {
+    readonly filename: string;
+    readonly content: string;
+};
+export type TaskArtifactReadInput = TaskArtifactRef & {
+    readonly filename: string;
+    readonly maxBytes?: number;
+};
+export type TaskArtifactWriteResult = {
+    readonly path: string;
+    readonly sizeBytes: number;
+};
+/** Task artifact directory/list/read/write vocabulary. */
+export interface TaskArtifactsService {
+    artifactDir(input: TaskArtifactRef): string;
+    listArtifacts(input: TaskArtifactRef): Promise<readonly TaskArtifactListEntry[]>;
+    readArtifact(input: TaskArtifactReadInput): Promise<TaskArtifactReadResult>;
+    writeArtifact(input: TaskArtifactWriteInput): Promise<TaskArtifactWriteResult>;
+}
+export declare const TASK_ARTIFACTS_CAPABILITY_ID = "task-state.artifacts";
+export declare const TASK_ARTIFACTS: CapabilityId<TaskArtifactsService>;

package/dist/src/task-artifacts.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/task-artifacts.ts
+var TASK_ARTIFACTS_CAPABILITY_ID = "task-state.artifacts";
+var TASK_ARTIFACTS = makeCapabilityId(TASK_ARTIFACTS_CAPABILITY_ID);
+export {
+  TASK_ARTIFACTS_CAPABILITY_ID,
+  TASK_ARTIFACTS
+};

package/dist/src/task-context-renderer.d.ts

@@ -0,0 +1,29 @@
+import type { CapabilityId } from "./capability-id";
+import type { RuntimeInstructionProvider } from "./provider-instructions";
+import type { RigTask, TaskRecord } from "./task-source";
+export type TaskContextRenderInput = {
+    readonly projectRoot: string;
+    readonly taskId?: string;
+    readonly task?: RigTask | TaskRecord | null;
+    readonly provider?: RuntimeInstructionProvider;
+};
+export type TaskScopeRenderInput = TaskContextRenderInput & {
+    readonly expandFiles?: boolean;
+};
+export type TaskPromptContextSection = {
+    readonly title: string;
+    readonly content: string;
+};
+export type TaskPromptContext = {
+    readonly taskId: string | null;
+    readonly sections: readonly TaskPromptContextSection[];
+};
+/** Provider/prompt-owned task info, scope, and dependency rendering vocabulary. */
+export interface TaskContextRendererService {
+    renderTaskInfo(input: TaskContextRenderInput): Promise<TaskPromptContextSection>;
+    renderTaskScope(input: TaskScopeRenderInput): Promise<TaskPromptContextSection>;
+    renderTaskDependencies(input: TaskContextRenderInput): Promise<TaskPromptContextSection>;
+    renderPromptContext(input: TaskContextRenderInput): Promise<TaskPromptContext>;
+}
+export declare const TASK_CONTEXT_RENDERER_CAPABILITY_ID = "provider.task-context-renderer";
+export declare const TASK_CONTEXT_RENDERER: CapabilityId<TaskContextRendererService>;

package/dist/src/task-context-renderer.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/task-context-renderer.ts
+var TASK_CONTEXT_RENDERER_CAPABILITY_ID = "provider.task-context-renderer";
+var TASK_CONTEXT_RENDERER = makeCapabilityId(TASK_CONTEXT_RENDERER_CAPABILITY_ID);
+export {
+  TASK_CONTEXT_RENDERER_CAPABILITY_ID,
+  TASK_CONTEXT_RENDERER
+};