@h-rig/contracts 0.0.6-alpha.135 → 0.0.6-alpha.137

package/dist/src/kernel.d.ts

@@ -44,14 +44,6 @@ export declare const LoadedPluginDescriptor: Schema.Struct<{
     readonly runtime: Schema.Unknown;
 }>;
 export type LoadedPluginDescriptor = typeof LoadedPluginDescriptor.Type;
-export declare const ProtectedStageGrant: Schema.Struct<{
-    readonly stageId: Schema.Trim;
-    readonly pluginId: Schema.Trim;
-    readonly operations: Schema.$Array<Schema.Literals<readonly ["remove", "replace"]>>;
-    readonly grantedBy: Schema.optional<Schema.Trim>;
-    readonly reason: Schema.optional<Schema.String>;
-}>;
-export type ProtectedStageGrant = typeof ProtectedStageGrant.Type;
 export declare const KernelReplacementGrant: Schema.Struct<{
     readonly pluginId: Schema.Trim;
     readonly grantedBy: Schema.optional<Schema.Trim>;
@@ -60,13 +52,6 @@ export declare const KernelReplacementGrant: Schema.Struct<{
 export type KernelReplacementGrant = typeof KernelReplacementGrant.Type;
 export declare const CapabilityGrants: Schema.Struct<{
     readonly capabilityPrecedence: Schema.optional<Schema.$Record<Schema.String, Schema.$Array<Schema.Trim>>>;
-    readonly protectedStageGrants: Schema.optional<Schema.$Array<Schema.Struct<{
-        readonly stageId: Schema.Trim;
-        readonly pluginId: Schema.Trim;
-        readonly operations: Schema.$Array<Schema.Literals<readonly ["remove", "replace"]>>;
-        readonly grantedBy: Schema.optional<Schema.Trim>;
-        readonly reason: Schema.optional<Schema.String>;
-    }>>>;
     readonly kernelReplacementGrants: Schema.optional<Schema.$Array<Schema.Struct<{
         readonly pluginId: Schema.Trim;
         readonly grantedBy: Schema.optional<Schema.Trim>;
@@ -74,10 +59,10 @@ export declare const CapabilityGrants: Schema.Struct<{
     }>>>;
 }>;
 export type CapabilityGrants = typeof CapabilityGrants.Type;
-export declare const KernelBootErrorCode: Schema.Literals<readonly ["BootIncoherent", "AmbiguousCapability", "MissingCapability", "ProtectedStageViolation", "KernelReplacementDenied", "PipelineUnresolvable"]>;
+export declare const KernelBootErrorCode: Schema.Literals<readonly ["BootIncoherent", "AmbiguousCapability", "MissingCapability", "KernelReplacementDenied", "PipelineUnresolvable"]>;
 export type KernelBootErrorCode = typeof KernelBootErrorCode.Type;
 export declare const KernelBootError: Schema.Struct<{
-    readonly code: Schema.Literals<readonly ["BootIncoherent", "AmbiguousCapability", "MissingCapability", "ProtectedStageViolation", "KernelReplacementDenied", "PipelineUnresolvable"]>;
+    readonly code: Schema.Literals<readonly ["BootIncoherent", "AmbiguousCapability", "MissingCapability", "KernelReplacementDenied", "PipelineUnresolvable"]>;
     readonly message: Schema.Trim;
     readonly capability: Schema.optional<Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>>;
     readonly stageId: Schema.optional<Schema.Trim>;
@@ -93,9 +78,6 @@ export declare class AmbiguousCapability extends Error {
 export declare class MissingCapability extends Error {
     readonly code = "MissingCapability";
 }
-export declare class ProtectedStageViolation extends Error {
-    readonly code = "ProtectedStageViolation";
-}
 export declare class KernelReplacementDenied extends Error {
     readonly code = "KernelReplacementDenied";
 }
@@ -145,7 +127,7 @@ export declare const KernelResolutionRecord: Schema.Struct<{
         }>>;
         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 kind: Schema.Literal<"kernel-replacement">;
             readonly target: Schema.Trim;
             readonly pluginId: Schema.Trim;
         }>>>;
@@ -184,7 +166,7 @@ export declare const BootResultDescriptor: Schema.Struct<{
             }>>;
             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 kind: Schema.Literal<"kernel-replacement">;
                 readonly target: Schema.Trim;
                 readonly pluginId: Schema.Trim;
             }>>>;
@@ -234,5 +216,6 @@ export interface KernelCapability {
 export interface BootResult {
     kernel: KernelCapability;
     plugins: readonly LoadedPlugin[];
+    capabilityProviderIds: Readonly<Record<CapabilityTag, string>>;
 }
 export type StageExecutor = (ctx: StageContext) => Promise<StageResult> | StageResult;

package/dist/src/kernel.js

@@ -115,7 +115,7 @@ var StageMutation = Schema2.Union([
   ReorderStageMutation
 ]);
 var ResolutionGrantUse = Schema2.Struct({
-  kind: Schema2.Literals(["protected-stage", "kernel-replacement"]),
+  kind: Schema2.Literal("kernel-replacement"),
   target: TrimmedNonEmptyString,
   pluginId: TrimmedNonEmptyString
 });
@@ -176,13 +176,6 @@ var LoadedPluginDescriptor = Schema3.Struct({
   contributes: Schema3.Unknown,
   runtime: Schema3.Unknown
 });
-var ProtectedStageGrant = Schema3.Struct({
-  stageId: TrimmedNonEmptyString,
-  pluginId: TrimmedNonEmptyString,
-  operations: Schema3.Array(Schema3.Literals(["remove", "replace"])),
-  grantedBy: Schema3.optional(TrimmedNonEmptyString),
-  reason: Schema3.optional(Schema3.String)
-});
 var KernelReplacementGrant = Schema3.Struct({
   pluginId: TrimmedNonEmptyString,
   grantedBy: Schema3.optional(TrimmedNonEmptyString),
@@ -190,14 +183,12 @@ var KernelReplacementGrant = Schema3.Struct({
 });
 var CapabilityGrants = Schema3.Struct({
   capabilityPrecedence: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Array(TrimmedNonEmptyString))),
-  protectedStageGrants: Schema3.optional(Schema3.Array(ProtectedStageGrant)),
   kernelReplacementGrants: Schema3.optional(Schema3.Array(KernelReplacementGrant))
 });
 var KernelBootErrorCode = Schema3.Literals([
   "BootIncoherent",
   "AmbiguousCapability",
   "MissingCapability",
-  "ProtectedStageViolation",
   "KernelReplacementDenied",
   "PipelineUnresolvable"
 ]);
@@ -221,10 +212,6 @@ class MissingCapability extends Error {
   code = "MissingCapability";
 }
 
-class ProtectedStageViolation extends Error {
-  code = "ProtectedStageViolation";
-}
-
 class KernelReplacementDenied extends Error {
   code = "KernelReplacementDenied";
 }
@@ -259,8 +246,6 @@ var JournalEvent = Schema3.Struct({
   payload: Schema3.Unknown
 });
 export {
-  ProtectedStageViolation,
-  ProtectedStageGrant,
   PluginMeta,
   PipelineUnresolvable,
   MissingCapability,

package/dist/src/plugin-hooks.js

@@ -63,6 +63,7 @@ var StageDescriptor = Schema2.Struct({
   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
@@ -121,7 +122,7 @@ var StageMutation = Schema2.Union([
   ReorderStageMutation
 ]);
 var ResolutionGrantUse = Schema2.Struct({
-  kind: Schema2.Literals(["protected-stage", "kernel-replacement"]),
+  kind: Schema2.Literal("kernel-replacement"),
   target: TrimmedNonEmptyString,
   pluginId: TrimmedNonEmptyString
 });
@@ -182,13 +183,6 @@ var LoadedPluginDescriptor = Schema3.Struct({
   contributes: Schema3.Unknown,
   runtime: Schema3.Unknown
 });
-var ProtectedStageGrant = Schema3.Struct({
-  stageId: TrimmedNonEmptyString,
-  pluginId: TrimmedNonEmptyString,
-  operations: Schema3.Array(Schema3.Literals(["remove", "replace"])),
-  grantedBy: Schema3.optional(TrimmedNonEmptyString),
-  reason: Schema3.optional(Schema3.String)
-});
 var KernelReplacementGrant = Schema3.Struct({
   pluginId: TrimmedNonEmptyString,
   grantedBy: Schema3.optional(TrimmedNonEmptyString),
@@ -196,14 +190,12 @@ var KernelReplacementGrant = Schema3.Struct({
 });
 var CapabilityGrants = Schema3.Struct({
   capabilityPrecedence: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Array(TrimmedNonEmptyString))),
-  protectedStageGrants: Schema3.optional(Schema3.Array(ProtectedStageGrant)),
   kernelReplacementGrants: Schema3.optional(Schema3.Array(KernelReplacementGrant))
 });
 var KernelBootErrorCode = Schema3.Literals([
   "BootIncoherent",
   "AmbiguousCapability",
   "MissingCapability",
-  "ProtectedStageViolation",
   "KernelReplacementDenied",
   "PipelineUnresolvable"
 ]);
@@ -307,9 +299,34 @@ var TaskSourceRegistration = Schema4.Struct({
 });
 var CliCommandRegistration = Schema4.Struct({
   id: Schema4.String,
-  command: Schema4.String,
+  family: Schema4.optional(Schema4.String),
+  command: Schema4.optional(Schema4.String),
+  description: Schema4.optional(Schema4.String),
+  usage: Schema4.optional(Schema4.String),
+  aliases: Schema4.optional(Schema4.Array(Schema4.String)),
+  projectRequired: Schema4.optional(Schema4.Boolean)
+});
+var ProductCapabilityRegistration = Schema4.Struct({
+  id: Schema4.String,
+  title: Schema4.String,
+  description: Schema4.optional(Schema4.String),
+  commandId: Schema4.optional(Schema4.String),
+  panelId: Schema4.optional(Schema4.String)
+});
+var PanelRegistration = Schema4.Struct({
+  id: Schema4.String,
+  slot: Schema4.String,
+  title: Schema4.String,
+  capabilityId: Schema4.optional(Schema4.String),
+  badge: Schema4.optional(Schema4.String),
+  disabled: Schema4.optional(Schema4.Boolean),
   description: Schema4.optional(Schema4.String)
 });
+var BlockerClassifierRegistration = Schema4.Struct({
+  id: Schema4.String,
+  description: Schema4.optional(Schema4.String),
+  priority: Schema4.optional(Schema4.Number)
+});
 var PluginContributes = Schema4.Struct({
   validators: Schema4.optional(Schema4.Array(ValidatorRegistration)),
   hooks: Schema4.optional(Schema4.Array(HookRegistration)),
@@ -319,7 +336,11 @@ var PluginContributes = Schema4.Struct({
   taskFieldSchemas: Schema4.optional(Schema4.Array(TaskFieldExtension)),
   taskSources: Schema4.optional(Schema4.Array(TaskSourceRegistration)),
   cliCommands: Schema4.optional(Schema4.Array(CliCommandRegistration)),
-  stageMutations: Schema4.optional(Schema4.Array(StageMutation))
+  stages: Schema4.optional(Schema4.Array(Stage)),
+  stageMutations: Schema4.optional(Schema4.Array(StageMutation)),
+  capabilities: Schema4.optional(Schema4.Array(ProductCapabilityRegistration)),
+  panels: Schema4.optional(Schema4.Array(PanelRegistration)),
+  blockerClassifiers: Schema4.optional(Schema4.Array(BlockerClassifierRegistration))
 });
 var RigPlugin = Schema4.Struct({
   name: Schema4.String,

package/dist/src/plugin.d.ts

@@ -86,10 +86,38 @@ export declare const TaskSourceRegistration: Schema.Struct<{
 export type TaskSourceRegistration = typeof TaskSourceRegistration.Type;
 export declare const CliCommandRegistration: Schema.Struct<{
     readonly id: Schema.String;
-    readonly command: Schema.String;
+    readonly family: Schema.optional<Schema.String>;
+    readonly command: Schema.optional<Schema.String>;
     readonly description: Schema.optional<Schema.String>;
+    readonly usage: Schema.optional<Schema.String>;
+    readonly aliases: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly projectRequired: Schema.optional<Schema.Boolean>;
 }>;
 export type CliCommandRegistration = typeof CliCommandRegistration.Type;
+export declare const ProductCapabilityRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly title: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly commandId: Schema.optional<Schema.String>;
+    readonly panelId: Schema.optional<Schema.String>;
+}>;
+export type ProductCapabilityRegistration = typeof ProductCapabilityRegistration.Type;
+export declare const PanelRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly slot: Schema.String;
+    readonly title: Schema.String;
+    readonly capabilityId: Schema.optional<Schema.String>;
+    readonly badge: Schema.optional<Schema.String>;
+    readonly disabled: Schema.optional<Schema.Boolean>;
+    readonly description: Schema.optional<Schema.String>;
+}>;
+export type PanelRegistration = typeof PanelRegistration.Type;
+export declare const BlockerClassifierRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly priority: Schema.optional<Schema.Number>;
+}>;
+export type BlockerClassifierRegistration = typeof BlockerClassifierRegistration.Type;
 export declare const PluginContributes: Schema.Struct<{
     readonly validators: Schema.optional<Schema.$Array<Schema.Struct<{
         readonly id: Schema.String;
@@ -153,8 +181,20 @@ export declare const PluginContributes: Schema.Struct<{
     }>>>;
     readonly cliCommands: Schema.optional<Schema.$Array<Schema.Struct<{
         readonly id: Schema.String;
-        readonly command: Schema.String;
+        readonly family: Schema.optional<Schema.String>;
+        readonly command: Schema.optional<Schema.String>;
         readonly description: Schema.optional<Schema.String>;
+        readonly usage: Schema.optional<Schema.String>;
+        readonly aliases: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly projectRequired: Schema.optional<Schema.Boolean>;
+    }>>>;
+    readonly stages: Schema.optional<Schema.$Array<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 stageMutations: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
         readonly op: Schema.Literal<"insert">;
@@ -198,6 +238,27 @@ export declare const PluginContributes: Schema.Struct<{
         readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
         readonly contributedBy: Schema.optional<Schema.Trim>;
     }>]>>>;
+    readonly capabilities: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly title: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+        readonly commandId: Schema.optional<Schema.String>;
+        readonly panelId: Schema.optional<Schema.String>;
+    }>>>;
+    readonly panels: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly slot: Schema.String;
+        readonly title: Schema.String;
+        readonly capabilityId: Schema.optional<Schema.String>;
+        readonly badge: Schema.optional<Schema.String>;
+        readonly disabled: Schema.optional<Schema.Boolean>;
+        readonly description: Schema.optional<Schema.String>;
+    }>>>;
+    readonly blockerClassifiers: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+        readonly priority: Schema.optional<Schema.Number>;
+    }>>>;
 }>;
 export type PluginContributes = typeof PluginContributes.Type;
 export declare const RigPlugin: Schema.Struct<{
@@ -272,8 +333,20 @@ export declare const RigPlugin: Schema.Struct<{
         }>>>;
         readonly cliCommands: Schema.optional<Schema.$Array<Schema.Struct<{
             readonly id: Schema.String;
-            readonly command: Schema.String;
+            readonly family: Schema.optional<Schema.String>;
+            readonly command: Schema.optional<Schema.String>;
             readonly description: Schema.optional<Schema.String>;
+            readonly usage: Schema.optional<Schema.String>;
+            readonly aliases: Schema.optional<Schema.$Array<Schema.String>>;
+            readonly projectRequired: Schema.optional<Schema.Boolean>;
+        }>>>;
+        readonly stages: Schema.optional<Schema.$Array<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 stageMutations: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
             readonly op: Schema.Literal<"insert">;
@@ -317,6 +390,27 @@ export declare const RigPlugin: Schema.Struct<{
             readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
             readonly contributedBy: Schema.optional<Schema.Trim>;
         }>]>>>;
+        readonly capabilities: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly title: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly commandId: Schema.optional<Schema.String>;
+            readonly panelId: Schema.optional<Schema.String>;
+        }>>>;
+        readonly panels: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly slot: Schema.String;
+            readonly title: Schema.String;
+            readonly capabilityId: Schema.optional<Schema.String>;
+            readonly badge: Schema.optional<Schema.String>;
+            readonly disabled: Schema.optional<Schema.Boolean>;
+            readonly description: Schema.optional<Schema.String>;
+        }>>>;
+        readonly blockerClassifiers: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+            readonly priority: Schema.optional<Schema.Number>;
+        }>>>;
     }>>;
 }>;
 export type RigPlugin = typeof RigPlugin.Type;

package/dist/src/plugin.js

@@ -60,6 +60,7 @@ var StageDescriptor = Schema2.Struct({
   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
@@ -118,7 +119,7 @@ var StageMutation = Schema2.Union([
   ReorderStageMutation
 ]);
 var ResolutionGrantUse = Schema2.Struct({
-  kind: Schema2.Literals(["protected-stage", "kernel-replacement"]),
+  kind: Schema2.Literal("kernel-replacement"),
   target: TrimmedNonEmptyString,
   pluginId: TrimmedNonEmptyString
 });
@@ -179,13 +180,6 @@ var LoadedPluginDescriptor = Schema3.Struct({
   contributes: Schema3.Unknown,
   runtime: Schema3.Unknown
 });
-var ProtectedStageGrant = Schema3.Struct({
-  stageId: TrimmedNonEmptyString,
-  pluginId: TrimmedNonEmptyString,
-  operations: Schema3.Array(Schema3.Literals(["remove", "replace"])),
-  grantedBy: Schema3.optional(TrimmedNonEmptyString),
-  reason: Schema3.optional(Schema3.String)
-});
 var KernelReplacementGrant = Schema3.Struct({
   pluginId: TrimmedNonEmptyString,
   grantedBy: Schema3.optional(TrimmedNonEmptyString),
@@ -193,14 +187,12 @@ var KernelReplacementGrant = Schema3.Struct({
 });
 var CapabilityGrants = Schema3.Struct({
   capabilityPrecedence: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Array(TrimmedNonEmptyString))),
-  protectedStageGrants: Schema3.optional(Schema3.Array(ProtectedStageGrant)),
   kernelReplacementGrants: Schema3.optional(Schema3.Array(KernelReplacementGrant))
 });
 var KernelBootErrorCode = Schema3.Literals([
   "BootIncoherent",
   "AmbiguousCapability",
   "MissingCapability",
-  "ProtectedStageViolation",
   "KernelReplacementDenied",
   "PipelineUnresolvable"
 ]);
@@ -305,9 +297,34 @@ var TaskSourceRegistration = Schema4.Struct({
 });
 var CliCommandRegistration = Schema4.Struct({
   id: Schema4.String,
-  command: Schema4.String,
+  family: Schema4.optional(Schema4.String),
+  command: Schema4.optional(Schema4.String),
+  description: Schema4.optional(Schema4.String),
+  usage: Schema4.optional(Schema4.String),
+  aliases: Schema4.optional(Schema4.Array(Schema4.String)),
+  projectRequired: Schema4.optional(Schema4.Boolean)
+});
+var ProductCapabilityRegistration = Schema4.Struct({
+  id: Schema4.String,
+  title: Schema4.String,
+  description: Schema4.optional(Schema4.String),
+  commandId: Schema4.optional(Schema4.String),
+  panelId: Schema4.optional(Schema4.String)
+});
+var PanelRegistration = Schema4.Struct({
+  id: Schema4.String,
+  slot: Schema4.String,
+  title: Schema4.String,
+  capabilityId: Schema4.optional(Schema4.String),
+  badge: Schema4.optional(Schema4.String),
+  disabled: Schema4.optional(Schema4.Boolean),
   description: Schema4.optional(Schema4.String)
 });
+var BlockerClassifierRegistration = Schema4.Struct({
+  id: Schema4.String,
+  description: Schema4.optional(Schema4.String),
+  priority: Schema4.optional(Schema4.Number)
+});
 var PluginContributes = Schema4.Struct({
   validators: Schema4.optional(Schema4.Array(ValidatorRegistration)),
   hooks: Schema4.optional(Schema4.Array(HookRegistration)),
@@ -317,7 +334,11 @@ var PluginContributes = Schema4.Struct({
   taskFieldSchemas: Schema4.optional(Schema4.Array(TaskFieldExtension)),
   taskSources: Schema4.optional(Schema4.Array(TaskSourceRegistration)),
   cliCommands: Schema4.optional(Schema4.Array(CliCommandRegistration)),
-  stageMutations: Schema4.optional(Schema4.Array(StageMutation))
+  stages: Schema4.optional(Schema4.Array(Stage)),
+  stageMutations: Schema4.optional(Schema4.Array(StageMutation)),
+  capabilities: Schema4.optional(Schema4.Array(ProductCapabilityRegistration)),
+  panels: Schema4.optional(Schema4.Array(PanelRegistration)),
+  blockerClassifiers: Schema4.optional(Schema4.Array(BlockerClassifierRegistration))
 });
 var RigPlugin = Schema4.Struct({
   name: Schema4.String,
@@ -336,11 +357,14 @@ export {
   SkillRegistration,
   RigPlugin,
   RepoSourceRegistration,
+  ProductCapabilityRegistration,
   PluginContributes,
+  PanelRegistration,
   HookRegistration,
   HookMatcher,
   HookEvent,
   CliCommandRegistration,
+  BlockerClassifierRegistration,
   AgentSessionHookEvent,
   AgentRoleRegistration
 };

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

@@ -1,5 +1,6 @@
 import { Schema } from "effect";
 import { RunStatus } from "./runtime";
+import { ResolvedPipeline, StageRunOutcome } from "./stage";
 /** Who caused a journal event. Operator ids come from the authenticated WS/HTTP principal. */
 export declare const RunActor: Schema.Struct<{
     readonly kind: Schema.Literals<readonly ["operator", "agent", "server", "system"]>;
@@ -355,6 +356,61 @@ export declare const RunCloseoutPhaseEvent: Schema.Struct<{
     readonly runId: Schema.brand<Schema.Trim, "RunId">;
 }>;
 export type RunCloseoutPhaseEvent = typeof RunCloseoutPhaseEvent.Type;
+export declare const RunPipelineResolvedEvent: Schema.Struct<{
+    readonly type: Schema.Literal<"pipeline-resolved">;
+    readonly pipeline: 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>;
+    }>;
+    readonly v: Schema.Literal<1>;
+    readonly seq: Schema.Int;
+    readonly at: Schema.String;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+}>;
+export type RunPipelineResolvedEvent = typeof RunPipelineResolvedEvent.Type;
+export declare const RunStageOutcomeEvent: Schema.Struct<{
+    readonly type: Schema.Literal<"stage-outcome">;
+    readonly outcome: 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;
+    }>;
+    readonly v: Schema.Literal<1>;
+    readonly seq: Schema.Int;
+    readonly at: Schema.String;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+}>;
+export type RunStageOutcomeEvent = typeof RunStageOutcomeEvent.Type;
 export declare const RunJournalEvent: Schema.Union<readonly [Schema.Struct<{
     readonly type: Schema.Literal<"status-changed">;
     readonly from: Schema.NullOr<Schema.Literals<readonly ["created", "queued", "preparing", "running", "waiting-approval", "waiting-user-input", "paused", "validating", "reviewing", "closing-out", "needs-attention", "completed", "failed", "stopped"]>>;
@@ -526,6 +582,57 @@ export declare const RunJournalEvent: Schema.Union<readonly [Schema.Struct<{
     readonly seq: Schema.Int;
     readonly at: Schema.String;
     readonly runId: Schema.brand<Schema.Trim, "RunId">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"pipeline-resolved">;
+    readonly pipeline: 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>;
+    }>;
+    readonly v: Schema.Literal<1>;
+    readonly seq: Schema.Int;
+    readonly at: Schema.String;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"stage-outcome">;
+    readonly outcome: 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;
+    }>;
+    readonly v: Schema.Literal<1>;
+    readonly seq: Schema.Int;
+    readonly at: Schema.String;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
 }>]>;
 export type RunJournalEvent = typeof RunJournalEvent.Type;
 export declare const decodeRunJournalEvent: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => {
@@ -701,6 +808,59 @@ export declare const decodeRunJournalEvent: (input: unknown, options?: import("e
     readonly seq: number;
     readonly outcome: "completed" | "failed" | "started";
     readonly detail?: string | null | undefined;
+} | {
+    readonly at: string;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly v: 1;
+    readonly pipeline: {
+        readonly order: readonly (string & import("effect/Brand").Brand<"StageId">)[];
+        readonly record: readonly {
+            readonly contributedBy: string;
+            readonly stageId: string & import("effect/Brand").Brand<"StageId">;
+            readonly isProtected: boolean;
+            readonly removedBy?: string | undefined;
+            readonly replacedBy?: string | undefined;
+            readonly wrappedBy?: readonly string[] | undefined;
+            readonly droppedAnchors?: readonly (string & import("effect/Brand").Brand<"StageId">)[] | undefined;
+        }[];
+        readonly cycles: readonly (readonly (string & import("effect/Brand").Brand<"StageId">)[])[];
+        readonly runId?: (string & import("effect/Brand").Brand<"RunId">) | undefined;
+        readonly grantUses?: readonly {
+            readonly kind: "kernel-replacement";
+            readonly target: string;
+            readonly pluginId: string;
+        }[] | undefined;
+        readonly resolvedAt?: string | undefined;
+    };
+    readonly type: "pipeline-resolved";
+    readonly seq: number;
+} | {
+    readonly at: string;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly v: 1;
+    readonly type: "stage-outcome";
+    readonly seq: number;
+    readonly outcome: {
+        readonly stageId: string & import("effect/Brand").Brand<"StageId">;
+        readonly result: {
+            readonly kind: "continue";
+            readonly ctx: {
+                readonly runId: string & import("effect/Brand").Brand<"RunId">;
+                readonly state: unknown;
+                readonly taskId?: (string & import("effect/Brand").Brand<"TaskId">) | null | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            };
+        } | {
+            readonly kind: "allow";
+        } | {
+            readonly kind: "block";
+            readonly reason: string;
+        };
+        readonly startedAt: string;
+        readonly finishedAt: string;
+    };
 };
 export declare const RUN_STATUS_TRANSITIONS: Readonly<Record<RunStatus, readonly RunStatus[]>>;
 export declare const TERMINAL_RUN_STATUSES: readonly RunStatus[];
@@ -757,6 +917,12 @@ export type RunJournalProjection = {
         outcome: RunCloseoutPhaseOutcome;
         detail: string | null;
     }>;
+    resolvedPipeline: ResolvedPipeline | null;
+    stageOutcomes: ReadonlyArray<{
+        seq: number;
+        at: string;
+        outcome: StageRunOutcome;
+    }>;
     lastSeq: number;
     lastEventAt: string | null;
     anomalies: ReadonlyArray<RunJournalAnomaly>;