@h-rig/contracts 0.0.6-alpha.18 → 0.0.6-alpha.181

package/dist/src/session-asset-materializer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Pure session-asset-materializer contract.
+ *
+ * Neutral home for the "materialize plugin-contributed session assets into the
+ * workspace" seam so the plugin-host assembler (@rig/core/plugin-host-context)
+ * can trigger Pi skill + package materialization without importing
+ * @rig/provider-plugin (a floor->plugin cycle). The provider plugin owns the
+ * concrete impl (it knows the `.pi/skills` + `.pi/settings.json` layout) and
+ * registers it under {@link SESSION_ASSET_MATERIALIZER}; the assembler resolves
+ * it by id off the project plugin host and calls it. When no provider plugin is
+ * loaded the capability is simply absent and materialization is skipped — the
+ * same non-fatal default the inline implementation had.
+ *
+ * Carries no behaviour and imports only sibling contract types.
+ */
+import type { CapabilityId } from "./capability-id";
+import type { RigConfig } from "./config";
+/** Capability id the provider plugin registers its session-asset materializer under. */
+export declare const SESSION_ASSET_MATERIALIZER_CAPABILITY_ID = "provider.session-asset-materializer";
+/**
+ * Materializes the plugin-contributed session assets (Pi skills declared via
+ * `contributes.skills`, and the config-declared Pi extension packages in
+ * `runtime.pi.packages`) into the project workspace. Idempotent and non-fatal:
+ * implementations log-and-continue on individual write failures so a
+ * materialization error can never deadlock harness boot.
+ */
+export interface SessionAssetMaterializerService {
+    materializeSessionAssets(projectRoot: string, config: RigConfig): Promise<void>;
+}
+/**
+ * Typed capability id the provider plugin provides and the plugin-host assembler
+ * requires. Phantom-typed with `SessionAssetMaterializerService` so `resolve(host)`
+ * returns the service with no cast leaking to callers.
+ */
+export declare const SESSION_ASSET_MATERIALIZER: CapabilityId<SessionAssetMaterializerService>;

package/dist/src/session-asset-materializer.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/session-asset-materializer.ts
+var SESSION_ASSET_MATERIALIZER_CAPABILITY_ID = "provider.session-asset-materializer";
+var SESSION_ASSET_MATERIALIZER = makeCapabilityId(SESSION_ASSET_MATERIALIZER_CAPABILITY_ID);
+export {
+  SESSION_ASSET_MATERIALIZER_CAPABILITY_ID,
+  SESSION_ASSET_MATERIALIZER
+};

package/dist/src/session-hook-materializer.d.ts

@@ -0,0 +1,41 @@
+import type { CapabilityId } from "./capability-id";
+import type { HookEvent, HookRegistration } from "./plugin";
+/** Stable id string for provider/runtime-owned session hook materialization. */
+export declare const SESSION_HOOK_MATERIALIZER_CAPABILITY_ID = "provider.session-hook-materializer";
+/**
+ * A plugin hook contribution prepared for the active session host.
+ *
+ * `typed` means the hook has a runtime implementation attached to the authored
+ * plugin object. Concrete materializers decide how their session host invokes
+ * that implementation; metadata-only hooks (no command and not typed) can be
+ * skipped by implementations.
+ */
+export interface PluginHookEntry {
+    readonly pluginName: string;
+    readonly hook: HookRegistration;
+    readonly typed?: boolean;
+}
+/** Alias naming the entries by the capability they are handed to. */
+export type SessionHookEntry = PluginHookEntry;
+/** Provider-owned materialization result; adapter ids are intentionally open. */
+export type SessionHookMaterializerResult = {
+    readonly adapterId: string;
+    readonly status: "materialized";
+    readonly path?: string;
+    readonly events?: readonly HookEvent[];
+} | {
+    readonly adapterId: string;
+    readonly status: "skipped";
+    readonly reason: string;
+};
+/**
+ * Materializes plugin-contributed hooks into whatever session host is active
+ * (Claude Code settings, Pi/OMP session integration, or another provider-owned
+ * substrate). The floor runtime resolves this capability and invokes it; it
+ * does not know adapter names, settings paths, or provider/session policy.
+ */
+export interface SessionHookMaterializerService {
+    materializeSessionHooks(projectRoot: string, entries: readonly PluginHookEntry[]): Promise<readonly SessionHookMaterializerResult[]> | readonly SessionHookMaterializerResult[];
+}
+/** Branded capability id for the session-hook materializer service. */
+export declare const SESSION_HOOK_MATERIALIZER: CapabilityId<SessionHookMaterializerService>;

package/dist/src/session-hook-materializer.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/session-hook-materializer.ts
+var SESSION_HOOK_MATERIALIZER_CAPABILITY_ID = "provider.session-hook-materializer";
+var SESSION_HOOK_MATERIALIZER = makeCapabilityId(SESSION_HOOK_MATERIALIZER_CAPABILITY_ID);
+export {
+  SESSION_HOOK_MATERIALIZER_CAPABILITY_ID,
+  SESSION_HOOK_MATERIALIZER
+};

package/dist/src/setup.d.ts

@@ -0,0 +1,154 @@
+/**
+ * cap:project-setup — cross-plugin seam.
+ *
+ * `@rig/cli-surface-plugin` (the `rig setup`/onboarding surface) runs project
+ * setup WITHOUT importing `@rig/init-plugin`: it requires this capability by id
+ * off the host. `@rig/init-plugin` OWNS the impl (`runSetup`) and registers it
+ * under this id. This file holds ONLY the pure seam vocabulary — no IO, no
+ * function-laden deps (those are the impl's concern, not the cross-plugin seam).
+ */
+import type { CapabilityId } from "./capability-id";
+import type { GitHubAuthStatus, GitHubProjectStatusField, GitHubProjectSummary } from "./github";
+/** Capability id the init/setup plugin registers its setup runner under. */
+export declare const PROJECT_SETUP_CAPABILITY_ID = "cap:project-setup";
+/**
+ * Where runs execute for this project. `kind` is the placement discriminator
+ * (e.g. "local" | "remote"); kept as a plain string so contracts stays free of
+ * the placement-domain enum.
+ */
+export type ProjectSetupPlacement = {
+    readonly alias: string;
+    readonly kind: "local" | "remote";
+    readonly host?: string;
+    readonly port?: number;
+    readonly token?: string | null;
+};
+/** Pure input to a project-setup pass. */
+export type ProjectSetupInput = {
+    readonly projectRoot: string;
+    readonly slug: string;
+    readonly placement: ProjectSetupPlacement;
+    readonly rewriteConfig?: boolean;
+    readonly ensurePi?: boolean;
+    readonly ensureLabels?: boolean;
+    readonly githubToken?: string | null;
+    readonly importGhToken?: boolean;
+};
+export type ProjectInitAuthMethod = "gh" | "token" | "device" | "skip";
+export type ProjectInitTaskSource = {
+    readonly kind: "github-issues";
+    readonly owner: string;
+    readonly repo: string;
+    readonly assignee?: string | undefined;
+} | {
+    readonly kind: "files";
+    readonly path: string;
+};
+export type ProjectInitInput = {
+    readonly projectRoot: string;
+    readonly demo?: boolean | undefined;
+    readonly repoSlug?: string | undefined;
+    readonly taskSource?: ProjectInitTaskSource | undefined;
+    readonly githubToken?: string | undefined;
+    readonly githubAuthMethod?: ProjectInitAuthMethod | undefined;
+    readonly githubProject?: "off" | string | undefined;
+    readonly githubProjectStatusField?: string | undefined;
+    readonly githubProjectStatuses?: Readonly<Record<string, string>> | undefined;
+    readonly yes?: boolean | undefined;
+    readonly repair?: boolean | undefined;
+    readonly privateStateOnly?: boolean | undefined;
+    readonly server?: "local" | "remote" | undefined;
+    readonly remoteAlias?: string | undefined;
+    readonly remoteHost?: string | undefined;
+    readonly remotePort?: number | undefined;
+    readonly remoteCheckout?: string | undefined;
+};
+export type ProjectInitResult = {
+    readonly mode: "control-plane" | "local-files" | "demo" | "task-source";
+    readonly projectRoot: string;
+    readonly messages: readonly string[];
+    readonly details: Record<string, unknown>;
+};
+export type ProjectInitGitHubProjectsInput = {
+    readonly projectRoot: string;
+    readonly owner: string;
+    readonly token?: string | null | undefined;
+};
+export type ProjectInitGitHubProjectsResult = {
+    readonly ok: true;
+    readonly projects: readonly GitHubProjectSummary[];
+} | {
+    readonly ok: false;
+    readonly error: string;
+    readonly projects: readonly [];
+};
+export type ProjectInitProjectStatusFieldInput = {
+    readonly projectRoot: string;
+    readonly projectId: string;
+    readonly token?: string | null | undefined;
+};
+export type ProjectInitProjectStatusFieldResult = {
+    readonly ok: true;
+    readonly field: GitHubProjectStatusField;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+export type ProjectRepoSlug = {
+    readonly owner: string;
+    readonly repo: string;
+    readonly slug: string;
+};
+export type RigConfigStatus = {
+    readonly exists: boolean;
+    readonly valid: boolean;
+    readonly path: string;
+    readonly slug: string | null;
+    readonly reason?: string;
+};
+export type RigStateStatus = {
+    readonly valid: boolean;
+    readonly selected: string | null;
+    readonly project: string | null;
+    readonly reason?: string;
+};
+export type RigAuthValidation = {
+    readonly ok: boolean;
+    readonly source: "stored-token" | "gh" | "missing";
+    readonly login?: string | null;
+    readonly detail: string;
+    readonly status?: GitHubAuthStatus;
+};
+export type RigSetupStatus = {
+    readonly configured: boolean;
+    readonly projectRoot: string;
+    readonly slug: string | null;
+    readonly config: RigConfigStatus;
+    readonly state: RigStateStatus;
+    readonly auth: RigAuthValidation;
+    readonly reasons: readonly string[];
+};
+export type ProjectSetupResult = {
+    readonly repoSlug: string;
+    readonly placement: string;
+    readonly configWritten: boolean;
+    readonly labels: unknown;
+    readonly pi: unknown;
+    readonly status: RigSetupStatus;
+};
+/** The cohesive project-setup operation the CLI surface depends on. Async methods do IO. */
+export interface ProjectSetupService {
+    parseRepoSlug(value: string): ProjectRepoSlug;
+    detectOriginRepoSlug(input: {
+        readonly projectRoot: string;
+    }): string | null;
+    detectStartupStatus(input: {
+        readonly projectRoot: string;
+    }): Promise<RigSetupStatus>;
+    runSetup(input: ProjectSetupInput): Promise<ProjectSetupResult>;
+    listGitHubProjectsForInit(input: ProjectInitGitHubProjectsInput): Promise<ProjectInitGitHubProjectsResult>;
+    getGitHubProjectStatusFieldForInit(input: ProjectInitProjectStatusFieldInput): Promise<ProjectInitProjectStatusFieldResult>;
+    runInit(input: ProjectInitInput): Promise<ProjectInitResult>;
+}
+/** Typed capability id; string value is {@link PROJECT_SETUP_CAPABILITY_ID}. */
+export declare const PROJECT_SETUP: CapabilityId<ProjectSetupService>;

package/dist/src/setup.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/setup.ts
+var PROJECT_SETUP_CAPABILITY_ID = "cap:project-setup";
+var PROJECT_SETUP = makeCapabilityId(PROJECT_SETUP_CAPABILITY_ID);
+export {
+  PROJECT_SETUP_CAPABILITY_ID,
+  PROJECT_SETUP
+};

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;