@h-rig/contracts 0.0.0-e2e-live.20260630085347

package/dist/src/stage.d.ts

@@ -0,0 +1,245 @@
+import { Schema } from "effect";
+export declare const StageKind: Schema.Literals<readonly ["transform", "gate", "observe"]>;
+export type StageKind = typeof StageKind.Type;
+export declare const StageId: Schema.brand<Schema.Trim, "StageId">;
+export type StageId = typeof StageId.Type;
+export declare const StageContext: Schema.Struct<{
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.optional<Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>>;
+    readonly state: Schema.Unknown;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>;
+export type StageContext = typeof StageContext.Type;
+export declare const StageDescriptor: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly kind: Schema.Literals<readonly ["transform", "gate", "observe"]>;
+    readonly before: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly priority: Schema.withDecodingDefault<Schema.Number>;
+    readonly protected: Schema.withDecodingDefault<Schema.Boolean>;
+}>;
+export type StageDescriptor = typeof StageDescriptor.Type;
+export declare const Stage: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly kind: Schema.Literals<readonly ["transform", "gate", "observe"]>;
+    readonly before: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly priority: Schema.withDecodingDefault<Schema.Number>;
+    readonly protected: Schema.withDecodingDefault<Schema.Boolean>;
+}>;
+export type Stage = typeof Stage.Type;
+export declare const StageContinueResult: Schema.Struct<{
+    readonly kind: Schema.Literal<"continue">;
+    readonly ctx: Schema.Struct<{
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly taskId: Schema.optional<Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>>;
+        readonly state: Schema.Unknown;
+        readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>;
+}>;
+export type StageContinueResult = typeof StageContinueResult.Type;
+export declare const StageAllowResult: Schema.Struct<{
+    readonly kind: Schema.Literal<"allow">;
+}>;
+export type StageAllowResult = typeof StageAllowResult.Type;
+export declare const StageBlockResult: Schema.Struct<{
+    readonly kind: Schema.Literal<"block">;
+    readonly reason: Schema.Trim;
+}>;
+export type StageBlockResult = typeof StageBlockResult.Type;
+export declare const StageResult: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"continue">;
+    readonly ctx: Schema.Struct<{
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly taskId: Schema.optional<Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>>;
+        readonly state: Schema.Unknown;
+        readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"allow">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"block">;
+    readonly reason: Schema.Trim;
+}>]>;
+export type StageResult = typeof StageResult.Type;
+export type StageRun = (ctx: StageContext) => Promise<StageResult> | StageResult;
+export declare const StageWrapperDescriptor: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly priority: Schema.withDecodingDefault<Schema.Number>;
+}>;
+export type StageWrapperDescriptor = typeof StageWrapperDescriptor.Type;
+export type StageWrapper = (next: StageRun, ctx: StageContext) => Promise<StageResult> | StageResult;
+export declare const StageMutationOp: Schema.Literals<readonly ["insert", "remove", "replace", "wrap", "reorder"]>;
+export type StageMutationOp = typeof StageMutationOp.Type;
+export declare const InsertStageMutation: Schema.Struct<{
+    readonly op: Schema.Literal<"insert">;
+    readonly stage: Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "StageId">;
+        readonly kind: Schema.Literals<readonly ["transform", "gate", "observe"]>;
+        readonly before: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly priority: Schema.withDecodingDefault<Schema.Number>;
+        readonly protected: Schema.withDecodingDefault<Schema.Boolean>;
+    }>;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>;
+export type InsertStageMutation = typeof InsertStageMutation.Type;
+export declare const RemoveStageMutation: Schema.Struct<{
+    readonly op: Schema.Literal<"remove">;
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>;
+export type RemoveStageMutation = typeof RemoveStageMutation.Type;
+export declare const ReplaceStageMutation: Schema.Struct<{
+    readonly op: Schema.Literal<"replace">;
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly stage: Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "StageId">;
+        readonly kind: Schema.Literals<readonly ["transform", "gate", "observe"]>;
+        readonly before: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly priority: Schema.withDecodingDefault<Schema.Number>;
+        readonly protected: Schema.withDecodingDefault<Schema.Boolean>;
+    }>;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>;
+export type ReplaceStageMutation = typeof ReplaceStageMutation.Type;
+export declare const WrapStageMutation: Schema.Struct<{
+    readonly op: Schema.Literal<"wrap">;
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly around: Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly priority: Schema.withDecodingDefault<Schema.Number>;
+    }>;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>;
+export type WrapStageMutation = typeof WrapStageMutation.Type;
+export declare const ReorderStageMutation: Schema.Struct<{
+    readonly op: Schema.Literal<"reorder">;
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly before: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>;
+export type ReorderStageMutation = typeof ReorderStageMutation.Type;
+export declare const StageMutation: Schema.Union<readonly [Schema.Struct<{
+    readonly op: Schema.Literal<"insert">;
+    readonly stage: Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "StageId">;
+        readonly kind: Schema.Literals<readonly ["transform", "gate", "observe"]>;
+        readonly before: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly priority: Schema.withDecodingDefault<Schema.Number>;
+        readonly protected: Schema.withDecodingDefault<Schema.Boolean>;
+    }>;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>, Schema.Struct<{
+    readonly op: Schema.Literal<"remove">;
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>, Schema.Struct<{
+    readonly op: Schema.Literal<"replace">;
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly stage: Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "StageId">;
+        readonly kind: Schema.Literals<readonly ["transform", "gate", "observe"]>;
+        readonly before: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly priority: Schema.withDecodingDefault<Schema.Number>;
+        readonly protected: Schema.withDecodingDefault<Schema.Boolean>;
+    }>;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>, Schema.Struct<{
+    readonly op: Schema.Literal<"wrap">;
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly around: Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly priority: Schema.withDecodingDefault<Schema.Number>;
+    }>;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>, Schema.Struct<{
+    readonly op: Schema.Literal<"reorder">;
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly before: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>]>;
+export type StageMutation = typeof StageMutation.Type;
+export declare const ResolutionGrantUse: Schema.Struct<{
+    readonly kind: Schema.Literal<"kernel-replacement">;
+    readonly target: Schema.Trim;
+    readonly pluginId: Schema.Trim;
+}>;
+export type ResolutionGrantUse = typeof ResolutionGrantUse.Type;
+export declare const ResolutionRecordEntry: Schema.Struct<{
+    readonly stageId: Schema.brand<Schema.Trim, "StageId">;
+    readonly contributedBy: Schema.Trim;
+    readonly removedBy: Schema.optional<Schema.Trim>;
+    readonly replacedBy: Schema.optional<Schema.Trim>;
+    readonly wrappedBy: Schema.optional<Schema.$Array<Schema.Trim>>;
+    readonly droppedAnchors: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly isProtected: Schema.Boolean;
+}>;
+export type ResolutionRecordEntry = typeof ResolutionRecordEntry.Type;
+export declare const ResolvedPipeline: Schema.Struct<{
+    readonly runId: Schema.optional<Schema.brand<Schema.Trim, "RunId">>;
+    readonly order: Schema.$Array<Schema.brand<Schema.Trim, "StageId">>;
+    readonly record: Schema.$Array<Schema.Struct<{
+        readonly stageId: Schema.brand<Schema.Trim, "StageId">;
+        readonly contributedBy: Schema.Trim;
+        readonly removedBy: Schema.optional<Schema.Trim>;
+        readonly replacedBy: Schema.optional<Schema.Trim>;
+        readonly wrappedBy: Schema.optional<Schema.$Array<Schema.Trim>>;
+        readonly droppedAnchors: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly isProtected: Schema.Boolean;
+    }>>;
+    readonly cycles: Schema.$Array<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly grantUses: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literal<"kernel-replacement">;
+        readonly target: Schema.Trim;
+        readonly pluginId: Schema.Trim;
+    }>>>;
+    readonly resolvedAt: Schema.optional<Schema.String>;
+}>;
+export type ResolvedPipeline = typeof ResolvedPipeline.Type;
+export declare const ResolutionRecord: Schema.Struct<{
+    readonly runId: Schema.optional<Schema.brand<Schema.Trim, "RunId">>;
+    readonly order: Schema.$Array<Schema.brand<Schema.Trim, "StageId">>;
+    readonly record: Schema.$Array<Schema.Struct<{
+        readonly stageId: Schema.brand<Schema.Trim, "StageId">;
+        readonly contributedBy: Schema.Trim;
+        readonly removedBy: Schema.optional<Schema.Trim>;
+        readonly replacedBy: Schema.optional<Schema.Trim>;
+        readonly wrappedBy: Schema.optional<Schema.$Array<Schema.Trim>>;
+        readonly droppedAnchors: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly isProtected: Schema.Boolean;
+    }>>;
+    readonly cycles: Schema.$Array<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly grantUses: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literal<"kernel-replacement">;
+        readonly target: Schema.Trim;
+        readonly pluginId: Schema.Trim;
+    }>>>;
+    readonly resolvedAt: Schema.optional<Schema.String>;
+}>;
+export type ResolutionRecord = typeof ResolutionRecord.Type;
+export declare const StageRunOutcome: Schema.Struct<{
+    readonly stageId: Schema.brand<Schema.Trim, "StageId">;
+    readonly result: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"continue">;
+        readonly ctx: Schema.Struct<{
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly taskId: Schema.optional<Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>>;
+            readonly state: Schema.Unknown;
+            readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"allow">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"block">;
+        readonly reason: Schema.Trim;
+    }>]>;
+    readonly startedAt: Schema.String;
+    readonly finishedAt: Schema.String;
+}>;
+export type StageRunOutcome = typeof StageRunOutcome.Type;

package/dist/src/stage.js

@@ -0,0 +1,169 @@
+// @bun
+// packages/contracts/src/stage.ts
+import { Schema as Schema2 } 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/stage.ts
+var StageKind = Schema2.Literals(["transform", "gate", "observe"]);
+var StageId = TrimmedNonEmptyString.pipe(Schema2.brand("StageId"));
+var StageContext = Schema2.Struct({
+  runId: RunId,
+  taskId: Schema2.optional(Schema2.NullOr(TaskId)),
+  state: Schema2.Unknown,
+  metadata: Schema2.optional(Schema2.Record(Schema2.String, Schema2.Unknown))
+});
+var StageDescriptor = Schema2.Struct({
+  id: StageId,
+  kind: StageKind,
+  before: Schema2.optional(Schema2.Array(StageId)),
+  after: Schema2.optional(Schema2.Array(StageId)),
+  priority: Schema2.Number.pipe(Schema2.withDecodingDefault(() => 0)),
+  protected: Schema2.Boolean.pipe(Schema2.withDecodingDefault(() => false))
+});
+var Stage = StageDescriptor;
+var StageContinueResult = Schema2.Struct({
+  kind: Schema2.Literal("continue"),
+  ctx: StageContext
+});
+var StageAllowResult = Schema2.Struct({
+  kind: Schema2.Literal("allow")
+});
+var StageBlockResult = Schema2.Struct({
+  kind: Schema2.Literal("block"),
+  reason: TrimmedNonEmptyString
+});
+var StageResult = Schema2.Union([
+  StageContinueResult,
+  StageAllowResult,
+  StageBlockResult
+]);
+var StageWrapperDescriptor = Schema2.Struct({
+  id: TrimmedNonEmptyString,
+  priority: Schema2.Number.pipe(Schema2.withDecodingDefault(() => 0))
+});
+var StageMutationOp = Schema2.Literals(["insert", "remove", "replace", "wrap", "reorder"]);
+var InsertStageMutation = Schema2.Struct({
+  op: Schema2.Literal("insert"),
+  stage: StageDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var RemoveStageMutation = Schema2.Struct({
+  op: Schema2.Literal("remove"),
+  id: StageId,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var ReplaceStageMutation = Schema2.Struct({
+  op: Schema2.Literal("replace"),
+  id: StageId,
+  stage: StageDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var WrapStageMutation = Schema2.Struct({
+  op: Schema2.Literal("wrap"),
+  id: StageId,
+  around: StageWrapperDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var ReorderStageMutation = Schema2.Struct({
+  op: Schema2.Literal("reorder"),
+  id: StageId,
+  before: Schema2.optional(Schema2.Array(StageId)),
+  after: Schema2.optional(Schema2.Array(StageId)),
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var StageMutation = Schema2.Union([
+  InsertStageMutation,
+  RemoveStageMutation,
+  ReplaceStageMutation,
+  WrapStageMutation,
+  ReorderStageMutation
+]);
+var ResolutionGrantUse = Schema2.Struct({
+  kind: Schema2.Literal("kernel-replacement"),
+  target: TrimmedNonEmptyString,
+  pluginId: TrimmedNonEmptyString
+});
+var ResolutionRecordEntry = Schema2.Struct({
+  stageId: StageId,
+  contributedBy: TrimmedNonEmptyString,
+  removedBy: Schema2.optional(TrimmedNonEmptyString),
+  replacedBy: Schema2.optional(TrimmedNonEmptyString),
+  wrappedBy: Schema2.optional(Schema2.Array(TrimmedNonEmptyString)),
+  droppedAnchors: Schema2.optional(Schema2.Array(StageId)),
+  isProtected: Schema2.Boolean
+});
+var ResolvedPipeline = Schema2.Struct({
+  runId: Schema2.optional(RunId),
+  order: Schema2.Array(StageId),
+  record: Schema2.Array(ResolutionRecordEntry),
+  cycles: Schema2.Array(Schema2.Array(StageId)),
+  grantUses: Schema2.optional(Schema2.Array(ResolutionGrantUse)),
+  resolvedAt: Schema2.optional(IsoDateTime)
+});
+var ResolutionRecord = ResolvedPipeline;
+var StageRunOutcome = Schema2.Struct({
+  stageId: StageId,
+  result: StageResult,
+  startedAt: IsoDateTime,
+  finishedAt: IsoDateTime
+});
+export {
+  WrapStageMutation,
+  StageWrapperDescriptor,
+  StageRunOutcome,
+  StageResult,
+  StageMutationOp,
+  StageMutation,
+  StageKind,
+  StageId,
+  StageDescriptor,
+  StageContinueResult,
+  StageContext,
+  StageBlockResult,
+  StageAllowResult,
+  Stage,
+  ResolvedPipeline,
+  ResolutionRecordEntry,
+  ResolutionRecord,
+  ResolutionGrantUse,
+  ReplaceStageMutation,
+  ReorderStageMutation,
+  RemoveStageMutation,
+  InsertStageMutation
+};

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", "blocked", "work-pending", "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", "blocked", "work-pending", "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", "blocked", "work-pending", "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", "blocked", "work-pending", "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", "blocked", "work-pending", "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", "blocked", "work-pending", "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", "blocked", "work-pending", "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", "blocked", "work-pending", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>>;
+    readonly stopReason: Schema.NullOr<Schema.Literals<readonly ["all-done", "all-human-blocked", "blocked", "work-pending", "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;