@h-rig/contracts 0.0.6-alpha.131 → 0.0.6-alpha.133

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

@@ -533,8 +533,8 @@ export declare const decodeRunJournalEvent: (input: unknown, options?: import("e
     readonly runId: string & import("effect/Brand").Brand<"RunId">;
     readonly v: 1;
     readonly type: "status-changed";
-    readonly from: "running" | "completed" | "queued" | "failed" | "stopped" | "created" | "preparing" | "waiting-approval" | "waiting-user-input" | "paused" | "validating" | "reviewing" | "closing-out" | "needs-attention" | null;
-    readonly to: "running" | "completed" | "queued" | "failed" | "stopped" | "created" | "preparing" | "waiting-approval" | "waiting-user-input" | "paused" | "validating" | "reviewing" | "closing-out" | "needs-attention";
+    readonly from: "running" | "stopped" | "completed" | "created" | "queued" | "preparing" | "waiting-approval" | "waiting-user-input" | "paused" | "validating" | "reviewing" | "closing-out" | "needs-attention" | "failed" | null;
+    readonly to: "running" | "stopped" | "completed" | "created" | "queued" | "preparing" | "waiting-approval" | "waiting-user-input" | "paused" | "validating" | "reviewing" | "closing-out" | "needs-attention" | "failed";
     readonly seq: number;
     readonly reason?: string | null | undefined;
     readonly actor?: {
@@ -553,28 +553,28 @@ export declare const decodeRunJournalEvent: (input: unknown, options?: import("e
         readonly createdAt?: string | undefined;
         readonly title?: string | undefined;
         readonly mode?: "local" | "remote" | undefined;
-        readonly model?: string | null | undefined;
-        readonly planning?: unknown;
-        readonly updatedAt?: string | undefined;
-        readonly completedAt?: string | null | undefined;
         readonly startedAt?: string | null | undefined;
-        readonly workspaceId?: string | undefined;
+        readonly updatedAt?: string | undefined;
         readonly runtimeMode?: string | null | undefined;
         readonly threadId?: string | null | undefined;
+        readonly completedAt?: string | null | undefined;
         readonly interactionMode?: string | null | undefined;
         readonly branch?: string | null | undefined;
         readonly worktreePath?: string | null | undefined;
+        readonly model?: string | null | undefined;
         readonly runtimeAdapter?: "pi" | undefined;
         readonly initialPrompt?: string | null | undefined;
         readonly latestMessageId?: string | null | undefined;
         readonly errorText?: string | null | undefined;
+        readonly workspaceId?: string | undefined;
         readonly sessionLogPath?: string | null | undefined;
         readonly pid?: number | null | undefined;
+        readonly prUrl?: string | null | undefined;
+        readonly planning?: unknown;
         readonly endpointId?: string | null | undefined;
         readonly hostId?: string | null | undefined;
         readonly leaseId?: string | null | undefined;
         readonly runMode?: string | null | undefined;
-        readonly prUrl?: string | null | undefined;
         readonly artifactRoot?: string | null | undefined;
         readonly logRoot?: string | null | undefined;
         readonly sessionPath?: string | null | undefined;
@@ -582,17 +582,17 @@ export declare const decodeRunJournalEvent: (input: unknown, options?: import("e
         readonly piSessionPrivate?: unknown;
         readonly projectRoot?: string | null | undefined;
         readonly serverCloseout?: {
-            readonly status: "running" | "completed" | "failed" | "pending" | "needs-attention";
+            readonly status: "running" | "completed" | "pending" | "needs-attention" | "failed";
             readonly updatedAt: string;
-            readonly phase: "push" | "merge" | "completed" | "queued" | "commit" | "pr-review-merge" | "pr-opened" | "close-source";
+            readonly phase: "push" | "completed" | "queued" | "merge" | "commit" | "pr-review-merge" | "pr-opened" | "close-source";
             readonly taskId?: string | null | undefined;
-            readonly completedAt?: string | null | undefined;
-            readonly error?: string | null | undefined;
             readonly reason?: string | null | undefined;
+            readonly error?: string | null | undefined;
+            readonly completedAt?: string | null | undefined;
             readonly branch?: string | null | undefined;
+            readonly prUrl?: string | null | undefined;
             readonly merged?: boolean | undefined;
             readonly runtimeWorkspace?: string | null | undefined;
-            readonly prUrl?: string | null | undefined;
             readonly artifactRoot?: string | null | undefined;
             readonly iterations?: number | null | undefined;
             readonly feedback?: readonly string[] | undefined;
@@ -611,22 +611,22 @@ export declare const decodeRunJournalEvent: (input: unknown, options?: import("e
     readonly at: string;
     readonly runId: string & import("effect/Brand").Brand<"RunId">;
     readonly v: 1;
-    readonly payload: unknown;
     readonly type: "timeline-entry";
+    readonly payload: unknown;
     readonly seq: number;
 } | {
     readonly at: string;
     readonly runId: string & import("effect/Brand").Brand<"RunId">;
     readonly v: 1;
-    readonly payload: unknown;
     readonly type: "log-entry";
+    readonly payload: unknown;
     readonly seq: number;
 } | {
     readonly at: string;
     readonly runId: string & import("effect/Brand").Brand<"RunId">;
     readonly v: 1;
-    readonly payload: unknown;
     readonly type: "approval-requested";
+    readonly payload: unknown;
     readonly requestId: string;
     readonly requestKind: string;
     readonly seq: number;
@@ -635,9 +635,9 @@ export declare const decodeRunJournalEvent: (input: unknown, options?: import("e
     readonly at: string;
     readonly runId: string & import("effect/Brand").Brand<"RunId">;
     readonly v: 1;
-    readonly decision: "approve" | "reject";
     readonly type: "approval-resolved";
     readonly requestId: string;
+    readonly decision: "approve" | "reject";
     readonly actor: {
         readonly kind: "server" | "system" | "agent" | "operator";
         readonly id?: string | null | undefined;
@@ -648,8 +648,8 @@ export declare const decodeRunJournalEvent: (input: unknown, options?: import("e
     readonly at: string;
     readonly runId: string & import("effect/Brand").Brand<"RunId">;
     readonly v: 1;
-    readonly payload: unknown;
     readonly type: "input-requested";
+    readonly payload: unknown;
     readonly requestId: string;
     readonly seq: number;
 } | {
@@ -670,8 +670,8 @@ export declare const decodeRunJournalEvent: (input: unknown, options?: import("e
     readonly at: string;
     readonly runId: string & import("effect/Brand").Brand<"RunId">;
     readonly v: 1;
-    readonly text: string;
     readonly type: "steering";
+    readonly text: string;
     readonly actor: {
         readonly kind: "server" | "system" | "agent" | "operator";
         readonly id?: string | null | undefined;
@@ -697,7 +697,7 @@ export declare const decodeRunJournalEvent: (input: unknown, options?: import("e
     readonly runId: string & import("effect/Brand").Brand<"RunId">;
     readonly v: 1;
     readonly type: "closeout-phase";
-    readonly phase: "push" | "merge" | "completed" | "queued" | "commit" | "pr-review-merge" | "pr-opened" | "close-source";
+    readonly phase: "push" | "completed" | "queued" | "merge" | "commit" | "pr-review-merge" | "pr-opened" | "close-source";
     readonly seq: number;
     readonly outcome: "completed" | "failed" | "started";
     readonly detail?: string | null | undefined;
@@ -734,6 +734,7 @@ export type RunJournalResolvedInput = RunJournalPendingRequest & {
     resolvedAt: string;
 };
 export type RunJournalProjection = {
+    runId: string | null;
     record: Partial<RunJournalRecord>;
     status: RunStatus | null;
     statusHistory: ReadonlyArray<{
@@ -760,4 +761,4 @@ export type RunJournalProjection = {
     lastEventAt: string | null;
     anomalies: ReadonlyArray<RunJournalAnomaly>;
 };
-export declare function reduceRunJournal(events: ReadonlyArray<RunJournalEvent>): RunJournalProjection;
+export declare function reduceRunJournal(events: ReadonlyArray<RunJournalEvent>, runId?: string | null): RunJournalProjection;

package/dist/src/run-journal.js

@@ -1313,7 +1313,7 @@ function assertRunStatusTransition(from, to) {
     throw new Error(`Illegal run status transition: ${from ?? "(none)"} -> ${to}. ` + `Allowed from ${from ?? "(none)"}: ${from ? RUN_STATUS_TRANSITIONS[from].join(", ") : "(any)"}.`);
   }
 }
-function reduceRunJournal(events) {
+function reduceRunJournal(events, runId = null) {
   let record = {};
   let status = null;
   const statusHistory = [];
@@ -1327,6 +1327,7 @@ function reduceRunJournal(events) {
   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;
@@ -1460,6 +1461,7 @@ function reduceRunJournal(events) {
     }
   }
   return {
+    runId: projectedRunId,
     record,
     status,
     statusHistory,

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

@@ -1305,7 +1305,7 @@ function canTransitionRunStatus(from, to) {
     return true;
   return RUN_STATUS_TRANSITIONS[from].includes(to);
 }
-function reduceRunJournal(events) {
+function reduceRunJournal(events, runId = null) {
   let record = {};
   let status = null;
   const statusHistory = [];
@@ -1319,6 +1319,7 @@ function reduceRunJournal(events) {
   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;
@@ -1452,6 +1453,7 @@ function reduceRunJournal(events) {
     }
   }
   return {
+    runId: projectedRunId,
     record,
     status,
     statusHistory,
@@ -1634,7 +1636,7 @@ function foldRunSessionEntries(entries, runId) {
       events.push(decodeRunJournalEvent(stamped));
     } catch {}
   });
-  return reduceRunJournal(events);
+  return reduceRunJournal(events, runId);
 }
 export {
   sessionIdFromSessionFile,

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.Literals<readonly ["protected-stage", "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.Literals<readonly ["protected-stage", "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.Literals<readonly ["protected-stage", "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.Literals(["protected-stage", "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
+};