@h-rig/contracts 0.0.6-alpha.14 → 0.0.6-alpha.140

package/dist/src/ipc.d.ts

@@ -0,0 +1,248 @@
+import type { GitCheckoutInput, GitCreateBranchInput, GitCreateWorktreeInput, GitCreateWorktreeResult, GitInitInput, GitListBranchesInput, GitListBranchesResult, GitPullInput, GitPullResult, GitReadWorkingTreePatchInput, GitReadWorkingTreePatchResult, GitRemoveWorktreeInput, GitRunStackedActionInput, GitRunStackedActionResult, GitStatusInput, GitStatusResult } from "./git";
+import type { ProjectListDirectoryInput, ProjectListDirectoryResult, ProjectSearchEntriesInput, ProjectSearchEntriesResult, ProjectReadFileInput, ProjectReadFileResult, ProjectWriteFileInput, ProjectWriteFileResult } from "./project";
+import type { ServerConfig } from "./server";
+import type { RigCreateAdhocRunInput, RigCreateTaskRunInput, RigDeleteRunInput, RigEnqueueTaskInput, RigGetRunLogsInput, RigGetRunLogsResult, RigGetTaskArtifactsResult, RigRunLogAppendedPayload, RigGetWorkspaceInput, RigGetWorkspaceResult, RigListWorkspacesResult, RigMutationResult, RigInterruptRunInput, RigQueueRunSteeringInput, RigQueueRunSteeringResult, RigResumeRunInput, RigResolveApprovalInput, RigResolveUserInputInput, RigSnapshot, RigStopRunInput, RigSubmitRunMessageInput } from "./rig";
+import type { TerminalClearInput, TerminalCloseInput, TerminalEvent, TerminalOpenInput, TerminalResizeInput, TerminalSessionSnapshot, TerminalWriteInput } from "./terminal";
+import type { ServerUpsertKeybindingInput, ServerUpsertKeybindingResult } from "./server";
+import type { ClientOrchestrationCommand, OrchestrationGetFullThreadDiffInput, OrchestrationGetFullThreadDiffResult, OrchestrationGetTurnDiffInput, OrchestrationGetTurnDiffResult, OrchestrationEvent, OrchestrationReadModel } from "./orchestration";
+import type { EngineEvent } from "./engine";
+import { EditorId } from "./editor";
+export interface ContextMenuItem<T extends string = string> {
+    id: T;
+    label: string;
+    destructive?: boolean;
+}
+export type DesktopUpdateStatus = "disabled" | "idle" | "checking" | "up-to-date" | "available" | "downloading" | "downloaded" | "error";
+export interface DesktopUpdateState {
+    enabled: boolean;
+    status: DesktopUpdateStatus;
+    currentVersion: string;
+    availableVersion: string | null;
+    downloadedVersion: string | null;
+    downloadPercent: number | null;
+    checkedAt: string | null;
+    message: string | null;
+    errorContext: "check" | "download" | "install" | null;
+    canRetry: boolean;
+}
+export interface DesktopUpdateActionResult {
+    accepted: boolean;
+    completed: boolean;
+    state: DesktopUpdateState;
+}
+export type RigProjectConfigStatus = "rig-config-ts" | "rig-config-json" | "legacy-task-config" | "missing";
+export interface DesktopRigSetupState {
+    rootPath: string | null;
+    ready: boolean;
+    wsUrl: string | null;
+    /**
+     * What kind of Rig configuration the project at `rootPath` has. The
+     * desktop main process probes the filesystem at boot and on
+     * `setRigRoot`; the renderer reads this to decide whether to show an
+     * onboarding banner ("Run `rig init`") or the normal dashboard.
+     */
+    configStatus: RigProjectConfigStatus;
+}
+export interface RigConfigWriteResult {
+    ok: boolean;
+    /** Absolute path to the file that was written. */
+    configPath: string;
+    /** Filesystem error message when `ok === false`. */
+    error?: string;
+    /** Updated setup state — `configStatus` reflects the post-write probe. */
+    setup: DesktopRigSetupState;
+}
+export interface RigConfigReadResult {
+    /** The raw rig.config.{ts,json} source, or null if none exists. */
+    source: string | null;
+    /** Which file was read; null when no config exists. */
+    configPath: string | null;
+}
+export interface ProjectGitRemoteInfo {
+    /** The raw origin URL, e.g. `git@github.com:humanity-org/humanwork.git`. */
+    url: string;
+    /** Parsed host, e.g. `github.com`. */
+    host: string | null;
+    /** Parsed owner/org, e.g. `humanity-org`. */
+    owner: string | null;
+    /** Parsed repository name (no `.git` suffix), e.g. `humanwork`. */
+    repo: string | null;
+}
+export interface DesktopBridge {
+    getWsUrl: () => string | null;
+    getRigSetup: () => Promise<DesktopRigSetupState>;
+    setRigRoot: (rootPath: string) => Promise<DesktopRigSetupState>;
+    /**
+     * Read the raw rig.config.{ts,json} from the project at `rootPath`.
+     * Returns `{ source: null }` when no config exists. Used by the in-app
+     * Settings screen to populate the form from the existing file.
+     */
+    readRigConfigRaw: (rootPath: string) => Promise<RigConfigReadResult>;
+    /**
+     * Write rig.config.ts to the project root atomically (temp-file + rename).
+     * Refreshes the cached setup state and returns it post-write so callers
+     * can route past the setup gate. Used by both the in-app setup wizard
+     * and the Settings → Project section.
+     */
+    writeRigConfig: (rootPath: string, source: string) => Promise<RigConfigWriteResult>;
+    /**
+     * Inspect the project's git origin to auto-fill setup wizard fields.
+     * Runs `git -C <rootPath> remote get-url origin` and parses owner/repo.
+     * Returns null when the project isn't a git repo, has no origin, or the
+     * URL doesn't match a recognized GitHub-style pattern. The wizard uses
+     * this to prefill the GitHub owner/repo step instead of making the
+     * operator type values that are already in `.git/config`.
+     */
+    getProjectGitRemote: (rootPath: string) => Promise<ProjectGitRemoteInfo | null>;
+    pickFolder: () => Promise<string | null>;
+    confirm: (message: string) => Promise<boolean>;
+    showContextMenu: <T extends string>(items: readonly ContextMenuItem<T>[], position?: {
+        x: number;
+        y: number;
+    }) => Promise<T | null>;
+    openExternal: (url: string) => Promise<boolean>;
+    onMenuAction: (listener: (action: string) => void) => () => void;
+    getUpdateState: () => Promise<DesktopUpdateState>;
+    downloadUpdate: () => Promise<DesktopUpdateActionResult>;
+    installUpdate: () => Promise<DesktopUpdateActionResult>;
+    onUpdateState: (listener: (state: DesktopUpdateState) => void) => () => void;
+}
+export interface NativeApi {
+    dialogs: {
+        pickFolder: () => Promise<string | null>;
+        confirm: (message: string) => Promise<boolean>;
+    };
+    terminal: {
+        open: (input: TerminalOpenInput) => Promise<TerminalSessionSnapshot>;
+        write: (input: TerminalWriteInput) => Promise<void>;
+        resize: (input: TerminalResizeInput) => Promise<void>;
+        clear: (input: TerminalClearInput) => Promise<void>;
+        restart: (input: TerminalOpenInput) => Promise<TerminalSessionSnapshot>;
+        close: (input: TerminalCloseInput) => Promise<void>;
+        onEvent: (callback: (event: TerminalEvent) => void) => () => void;
+    };
+    projects: {
+        listDirectory: (input: ProjectListDirectoryInput) => Promise<ProjectListDirectoryResult>;
+        searchEntries: (input: ProjectSearchEntriesInput) => Promise<ProjectSearchEntriesResult>;
+        readFile: (input: ProjectReadFileInput) => Promise<ProjectReadFileResult>;
+        writeFile: (input: ProjectWriteFileInput) => Promise<ProjectWriteFileResult>;
+    };
+    shell: {
+        openInEditor: (cwd: string, editor: EditorId) => Promise<void>;
+        openExternal: (url: string) => Promise<void>;
+    };
+    git: {
+        listBranches: (input: GitListBranchesInput) => Promise<GitListBranchesResult>;
+        createWorktree: (input: GitCreateWorktreeInput) => Promise<GitCreateWorktreeResult>;
+        removeWorktree: (input: GitRemoveWorktreeInput) => Promise<void>;
+        createBranch: (input: GitCreateBranchInput) => Promise<void>;
+        checkout: (input: GitCheckoutInput) => Promise<void>;
+        init: (input: GitInitInput) => Promise<void>;
+        pull: (input: GitPullInput) => Promise<GitPullResult>;
+        status: (input: GitStatusInput) => Promise<GitStatusResult>;
+        readWorkingTreePatch: (input: GitReadWorkingTreePatchInput) => Promise<GitReadWorkingTreePatchResult>;
+        runStackedAction: (input: GitRunStackedActionInput) => Promise<GitRunStackedActionResult>;
+    };
+    contextMenu: {
+        show: <T extends string>(items: readonly ContextMenuItem<T>[], position?: {
+            x: number;
+            y: number;
+        }) => Promise<T | null>;
+    };
+    server: {
+        getConfig: () => Promise<ServerConfig>;
+        upsertKeybinding: (input: ServerUpsertKeybindingInput) => Promise<ServerUpsertKeybindingResult>;
+    };
+    rig: {
+        getSnapshot: () => Promise<RigSnapshot>;
+        listWorkspaces: () => Promise<RigListWorkspacesResult>;
+        getWorkspace: (input: RigGetWorkspaceInput) => Promise<RigGetWorkspaceResult>;
+        getRunLogs: (input: RigGetRunLogsInput) => Promise<RigGetRunLogsResult>;
+        replayEvents: (fromSequenceExclusive: number) => Promise<EngineEvent[]>;
+        createAdhocRun: (input: RigCreateAdhocRunInput) => Promise<RigMutationResult>;
+        createTaskRun: (input: RigCreateTaskRunInput) => Promise<RigMutationResult>;
+        deleteRun: (input: RigDeleteRunInput) => Promise<RigMutationResult>;
+        enqueueTask: (input: RigEnqueueTaskInput) => Promise<RigMutationResult>;
+        resumeRun: (input: RigResumeRunInput) => Promise<RigMutationResult>;
+        submitRunMessage: (input: RigSubmitRunMessageInput) => Promise<RigMutationResult>;
+        queueRunSteering: (input: RigQueueRunSteeringInput) => Promise<RigQueueRunSteeringResult>;
+        interruptRun: (input: RigInterruptRunInput) => Promise<RigMutationResult>;
+        stopRun: (input: RigStopRunInput) => Promise<RigMutationResult>;
+        resolveApproval: (input: RigResolveApprovalInput) => Promise<RigMutationResult>;
+        resolveUserInput: (input: RigResolveUserInputInput) => Promise<RigMutationResult>;
+        getTaskArtifacts: (taskId: string) => Promise<RigGetTaskArtifactsResult>;
+        onEvent: (callback: (event: EngineEvent) => void) => () => void;
+        onRunLogAppended: (callback: (payload: RigRunLogAppendedPayload) => void) => () => void;
+    };
+    orchestration: {
+        getSnapshot: () => Promise<OrchestrationReadModel>;
+        dispatchCommand: (command: ClientOrchestrationCommand) => Promise<{
+            sequence: number;
+        }>;
+        getTurnDiff: (input: OrchestrationGetTurnDiffInput) => Promise<OrchestrationGetTurnDiffResult>;
+        getFullThreadDiff: (input: OrchestrationGetFullThreadDiffInput) => Promise<OrchestrationGetFullThreadDiffResult>;
+        replayEvents: (fromSequenceExclusive: number) => Promise<OrchestrationEvent[]>;
+        onDomainEvent: (callback: (event: OrchestrationEvent) => void) => () => void;
+    };
+    remote: {
+        testEndpoint: (input: {
+            host: string;
+            port: number;
+            token?: string;
+        }) => Promise<{
+            latencyMs: number;
+        }>;
+        listEndpoints: () => Promise<unknown[]>;
+        registerEndpoint: (input: {
+            alias: string;
+            host: string;
+            port: number;
+            token?: string;
+            autoConnect?: boolean;
+        }) => Promise<unknown>;
+        removeEndpoint: (input: {
+            endpointId: string;
+        }) => Promise<void>;
+        connect: (input: {
+            endpointId: string;
+        }) => Promise<void>;
+        disconnect: (input: {
+            endpointId: string;
+        }) => Promise<void>;
+        createRunForTask: (input: {
+            endpointId: string;
+            taskId: string;
+            runId: string;
+            workspaceId: string;
+            runtimeMode?: string;
+            interactionMode?: string;
+        }) => Promise<{
+            ok: boolean;
+        }>;
+        terminalOpen: (input: {
+            endpointId: string;
+            threadId: string;
+            terminalId: string;
+            cwd?: string;
+            env?: Record<string, string>;
+        }) => Promise<unknown>;
+        terminalWrite: (input: {
+            endpointId: string;
+            threadId: string;
+            terminalId: string;
+            data: string;
+        }) => Promise<void>;
+        terminalResize: (input: {
+            endpointId: string;
+            threadId: string;
+            terminalId: string;
+            cols: number;
+            rows: number;
+        }) => Promise<void>;
+        terminalClose: (input: {
+            endpointId: string;
+            threadId: string;
+            terminalId: string;
+        }) => Promise<void>;
+    };
+}

package/dist/src/kernel.d.ts

@@ -0,0 +1,221 @@
+import { Schema } from "effect";
+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 PluginMeta: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly version: Schema.Trim;
+    readonly provides: Schema.$Array<Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>>;
+    readonly requires: Schema.optional<Schema.$Array<Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>>>;
+    readonly replaces: Schema.optional<Schema.$Array<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 PluginMeta = typeof PluginMeta.Type;
+export declare const LoadedPluginDescriptor: Schema.Struct<{
+    readonly meta: Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly version: Schema.Trim;
+        readonly provides: Schema.$Array<Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>>;
+        readonly requires: Schema.optional<Schema.$Array<Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>>>;
+        readonly replaces: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly capability: Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>;
+            readonly providerPluginId: Schema.Trim;
+        }>, Schema.Trim]>>>;
+    }>;
+    readonly provides: Schema.$Array<Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>>;
+    readonly contributes: Schema.Unknown;
+    readonly runtime: Schema.Unknown;
+}>;
+export type LoadedPluginDescriptor = typeof LoadedPluginDescriptor.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 LoadedPlugin {
+    meta: PluginMeta;
+    provides: ReadonlySet<CapabilityTag>;
+    contributes: unknown;
+    runtime: unknown;
+}
+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 PluginMeta[], 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 LoadedPlugin[];
+    capabilityProviderIds: Readonly<Record<CapabilityTag, string>>;
+}
+export type StageExecutor = (ctx: StageContext) => Promise<StageResult> | StageResult;