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

package/dist/src/isolation.d.ts

@@ -0,0 +1,213 @@
+/**
+ * Pure isolation-backend contract vocab.
+ *
+ * The neutral home for the runtime-isolation backend seam: the capability id, the
+ * `IsolationBackend` service interface, and its provisioning option/data types. A
+ * backend plugin (e.g. @rig/isolation-plugin: worktree/sandbox provisioning)
+ * registers its executable `IsolationBackend` factory under {@link ISOLATION_BACKEND}
+ * (string value {@link ISOLATION_BACKEND_CAPABILITY_ID}); the dumb runtime
+ * substrate (the task-runtime-start hook, the default-lifecycle isolation stage)
+ * resolves it by id from a plugin host built off the project's rig.config via the
+ * `defineCapability` seam — exactly the seam shape of {@link MEMORY} and the
+ * lifecycle capabilities. This module carries no behaviour and imports only pure
+ * contract types, so both the substrate and the plugin can reference it without a
+ * substrate->plugin import cycle.
+ *
+ * The provisioning data types (`AgentRuntime`, `IsolationMode`, `TaskRecordReader`)
+ * are pure data/structural shapes mirrored here so the option type is contracts-
+ * pure; the runtime re-exports them from its own modules for back-compat.
+ */
+import type { CapabilityId } from "./capability-id";
+import type { TaskRecord } from "./task-source";
+import type { IsolationMode } from "./runtime";
+/** Capability id the isolation backend plugin registers its factory under. */
+export declare const ISOLATION_BACKEND_CAPABILITY_ID = "isolation.backend";
+/**
+ * A provisioned, isolated agent runtime: the resolved filesystem layout a backend
+ * hands back. Pure data (all paths/ids), so it lives in contracts as seam vocab;
+ * the runtime re-exports this from `runtime/isolation` for its internal callers.
+ */
+export type AgentRuntime = {
+    id: string;
+    taskId: string;
+    mode: IsolationMode;
+    rootDir: string;
+    workspaceDir: string;
+    homeDir: string;
+    tmpDir: string;
+    cacheDir: string;
+    logsDir: string;
+    stateDir: string;
+    sessionDir: string;
+    claudeHomeDir: string;
+    contextFile: string;
+    binDir: string;
+    createdAt: string;
+};
+/**
+ * The control surface over a running task-run snapshot sidecar. Pure data/handle
+ * type (no impl), so it lives in contracts as seam vocab; both the isolation
+ * plugin (which starts it) and the runtime substrate (agent-wrapper, which holds
+ * the handle) reference it from here without coupling to the impl.
+ */
+export type RuntimeSnapshotSidecar = {
+    cancel: () => Promise<void>;
+    finalize: (command: string[], exitCode: number) => Promise<void>;
+};
+/**
+ * The minimal read surface over task records the provisioner consumes. Structural
+ * contract (only depends on the pure {@link TaskRecord}); the runtime's concrete
+ * reader is assignable to this, mirroring how `MemoryCommandEventSink` keeps the
+ * memory contract free of any runtime/behaviour import.
+ */
+export interface TaskRecordReader {
+    listTasks(): Promise<readonly TaskRecord[]>;
+    getTask(id: string): Promise<TaskRecord | null>;
+}
+/** Options the substrate passes through to provision an isolated runtime. */
+export type EnsureAgentRuntimeOptions = {
+    projectRoot: string;
+    id: string;
+    taskId: string;
+    mode: IsolationMode;
+    provider?: "pi";
+    taskRecordReader?: TaskRecordReader;
+    preserveTaskArtifacts?: boolean;
+};
+/** Options to execute a command inside an already-provisioned agent runtime. */
+export type RunInAgentRuntimeOptions = {
+    projectRoot: string;
+    runtime: AgentRuntime;
+    command: string[];
+    inheritStdio?: boolean;
+};
+/**
+ * The pure filesystem-layout subset a sandbox wrap consumes. Structural data
+ * (all paths/ids), so it lives in contracts as seam vocab; agent-wrapper builds
+ * this from an {@link AgentRuntime} and the backend's wrap impl consumes it. The
+ * provisioned runtime is always `worktree`, but `mode` is the wider
+ * {@link IsolationMode} here so the seam stays assignable from `AgentRuntime`.
+ */
+export type SandboxRuntimeDescriptor = {
+    id: string;
+    mode: IsolationMode;
+    rootDir: string;
+    workspaceDir: string;
+    homeDir: string;
+    tmpDir: string;
+    cacheDir: string;
+    stateDir: string;
+    sessionDir: string;
+    claudeHomeDir: string;
+    binDir: string;
+};
+/** Options the substrate passes to wrap a provider command for sandboxed launch. */
+export type WrapRuntimeSandboxOptions = {
+    projectRoot: string;
+    runtime: SandboxRuntimeDescriptor;
+    command: string[];
+};
+/**
+ * The plan a sandbox-wrap returns: the (possibly rewritten) command plus the
+ * resolved backend metadata. `backend` is an open string union (none/seatbelt/
+ * bwrap/docker/…) kept as `string` so contracts carry no impl-coupled literals.
+ */
+export type RuntimeSandboxPlan = {
+    command: string[];
+    enabled: boolean;
+    backend: string;
+    profilePath?: string;
+    reason?: string;
+    metadata?: Record<string, unknown>;
+};
+/** Result of executing a command inside an isolated agent runtime. */
+export type RunInAgentRuntimeResult = {
+    exitCode: number;
+    stdout?: string;
+    stderr?: string;
+    sandboxBackend: string;
+    sandboxEnabled: boolean;
+};
+/**
+ * A deterministic fingerprint of the runtime image build inputs. Pure data,
+ * lives in contracts so both isolation-plugin (which computes it) and
+ * cli-surface-plugin (which reads image ops through the ISOLATION_BACKEND
+ * seam) can reference the type without a cross-plugin import.
+ */
+export type RuntimeImageFingerprint = {
+    platform: string;
+    bunVersion: string;
+    nodeVersion: string;
+    claudeVersion: string;
+    runtimeCodeHash: string;
+    policyHash: string;
+    pluginsHash: string;
+    lockfileHashes: Record<string, string>;
+};
+/**
+ * The cohesive isolation surface the runtime substrate depends on: provisioning
+ * (`ensureAgentRuntime`) plus the execution helpers (`runInAgentRuntime`,
+ * `runtimeEnv`, `startRuntimeSnapshotSidecar`) the substrate's queue/agent
+ * executor still invokes. A backend plugin provides a concrete impl (worktree,
+ * sandbox, container, …); the substrate only ever sees this port — it resolves the
+ * port off the plugin host and never imports the backend package, so there is no
+ * substrate->plugin cycle even though the impls now live in @rig/isolation-plugin.
+ */
+export interface IsolationBackend {
+    ensureAgentRuntime(options: EnsureAgentRuntimeOptions): Promise<AgentRuntime>;
+    runInAgentRuntime(options: RunInAgentRuntimeOptions): Promise<RunInAgentRuntimeResult>;
+    runtimeEnv(projectRoot: string, runtime: AgentRuntime): Promise<Record<string, string>>;
+    /**
+     * Enumerate the provisioned runtimes for a project root. Backend-specific
+     * (worktree dirs vs. containers vs. sandboxes), so it belongs on the port —
+     * the `rig agent` group and the host run-loader resolve it here rather than
+     * importing the backend impl.
+     */
+    listAgentRuntimes(projectRoot: string): Promise<AgentRuntime[]>;
+    /**
+     * Tear down a single provisioned runtime by id. Backend-specific cleanup
+     * (remove worktree / kill container), reached through the port.
+     */
+    cleanupAgentRuntime(options: {
+        projectRoot: string;
+        id: string;
+    }): Promise<void>;
+    /**
+     * Persist operator-forwarded secrets beside the runtime so a detached run
+     * process recovers them via {@link runtimeEnv}. Backend-specific because the
+     * secret location is part of the runtime's on-disk/instance layout.
+     */
+    persistRuntimeSecrets(runtimeRoot: string, env: Record<string, string>): void;
+    startRuntimeSnapshotSidecar(runtime: AgentRuntime, options?: {
+        instanceId?: string;
+    }): Promise<RuntimeSnapshotSidecar>;
+    /**
+     * Wrap a provider command for sandboxed launch (seatbelt/bwrap/none). The
+     * substrate's agent-wrapper resolves this through the port and spawns the
+     * returned `command` itself, so the sandbox impl stays plugin-owned.
+     */
+    wrapRuntimeSandbox(options: WrapRuntimeSandboxOptions): Promise<RuntimeSandboxPlan>;
+    /**
+     * Compute the deterministic fingerprint of this project's runtime image build
+     * inputs (Bun/Node/Claude versions, code hashes, policy hash, lockfile hashes).
+     * Exposed on the port so build-time CLI commands (e.g. `rig dist rebuild-agent`)
+     * resolve it through the seam instead of importing isolation-plugin impl directly.
+     */
+    computeRuntimeImageFingerprint(projectRoot: string): Promise<RuntimeImageFingerprint>;
+    /**
+     * Derive a short deterministic image id string from a fingerprint.
+     * Pure function; lives on the port alongside `computeRuntimeImageFingerprint`
+     * so callers only need the seam, not the impl.
+     */
+    computeRuntimeImageId(fp: RuntimeImageFingerprint): string;
+}
+/** The capability `run` shape the plugin registers: a (lazy) backend factory. */
+export type IsolationBackendCapabilityRun = () => IsolationBackend | Promise<IsolationBackend>;
+/**
+ * The typed capability id the isolation backend plugin provides and the substrate
+ * requires. Phantom-typed with {@link IsolationBackend} so
+ * `defineCapability(ISOLATION_BACKEND)` resolves to the backend with no cast
+ * leaking to callers. Its string value is {@link ISOLATION_BACKEND_CAPABILITY_ID},
+ * so it indexes the same host entry.
+ */
+export declare const ISOLATION_BACKEND: CapabilityId<IsolationBackend>;

package/dist/src/isolation.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/isolation.ts
+var ISOLATION_BACKEND_CAPABILITY_ID = "isolation.backend";
+var ISOLATION_BACKEND = makeCapabilityId(ISOLATION_BACKEND_CAPABILITY_ID);
+export {
+  ISOLATION_BACKEND_CAPABILITY_ID,
+  ISOLATION_BACKEND
+};

package/dist/src/kernel.d.ts

@@ -0,0 +1,200 @@
+import { Schema } from "effect";
+import type { RigPlugin } from "./plugin";
+import type { CapabilityId } from "./capability-id";
+import { ResolvedPipeline, StageContext, StageDescriptor, StageMutation, StageResult, StageRunOutcome } from "./stage";
+export declare const CapabilityTag: Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>;
+export type CapabilityTag = typeof CapabilityTag.Type;
+export declare const CapabilityProviderRef: Schema.Struct<{
+    readonly capability: Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>;
+    readonly pluginId: Schema.Trim;
+}>;
+export type CapabilityProviderRef = typeof CapabilityProviderRef.Type;
+export declare const CapabilityReplacement: Schema.Struct<{
+    readonly capability: Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>;
+    readonly providerPluginId: Schema.Trim;
+}>;
+export type CapabilityReplacement = typeof CapabilityReplacement.Type;
+export declare const CapabilityReplacementSpec: Schema.Union<readonly [Schema.Struct<{
+    readonly capability: Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>;
+    readonly providerPluginId: Schema.Trim;
+}>, Schema.Trim]>;
+export type CapabilityReplacementSpec = typeof CapabilityReplacementSpec.Type;
+export declare const KernelReplacementGrant: Schema.Struct<{
+    readonly pluginId: Schema.Trim;
+    readonly grantedBy: Schema.optional<Schema.Trim>;
+    readonly reason: Schema.optional<Schema.String>;
+}>;
+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 kernelReplacementGrants: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly pluginId: Schema.Trim;
+        readonly grantedBy: Schema.optional<Schema.Trim>;
+        readonly reason: Schema.optional<Schema.String>;
+    }>>>;
+}>;
+export type CapabilityGrants = typeof CapabilityGrants.Type;
+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", "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>;
+    readonly pluginIds: Schema.optional<Schema.$Array<Schema.Trim>>;
+}>;
+export type KernelBootError = typeof KernelBootError.Type;
+export declare class BootIncoherent extends Error {
+    readonly code = "BootIncoherent";
+}
+export declare class AmbiguousCapability extends Error {
+    readonly code = "AmbiguousCapability";
+}
+export declare class MissingCapability extends Error {
+    readonly code = "MissingCapability";
+}
+export declare class KernelReplacementDenied extends Error {
+    readonly code = "KernelReplacementDenied";
+}
+export declare class PipelineUnresolvable extends Error {
+    readonly code = "PipelineUnresolvable";
+}
+export declare const CapabilityResolutionStatus: Schema.Literals<readonly ["resolved", "ambiguous", "missing", "replaced"]>;
+export type CapabilityResolutionStatus = typeof CapabilityResolutionStatus.Type;
+export declare const CapabilityResolutionRecord: Schema.Struct<{
+    readonly capability: Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>;
+    readonly status: Schema.Literals<readonly ["resolved", "ambiguous", "missing", "replaced"]>;
+    readonly selectedPluginId: Schema.NullOr<Schema.Trim>;
+    readonly candidatePluginIds: Schema.$Array<Schema.Trim>;
+    readonly precedenceUsed: Schema.Boolean;
+    readonly replacementUsed: Schema.optional<Schema.Struct<{
+        readonly capability: Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>;
+        readonly providerPluginId: Schema.Trim;
+    }>>;
+    readonly error: Schema.optional<Schema.String>;
+}>;
+export type CapabilityResolutionRecord = typeof CapabilityResolutionRecord.Type;
+export declare const KernelResolutionRecord: Schema.Struct<{
+    readonly resolvedAt: Schema.String;
+    readonly capabilities: Schema.$Array<Schema.Struct<{
+        readonly capability: Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>;
+        readonly status: Schema.Literals<readonly ["resolved", "ambiguous", "missing", "replaced"]>;
+        readonly selectedPluginId: Schema.NullOr<Schema.Trim>;
+        readonly candidatePluginIds: Schema.$Array<Schema.Trim>;
+        readonly precedenceUsed: Schema.Boolean;
+        readonly replacementUsed: Schema.optional<Schema.Struct<{
+            readonly capability: Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>;
+            readonly providerPluginId: Schema.Trim;
+        }>>;
+        readonly error: Schema.optional<Schema.String>;
+    }>>;
+    readonly pipeline: Schema.optional<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 KernelResolutionRecord = typeof KernelResolutionRecord.Type;
+export declare const BootResultDescriptor: Schema.Struct<{
+    readonly kernelPluginId: Schema.Trim;
+    readonly pluginIds: Schema.$Array<Schema.Trim>;
+    readonly resolution: Schema.Struct<{
+        readonly resolvedAt: Schema.String;
+        readonly capabilities: Schema.$Array<Schema.Struct<{
+            readonly capability: Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>;
+            readonly status: Schema.Literals<readonly ["resolved", "ambiguous", "missing", "replaced"]>;
+            readonly selectedPluginId: Schema.NullOr<Schema.Trim>;
+            readonly candidatePluginIds: Schema.$Array<Schema.Trim>;
+            readonly precedenceUsed: Schema.Boolean;
+            readonly replacementUsed: Schema.optional<Schema.Struct<{
+                readonly capability: Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>;
+                readonly providerPluginId: Schema.Trim;
+            }>>;
+            readonly error: Schema.optional<Schema.String>;
+        }>>;
+        readonly pipeline: Schema.optional<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 BootResultDescriptor = typeof BootResultDescriptor.Type;
+export declare const JournalEvent: Schema.Struct<{
+    readonly type: Schema.Trim;
+    readonly runId: Schema.optional<Schema.brand<Schema.Trim, "RunId">>;
+    readonly at: Schema.String;
+    readonly payload: Schema.Unknown;
+}>;
+export type JournalEvent = typeof JournalEvent.Type;
+export interface JournalCapability {
+    append(event: unknown): Promise<void>;
+    recordPipeline(runId: string, pipeline: ResolvedPipeline): Promise<void>;
+    recordStageOutcome?(runId: string, outcome: StageRunOutcome): Promise<void>;
+    read(runId: string): Promise<readonly unknown[]>;
+}
+export interface StageRunnerCapability {
+    resolve(defaultStages: readonly StageDescriptor[], mutations: readonly StageMutation[], grants?: CapabilityGrants): ResolvedPipeline;
+    runPipeline(runId: string, resolved: ResolvedPipeline, ctx: StageContext): Promise<readonly StageRunOutcome[]>;
+}
+export interface TransportCapability {
+    dispatch(task: unknown, options?: unknown): Promise<string>;
+    attach?(runId: string): Promise<unknown>;
+    serve?(): Promise<void>;
+}
+export interface LoaderPolicyCapability {
+    resolveCapability(plugins: readonly RigPlugin[], capability: CapabilityTag, grants?: CapabilityGrants): CapabilityResolutionRecord;
+}
+export interface KernelCapability {
+    journal: JournalCapability;
+    stageRunner: StageRunnerCapability;
+    transport: TransportCapability;
+    loaderPolicy: LoaderPolicyCapability;
+    start(plugins: readonly unknown[]): Promise<void>;
+}
+export interface BootResult {
+    kernel: KernelCapability;
+    plugins: readonly RigPlugin[];
+    capabilityProviderIds: Readonly<Record<CapabilityTag, string>>;
+}
+export type StageExecutor = (ctx: StageContext) => Promise<StageResult> | StageResult;
+/**
+ * The placement-aware run transport capability id.
+ *
+ * @rig/transport-plugin provides this as a host-service capability (its impl
+ * wraps `createPlacementRunTransport`). @rig/run-exec resolves it via
+ * `loadCapabilityForRoot` and passes the result to `adopt()` — the SEAM-ONLY
+ * replacement for importing `createPlacementRunTransport` directly from
+ * @rig/transport-plugin impl (§6.4).
+ */
+export declare const PLACEMENT_RUN_TRANSPORT: CapabilityId<TransportCapability>;

package/dist/src/kernel.js

@@ -0,0 +1,261 @@
+// @bun
+// packages/contracts/src/kernel.ts
+import { Schema as Schema3 } 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/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/stage.ts
+import { Schema as Schema2 } from "effect";
+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 StageContinueResult = Schema2.Struct({
+  kind: Schema2.Literal("continue"),
+  ctx: StageContext
+});
+var StageAllowResult = Schema2.Struct({
+  kind: Schema2.Literal("allow")
+});
+var StageBlockResult = Schema2.Struct({
+  kind: Schema2.Literal("block"),
+  reason: TrimmedNonEmptyString
+});
+var StageResult = Schema2.Union([
+  StageContinueResult,
+  StageAllowResult,
+  StageBlockResult
+]);
+var StageWrapperDescriptor = Schema2.Struct({
+  id: TrimmedNonEmptyString,
+  priority: Schema2.Number.pipe(Schema2.withDecodingDefault(() => 0))
+});
+var StageMutationOp = Schema2.Literals(["insert", "remove", "replace", "wrap", "reorder"]);
+var InsertStageMutation = Schema2.Struct({
+  op: Schema2.Literal("insert"),
+  stage: StageDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var RemoveStageMutation = Schema2.Struct({
+  op: Schema2.Literal("remove"),
+  id: StageId,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var ReplaceStageMutation = Schema2.Struct({
+  op: Schema2.Literal("replace"),
+  id: StageId,
+  stage: StageDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var WrapStageMutation = Schema2.Struct({
+  op: Schema2.Literal("wrap"),
+  id: StageId,
+  around: StageWrapperDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var ReorderStageMutation = Schema2.Struct({
+  op: Schema2.Literal("reorder"),
+  id: StageId,
+  before: Schema2.optional(Schema2.Array(StageId)),
+  after: Schema2.optional(Schema2.Array(StageId)),
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var StageMutation = Schema2.Union([
+  InsertStageMutation,
+  RemoveStageMutation,
+  ReplaceStageMutation,
+  WrapStageMutation,
+  ReorderStageMutation
+]);
+var ResolutionGrantUse = Schema2.Struct({
+  kind: Schema2.Literal("kernel-replacement"),
+  target: TrimmedNonEmptyString,
+  pluginId: TrimmedNonEmptyString
+});
+var ResolutionRecordEntry = Schema2.Struct({
+  stageId: StageId,
+  contributedBy: TrimmedNonEmptyString,
+  removedBy: Schema2.optional(TrimmedNonEmptyString),
+  replacedBy: Schema2.optional(TrimmedNonEmptyString),
+  wrappedBy: Schema2.optional(Schema2.Array(TrimmedNonEmptyString)),
+  droppedAnchors: Schema2.optional(Schema2.Array(StageId)),
+  isProtected: Schema2.Boolean
+});
+var ResolvedPipeline = Schema2.Struct({
+  runId: Schema2.optional(RunId),
+  order: Schema2.Array(StageId),
+  record: Schema2.Array(ResolutionRecordEntry),
+  cycles: Schema2.Array(Schema2.Array(StageId)),
+  grantUses: Schema2.optional(Schema2.Array(ResolutionGrantUse)),
+  resolvedAt: Schema2.optional(IsoDateTime)
+});
+var StageRunOutcome = Schema2.Struct({
+  stageId: StageId,
+  result: StageResult,
+  startedAt: IsoDateTime,
+  finishedAt: IsoDateTime
+});
+
+// packages/contracts/src/kernel.ts
+var CapabilityTag = Schema3.Literals([
+  "kernel",
+  "journal",
+  "stage-runner",
+  "transport",
+  "loader-policy"
+]);
+var CapabilityProviderRef = Schema3.Struct({
+  capability: CapabilityTag,
+  pluginId: TrimmedNonEmptyString
+});
+var CapabilityReplacement = Schema3.Struct({
+  capability: CapabilityTag,
+  providerPluginId: TrimmedNonEmptyString
+});
+var CapabilityReplacementSpec = Schema3.Union([
+  CapabilityReplacement,
+  TrimmedNonEmptyString
+]);
+var KernelReplacementGrant = Schema3.Struct({
+  pluginId: TrimmedNonEmptyString,
+  grantedBy: Schema3.optional(TrimmedNonEmptyString),
+  reason: Schema3.optional(Schema3.String)
+});
+var CapabilityGrants = Schema3.Struct({
+  capabilityPrecedence: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Array(TrimmedNonEmptyString))),
+  kernelReplacementGrants: Schema3.optional(Schema3.Array(KernelReplacementGrant))
+});
+var KernelBootErrorCode = Schema3.Literals([
+  "BootIncoherent",
+  "AmbiguousCapability",
+  "MissingCapability",
+  "KernelReplacementDenied",
+  "PipelineUnresolvable"
+]);
+var KernelBootError = Schema3.Struct({
+  code: KernelBootErrorCode,
+  message: TrimmedNonEmptyString,
+  capability: Schema3.optional(CapabilityTag),
+  stageId: Schema3.optional(TrimmedNonEmptyString),
+  pluginIds: Schema3.optional(Schema3.Array(TrimmedNonEmptyString))
+});
+
+class BootIncoherent extends Error {
+  code = "BootIncoherent";
+}
+
+class AmbiguousCapability extends Error {
+  code = "AmbiguousCapability";
+}
+
+class MissingCapability extends Error {
+  code = "MissingCapability";
+}
+
+class KernelReplacementDenied extends Error {
+  code = "KernelReplacementDenied";
+}
+
+class PipelineUnresolvable extends Error {
+  code = "PipelineUnresolvable";
+}
+var CapabilityResolutionStatus = Schema3.Literals(["resolved", "ambiguous", "missing", "replaced"]);
+var CapabilityResolutionRecord = Schema3.Struct({
+  capability: CapabilityTag,
+  status: CapabilityResolutionStatus,
+  selectedPluginId: Schema3.NullOr(TrimmedNonEmptyString),
+  candidatePluginIds: Schema3.Array(TrimmedNonEmptyString),
+  precedenceUsed: Schema3.Boolean,
+  replacementUsed: Schema3.optional(CapabilityReplacement),
+  error: Schema3.optional(Schema3.String)
+});
+var KernelResolutionRecord = Schema3.Struct({
+  resolvedAt: IsoDateTime,
+  capabilities: Schema3.Array(CapabilityResolutionRecord),
+  pipeline: Schema3.optional(ResolvedPipeline)
+});
+var BootResultDescriptor = Schema3.Struct({
+  kernelPluginId: TrimmedNonEmptyString,
+  pluginIds: Schema3.Array(TrimmedNonEmptyString),
+  resolution: KernelResolutionRecord
+});
+var JournalEvent = Schema3.Struct({
+  type: TrimmedNonEmptyString,
+  runId: Schema3.optional(RunId),
+  at: IsoDateTime,
+  payload: Schema3.Unknown
+});
+var PLACEMENT_RUN_TRANSPORT = makeCapabilityId("transport.placement-run");
+export {
+  PipelineUnresolvable,
+  PLACEMENT_RUN_TRANSPORT,
+  MissingCapability,
+  KernelResolutionRecord,
+  KernelReplacementGrant,
+  KernelReplacementDenied,
+  KernelBootErrorCode,
+  KernelBootError,
+  JournalEvent,
+  CapabilityTag,
+  CapabilityResolutionStatus,
+  CapabilityResolutionRecord,
+  CapabilityReplacementSpec,
+  CapabilityReplacement,
+  CapabilityProviderRef,
+  CapabilityGrants,
+  BootResultDescriptor,
+  BootIncoherent,
+  AmbiguousCapability
+};