@h-rig/contracts 0.0.6-alpha.15 → 0.0.6-alpha.151

package/dist/src/runtime.d.ts

@@ -0,0 +1,103 @@
+import { Schema } from "effect";
+export declare const RunKind: Schema.Literals<readonly ["adhoc", "task", "batch", "validation", "review"]>;
+export type RunKind = typeof RunKind.Type;
+export declare const RunMode: Schema.Literals<readonly ["interactive", "autonomous", "supervised"]>;
+export type RunMode = typeof RunMode.Type;
+export declare const RunStatus: Schema.Literals<readonly ["created", "queued", "preparing", "running", "waiting-approval", "waiting-user-input", "paused", "validating", "reviewing", "closing-out", "needs-attention", "completed", "failed", "stopped"]>;
+export type RunStatus = typeof RunStatus.Type;
+export declare const EngineSandboxMode: Schema.Literals<readonly ["read-only", "workspace-write", "danger-full-access"]>;
+export type EngineSandboxMode = typeof EngineSandboxMode.Type;
+export declare const IsolationMode: Schema.Literals<readonly ["none", "env", "worktree"]>;
+export type IsolationMode = typeof IsolationMode.Type;
+export declare const RuntimeStatus: Schema.Literals<readonly ["prepared", "starting", "running", "interrupted", "exited", "failed", "destroyed"]>;
+export type RuntimeStatus = typeof RuntimeStatus.Type;
+export declare const RunExecutionTarget: Schema.Literals<readonly ["local", "remote"]>;
+export type RunExecutionTarget = typeof RunExecutionTarget.Type;
+export declare const RunSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "RunId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly title: Schema.Trim;
+    readonly runKind: Schema.Literals<readonly ["adhoc", "task", "batch", "validation", "review"]>;
+    readonly mode: Schema.Literals<readonly ["interactive", "autonomous", "supervised"]>;
+    readonly runtimeMode: Schema.Literals<readonly ["approval-required", "full-access"]>;
+    readonly interactionMode: Schema.Literals<readonly ["default", "plan"]>;
+    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 runtimeAdapter: Schema.Literal<"pi">;
+    readonly model: Schema.NullOr<Schema.Trim>;
+    readonly initialPrompt: Schema.NullOr<Schema.String>;
+    readonly executionTarget: Schema.optional<Schema.Literals<readonly ["local", "remote"]>>;
+    readonly remoteHostId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly remoteLeaseId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly remoteLeaseClaimedAt: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly activeRuntimeId: Schema.NullOr<Schema.brand<Schema.Trim, "EngineRuntimeId">>;
+    readonly latestMessageId: Schema.NullOr<Schema.Trim>;
+    readonly pendingApprovalCount: Schema.Int;
+    readonly pendingUserInputCount: Schema.Int;
+    readonly branch: Schema.NullOr<Schema.Trim>;
+    readonly worktreePath: Schema.NullOr<Schema.Trim>;
+    readonly errorText: Schema.NullOr<Schema.String>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly startedAt: Schema.NullOr<Schema.String>;
+    readonly completedAt: Schema.NullOr<Schema.String>;
+}>;
+export type RunSummary = typeof RunSummary.Type;
+export declare const RuntimeSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "EngineRuntimeId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly adapterKind: Schema.Literal<"pi">;
+    readonly executionTarget: Schema.optional<Schema.Literals<readonly ["local", "remote"]>>;
+    readonly remoteHostId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly status: Schema.Literals<readonly ["prepared", "starting", "running", "interrupted", "exited", "failed", "destroyed"]>;
+    readonly sandboxMode: Schema.Literals<readonly ["read-only", "workspace-write", "danger-full-access"]>;
+    readonly isolationMode: Schema.Literals<readonly ["none", "env", "worktree"]>;
+    readonly workspaceDir: Schema.NullOr<Schema.Trim>;
+    readonly homeDir: Schema.NullOr<Schema.Trim>;
+    readonly tmpDir: Schema.NullOr<Schema.Trim>;
+    readonly cacheDir: Schema.NullOr<Schema.Trim>;
+    readonly logsDir: Schema.NullOr<Schema.Trim>;
+    readonly stateDir: Schema.NullOr<Schema.Trim>;
+    readonly sessionDir: Schema.NullOr<Schema.Trim>;
+    readonly sessionLogPath: Schema.NullOr<Schema.Trim>;
+    readonly pid: Schema.NullOr<Schema.Int>;
+    readonly startedAt: Schema.NullOr<Schema.String>;
+    readonly updatedAt: Schema.String;
+    readonly exitedAt: Schema.NullOr<Schema.String>;
+}>;
+export type RuntimeSummary = typeof RuntimeSummary.Type;
+export declare const ApprovalStatus: Schema.Literals<readonly ["pending", "resolved"]>;
+export type ApprovalStatus = typeof ApprovalStatus.Type;
+export declare const ApprovalSummary: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly actionId: Schema.NullOr<Schema.Trim>;
+    readonly requestKind: Schema.Trim;
+    readonly status: Schema.Literals<readonly ["pending", "resolved"]>;
+    readonly payload: Schema.Unknown;
+    readonly createdAt: Schema.String;
+    readonly resolvedAt: Schema.NullOr<Schema.String>;
+}>;
+export type ApprovalSummary = typeof ApprovalSummary.Type;
+export declare const UserInputRequestSummary: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly status: Schema.Literals<readonly ["pending", "resolved"]>;
+    readonly payload: Schema.Unknown;
+    readonly createdAt: Schema.String;
+    readonly resolvedAt: Schema.NullOr<Schema.String>;
+}>;
+export type UserInputRequestSummary = typeof UserInputRequestSummary.Type;
+export declare const WorktreeSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "WorktreeId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly branchName: Schema.Trim;
+    readonly path: Schema.Trim;
+    readonly status: Schema.Trim;
+    readonly createdAt: Schema.String;
+    readonly cleanedAt: Schema.NullOr<Schema.String>;
+}>;
+export type WorktreeSummary = typeof WorktreeSummary.Type;

package/dist/src/runtime.js

@@ -16,6 +16,9 @@ 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");
@@ -921,12 +924,14 @@ var RunStatus = Schema4.Literals([
   "running",
   "waiting-approval",
   "waiting-user-input",
+  "paused",
   "validating",
   "reviewing",
+  "closing-out",
+  "needs-attention",
   "completed",
   "failed",
-  "cancelled",
-  "paused"
+  "stopped"
 ]);
 var EngineSandboxMode = Schema4.Literals([
   "read-only",
@@ -954,7 +959,7 @@ var RunSummary = Schema4.Struct({
   runtimeMode: RuntimeMode,
   interactionMode: ProviderInteractionMode,
   status: RunStatus,
-  runtimeAdapter: TrimmedNonEmptyString,
+  runtimeAdapter: Schema4.Literal("pi"),
   model: Schema4.NullOr(TrimmedNonEmptyString),
   initialPrompt: Schema4.NullOr(Schema4.String),
   executionTarget: Schema4.optional(RunExecutionTarget),
@@ -977,7 +982,7 @@ var RuntimeSummary = Schema4.Struct({
   id: EngineRuntimeId,
   workspaceId: WorkspaceId,
   runId: RunId,
-  adapterKind: TrimmedNonEmptyString,
+  adapterKind: Schema4.Literal("pi"),
   executionTarget: Schema4.optional(RunExecutionTarget),
   remoteHostId: Schema4.optional(Schema4.NullOr(TrimmedNonEmptyString)),
   status: RuntimeStatus,

package/dist/src/server.d.ts

@@ -0,0 +1,106 @@
+import { Schema } from "effect";
+export declare const ServerConfigIssue: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"keybindings.malformed-config">;
+    readonly message: Schema.Trim;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"keybindings.invalid-entry">;
+    readonly message: Schema.Trim;
+    readonly index: Schema.Number;
+}>]>;
+export type ServerConfigIssue = typeof ServerConfigIssue.Type;
+export declare const ServerProviderStatusState: Schema.Literals<readonly ["ready", "warning", "error"]>;
+export type ServerProviderStatusState = typeof ServerProviderStatusState.Type;
+export declare const ServerProviderAuthStatus: Schema.Literals<readonly ["authenticated", "unauthenticated", "unknown"]>;
+export type ServerProviderAuthStatus = typeof ServerProviderAuthStatus.Type;
+export declare const ServerProviderStatus: Schema.Struct<{
+    readonly provider: Schema.Literals<readonly ["codex", "claude"]>;
+    readonly status: Schema.Literals<readonly ["ready", "warning", "error"]>;
+    readonly available: Schema.Boolean;
+    readonly authStatus: Schema.Literals<readonly ["authenticated", "unauthenticated", "unknown"]>;
+    readonly checkedAt: Schema.String;
+    readonly message: Schema.optional<Schema.Trim>;
+}>;
+export type ServerProviderStatus = typeof ServerProviderStatus.Type;
+export declare const ServerConfig: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly rigRoot: Schema.NullOr<Schema.Trim>;
+    readonly keybindingsConfigPath: Schema.Trim;
+    readonly keybindings: Schema.$Array<Schema.Struct<{
+        readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+        readonly shortcut: Schema.Struct<{
+            readonly key: Schema.Trim;
+            readonly metaKey: Schema.Boolean;
+            readonly ctrlKey: Schema.Boolean;
+            readonly shiftKey: Schema.Boolean;
+            readonly altKey: Schema.Boolean;
+            readonly modKey: Schema.Boolean;
+        }>;
+        readonly whenAst: Schema.optional<Schema.Schema<import("./keybindings").KeybindingWhenNode>>;
+    }>>;
+    readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.malformed-config">;
+        readonly message: Schema.Trim;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.invalid-entry">;
+        readonly message: Schema.Trim;
+        readonly index: Schema.Number;
+    }>]>>;
+    readonly providers: Schema.$Array<Schema.Struct<{
+        readonly provider: Schema.Literals<readonly ["codex", "claude"]>;
+        readonly status: Schema.Literals<readonly ["ready", "warning", "error"]>;
+        readonly available: Schema.Boolean;
+        readonly authStatus: Schema.Literals<readonly ["authenticated", "unauthenticated", "unknown"]>;
+        readonly checkedAt: Schema.String;
+        readonly message: Schema.optional<Schema.Trim>;
+    }>>;
+    readonly availableEditors: Schema.$Array<Schema.Literals<("cursor" | "vscode" | "zed" | "file-manager")[]>>;
+}>;
+export type ServerConfig = typeof ServerConfig.Type;
+export declare const ServerUpsertKeybindingInput: Schema.Struct<{
+    readonly key: Schema.Trim;
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+    readonly when: Schema.optional<Schema.Trim>;
+}>;
+export type ServerUpsertKeybindingInput = typeof ServerUpsertKeybindingInput.Type;
+export declare const ServerUpsertKeybindingResult: Schema.Struct<{
+    readonly keybindings: Schema.$Array<Schema.Struct<{
+        readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+        readonly shortcut: Schema.Struct<{
+            readonly key: Schema.Trim;
+            readonly metaKey: Schema.Boolean;
+            readonly ctrlKey: Schema.Boolean;
+            readonly shiftKey: Schema.Boolean;
+            readonly altKey: Schema.Boolean;
+            readonly modKey: Schema.Boolean;
+        }>;
+        readonly whenAst: Schema.optional<Schema.Schema<import("./keybindings").KeybindingWhenNode>>;
+    }>>;
+    readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.malformed-config">;
+        readonly message: Schema.Trim;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.invalid-entry">;
+        readonly message: Schema.Trim;
+        readonly index: Schema.Number;
+    }>]>>;
+}>;
+export type ServerUpsertKeybindingResult = typeof ServerUpsertKeybindingResult.Type;
+export declare const ServerConfigUpdatedPayload: Schema.Struct<{
+    readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.malformed-config">;
+        readonly message: Schema.Trim;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.invalid-entry">;
+        readonly message: Schema.Trim;
+        readonly index: Schema.Number;
+    }>]>>;
+    readonly providers: Schema.$Array<Schema.Struct<{
+        readonly provider: Schema.Literals<readonly ["codex", "claude"]>;
+        readonly status: Schema.Literals<readonly ["ready", "warning", "error"]>;
+        readonly available: Schema.Boolean;
+        readonly authStatus: Schema.Literals<readonly ["authenticated", "unauthenticated", "unknown"]>;
+        readonly checkedAt: Schema.String;
+        readonly message: Schema.optional<Schema.Trim>;
+    }>>;
+}>;
+export type ServerConfigUpdatedPayload = typeof ServerConfigUpdatedPayload.Type;

package/dist/src/server.js

@@ -16,6 +16,9 @@ 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");

package/dist/src/serviceFabric.d.ts

@@ -0,0 +1,62 @@
+import { Schema } from "effect";
+export declare const ServiceFabricWorkspaceInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+}>;
+export type ServiceFabricWorkspaceInput = typeof ServiceFabricWorkspaceInput.Type;
+export declare const ServiceFabricUpInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly services: Schema.optional<Schema.$Array<Schema.Trim>>;
+}>;
+export type ServiceFabricUpInput = typeof ServiceFabricUpInput.Type;
+export declare const ServiceFabricUpResult: Schema.Struct<{
+    readonly plan: Schema.Struct<{
+        readonly generatedAt: Schema.String;
+        readonly serviceCount: Schema.Number;
+        readonly services: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.Trim;
+            readonly relativeRootPath: Schema.Trim;
+            readonly absoluteRootPath: Schema.Trim;
+            readonly port: Schema.Number;
+            readonly healthcheck: Schema.Trim;
+            readonly routePrefix: Schema.NullOr<Schema.Trim>;
+            readonly mode: Schema.Literals<readonly ["stub", "process"]>;
+            readonly command: Schema.NullOr<Schema.String>;
+            readonly environment: Schema.Unknown;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.String>;
+    }>;
+    readonly state: Schema.Struct<{
+        readonly generatedAt: Schema.String;
+        readonly rootPath: Schema.Trim;
+        readonly services: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.Trim;
+            readonly pid: Schema.Number;
+            readonly mode: Schema.Literals<readonly ["stub", "process"]>;
+            readonly port: Schema.Number;
+            readonly healthcheck: Schema.Trim;
+            readonly routePrefix: Schema.NullOr<Schema.Trim>;
+            readonly relativeRootPath: Schema.Trim;
+            readonly logPath: Schema.Trim;
+        }>>;
+    }>;
+    readonly summary: Schema.Struct<{
+        readonly updatedAt: Schema.String;
+        readonly status: Schema.Literals<readonly ["empty", "booting", "ready", "degraded", "stopped"]>;
+        readonly serviceCount: Schema.Number;
+        readonly healthyServiceCount: Schema.Number;
+        readonly stateDir: Schema.Trim;
+        readonly services: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.Trim;
+            readonly relativeRootPath: Schema.Trim;
+            readonly mode: Schema.Literals<readonly ["stub", "process"]>;
+            readonly port: Schema.Number;
+            readonly healthcheck: Schema.Trim;
+            readonly routePrefix: Schema.NullOr<Schema.Trim>;
+            readonly status: Schema.Literals<readonly ["planned", "booting", "healthy", "degraded", "failed", "stopped"]>;
+            readonly pid: Schema.NullOr<Schema.Number>;
+            readonly logPath: Schema.NullOr<Schema.Trim>;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.String>;
+    }>;
+}>;
+export type ServiceFabricUpResult = typeof ServiceFabricUpResult.Type;

package/dist/src/serviceFabric.js

@@ -16,6 +16,9 @@ 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");
@@ -967,7 +970,7 @@ var WorkspaceRemoteHostSummary = Schema4.Struct({
   region: Schema4.NullOr(TrimmedNonEmptyString),
   labels: Schema4.Array(TrimmedNonEmptyString),
   capabilities: Schema4.Array(TrimmedNonEmptyString),
-  runtimeAdapters: Schema4.Array(TrimmedNonEmptyString),
+  runtimeAdapters: Schema4.Array(Schema4.Literal("pi")),
   status: WorkspaceRemoteHostStatus,
   currentLeaseCount: Schema4.Number,
   lastHeartbeatAt: Schema4.NullOr(IsoDateTime),
@@ -1008,7 +1011,7 @@ var WorkspaceSummary = Schema4.Struct({
   title: TrimmedNonEmptyString,
   rootPath: TrimmedNonEmptyString,
   sourceKind: WorkspaceSourceKind,
-  defaultRuntimeAdapter: Schema4.optional(TrimmedNonEmptyString),
+  defaultRuntimeAdapter: Schema4.optional(Schema4.Literal("pi")),
   defaultProvider: Schema4.optional(ProviderKind),
   defaultModel: Schema4.NullOr(TrimmedNonEmptyString),
   topology: Schema4.optional(WorkspaceTopologySummary),

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;