@h-rig/contracts 0.0.6-alpha.16 → 0.0.6-alpha.161

package/dist/src/agent-roles.d.ts

@@ -0,0 +1,8 @@
+import type { AgentRoleRegistration } from "./plugin";
+export interface ResolvedAgentRole extends AgentRoleRegistration {
+    model: string;
+}
+export interface AgentRoleRegistry {
+    resolve(id: string): ResolvedAgentRole;
+    list(): readonly ResolvedAgentRole[];
+}

package/dist/src/artifact.d.ts

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+export declare const ArtifactSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "ArtifactId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly kind: Schema.Trim;
+    readonly label: Schema.Trim;
+    readonly path: Schema.NullOr<Schema.Trim>;
+    readonly url: Schema.NullOr<Schema.Trim>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly createdAt: Schema.String;
+}>;
+export type ArtifactSummary = typeof ArtifactSummary.Type;

package/dist/src/artifact.js

@@ -16,6 +16,9 @@ var WorkspaceId = makeEntityId("WorkspaceId");
 var GraphId = makeEntityId("GraphId");
 var TaskId = makeEntityId("TaskId");
 var RunId = makeEntityId("RunId");
+var SafePathSegment = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafePathSegment"));
+var SafeRunId = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(Schema.brand("SafeRunId"));
+var SafeGitRefComponent = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafeGitRefComponent"));
 var EngineRuntimeId = makeEntityId("EngineRuntimeId");
 var ConversationId = makeEntityId("ConversationId");
 var ActionId = makeEntityId("ActionId");

package/dist/src/baseSchemas.d.ts

@@ -0,0 +1,63 @@
+import { Schema } from "effect";
+export declare const TrimmedString: Schema.Trim;
+export declare const TrimmedNonEmptyString: Schema.Trim;
+export declare const NonNegativeInt: Schema.Int;
+export declare const PositiveInt: Schema.Int;
+export declare const IsoDateTime: Schema.String;
+export type IsoDateTime = typeof IsoDateTime.Type;
+export declare const ThreadId: Schema.brand<Schema.Trim, "ThreadId">;
+export type ThreadId = typeof ThreadId.Type;
+export declare const ProjectId: Schema.brand<Schema.Trim, "ProjectId">;
+export type ProjectId = typeof ProjectId.Type;
+export declare const WorkspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+export type WorkspaceId = typeof WorkspaceId.Type;
+export declare const GraphId: Schema.brand<Schema.Trim, "GraphId">;
+export type GraphId = typeof GraphId.Type;
+export declare const TaskId: Schema.brand<Schema.Trim, "TaskId">;
+export type TaskId = typeof TaskId.Type;
+export declare const RunId: Schema.brand<Schema.Trim, "RunId">;
+export type RunId = typeof RunId.Type;
+export declare const SafePathSegment: Schema.brand<Schema.Trim, "SafePathSegment">;
+export type SafePathSegment = typeof SafePathSegment.Type;
+export declare const SafeRunId: Schema.brand<Schema.Trim, "SafeRunId">;
+export type SafeRunId = typeof SafeRunId.Type;
+export declare const SafeGitRefComponent: Schema.brand<Schema.Trim, "SafeGitRefComponent">;
+export type SafeGitRefComponent = typeof SafeGitRefComponent.Type;
+export declare const EngineRuntimeId: Schema.brand<Schema.Trim, "EngineRuntimeId">;
+export type EngineRuntimeId = typeof EngineRuntimeId.Type;
+export declare const ConversationId: Schema.brand<Schema.Trim, "ConversationId">;
+export type ConversationId = typeof ConversationId.Type;
+export declare const ActionId: Schema.brand<Schema.Trim, "ActionId">;
+export type ActionId = typeof ActionId.Type;
+export declare const ArtifactId: Schema.brand<Schema.Trim, "ArtifactId">;
+export type ArtifactId = typeof ArtifactId.Type;
+export declare const WorktreeId: Schema.brand<Schema.Trim, "WorktreeId">;
+export type WorktreeId = typeof WorktreeId.Type;
+export declare const ValidationResultId: Schema.brand<Schema.Trim, "ValidationResultId">;
+export type ValidationResultId = typeof ValidationResultId.Type;
+export declare const ReviewResultId: Schema.brand<Schema.Trim, "ReviewResultId">;
+export type ReviewResultId = typeof ReviewResultId.Type;
+export declare const CommandId: Schema.brand<Schema.Trim, "CommandId">;
+export type CommandId = typeof CommandId.Type;
+export declare const EventId: Schema.brand<Schema.Trim, "EventId">;
+export type EventId = typeof EventId.Type;
+export declare const MessageId: Schema.brand<Schema.Trim, "MessageId">;
+export type MessageId = typeof MessageId.Type;
+export declare const TurnId: Schema.brand<Schema.Trim, "TurnId">;
+export type TurnId = typeof TurnId.Type;
+export declare const ProviderItemId: Schema.brand<Schema.Trim, "ProviderItemId">;
+export type ProviderItemId = typeof ProviderItemId.Type;
+export declare const RuntimeSessionId: Schema.brand<Schema.Trim, "RuntimeSessionId">;
+export type RuntimeSessionId = typeof RuntimeSessionId.Type;
+export declare const RuntimeItemId: Schema.brand<Schema.Trim, "RuntimeItemId">;
+export type RuntimeItemId = typeof RuntimeItemId.Type;
+export declare const RuntimeRequestId: Schema.brand<Schema.Trim, "RuntimeRequestId">;
+export type RuntimeRequestId = typeof RuntimeRequestId.Type;
+export declare const RuntimeTaskId: Schema.brand<Schema.Trim, "RuntimeTaskId">;
+export type RuntimeTaskId = typeof RuntimeTaskId.Type;
+export declare const ApprovalRequestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+export type ApprovalRequestId = typeof ApprovalRequestId.Type;
+export declare const CheckpointRef: Schema.brand<Schema.Trim, "CheckpointRef">;
+export type CheckpointRef = typeof CheckpointRef.Type;
+export declare const RemoteEndpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+export type RemoteEndpointId = typeof RemoteEndpointId.Type;

package/dist/src/baseSchemas.js

@@ -13,6 +13,9 @@ var WorkspaceId = makeEntityId("WorkspaceId");
 var GraphId = makeEntityId("GraphId");
 var TaskId = makeEntityId("TaskId");
 var RunId = makeEntityId("RunId");
+var SafePathSegment = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafePathSegment"));
+var SafeRunId = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(Schema.brand("SafeRunId"));
+var SafeGitRefComponent = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafeGitRefComponent"));
 var EngineRuntimeId = makeEntityId("EngineRuntimeId");
 var ConversationId = makeEntityId("ConversationId");
 var ActionId = makeEntityId("ActionId");
@@ -41,6 +44,9 @@ export {
   TrimmedNonEmptyString,
   ThreadId,
   TaskId,
+  SafeRunId,
+  SafePathSegment,
+  SafeGitRefComponent,
   RuntimeTaskId,
   RuntimeSessionId,
   RuntimeRequestId,

package/dist/src/browser.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Pure browser-contract types.
+ *
+ * These types are the neutral home for the browser-required task contract so
+ * that the dumb runtime substrate (isolation provisioning, task info, rig-agent,
+ * rig-browser-tool) and the @rig/browser-plugin that owns the resolution logic
+ * can both reference them without a substrate->plugin import cycle. They carry
+ * no behaviour and import nothing — exactly like `memory.ts` /
+ * `lifecycle-capabilities.ts`.
+ *
+ * The plugin registers its executable `BrowserContractService` impl under the
+ * typed capability id {@link BROWSER_CONTRACT_SERVICE_CAPABILITY} (whose string
+ * value is {@link BROWSER_CONTRACT_SERVICE_CAPABILITY_ID}) via the
+ * `defineCapability` seam (`@rig/core/capability`); the runtime resolves it by id
+ * from `pluginHost.listExecutableCapabilities()` via the thin typed port in
+ * `@rig/runtime/control-plane/browser-contract-port`.
+ */
+import type { CapabilityId } from "./capability-id";
+/** Capability id the browser plugin registers its `BrowserContractService` factory under. */
+export declare const BROWSER_CONTRACT_SERVICE_CAPABILITY_ID = "browser.contract";
+/** Author-facing browser config attached to a task entry (rig.config / task source). */
+export type TaskBrowserConfig = {
+    required?: boolean;
+    preset?: string;
+    profile?: string;
+    attach_url?: string;
+    state_dir?: string;
+    dev_command?: string;
+    launch_command?: string;
+    check_command?: string;
+    e2e_command?: string;
+    mode?: string;
+};
+/** Resolved, runtime-effective browser contract persisted into the runtime context. */
+export type RuntimeBrowserContext = {
+    required: boolean;
+    preset: string;
+    mode: string;
+    stateDir: string;
+    defaultProfile: string;
+    effectiveProfile: string;
+    defaultAttachUrl: string;
+    effectiveAttachUrl: string;
+    devCommand?: string;
+    launchCommand?: string;
+    checkCommand?: string;
+    e2eCommand?: string;
+    launchHelper: string;
+    checkHelper: string;
+    attachInfoHelper: string;
+    e2eHelper: string;
+    resetProfileHelper: string;
+};
+/** Options for deriving the runtime-effective browser context. */
+export type ResolveTaskBrowserContextOptions = {
+    hostProjectRoot?: string;
+    runtimeId?: string;
+};
+/**
+ * The cohesive set of browser-contract operations the runtime consumers depend
+ * on. This is pure capability VOCAB: the `@rig/browser-plugin` provides a
+ * concrete impl (statically checked against this interface via
+ * `BrowserContractCap.provide`), and the substrate only ever sees this contract —
+ * resolved by id off a plugin host with no `as unknown as` at any call site.
+ */
+export interface BrowserContractService {
+    /** Resolve an author-facing `TaskBrowserConfig` into the runtime-effective context. */
+    resolveTaskBrowserContext(browser: TaskBrowserConfig | undefined, options?: ResolveTaskBrowserContextOptions): RuntimeBrowserContext | undefined;
+    /** Render the `task info` guidance lines for a resolved browser context. */
+    buildBrowserGuidanceLines(browser: RuntimeBrowserContext): string[];
+}
+/**
+ * The typed capability id the browser plugin provides and consumers require.
+ * Phantom-typed with {@link BrowserContractService} so
+ * `BrowserContractCap.require(host)` returns a `BrowserContractService` with no
+ * cast leaking to callers. Its string value is
+ * {@link BROWSER_CONTRACT_SERVICE_CAPABILITY_ID}, so it indexes the same host
+ * entry.
+ */
+export declare const BROWSER_CONTRACT_SERVICE_CAPABILITY: CapabilityId<BrowserContractService>;

package/dist/src/browser.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/browser.ts
+var BROWSER_CONTRACT_SERVICE_CAPABILITY_ID = "browser.contract";
+var BROWSER_CONTRACT_SERVICE_CAPABILITY = makeCapabilityId(BROWSER_CONTRACT_SERVICE_CAPABILITY_ID);
+export {
+  BROWSER_CONTRACT_SERVICE_CAPABILITY_ID,
+  BROWSER_CONTRACT_SERVICE_CAPABILITY
+};

package/dist/src/capability-id.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Capability-seam vocabulary.
+ *
+ * A `CapabilityId<T>` is a plain id string branded (phantom-typed) with the
+ * service type `T` it resolves to. `defineCapability<T>` (in `@rig/core`) reads
+ * this brand so `resolve`/`require` are typed as `T` with the `unknown → T` cast
+ * contained ONCE inside the helper — callers never cast.
+ *
+ * Pure: no imports, no behaviour. The brand lives only in an OPTIONAL phantom
+ * property so a plain `string` is still assignable to `CapabilityId<T>` via the
+ * `makeCapabilityId` cast, and a `CapabilityId<T>` is usable anywhere a `string`
+ * is (equality checks against `host` capability ids, `.toString()`, etc.).
+ */
+declare const CapabilityIdBrand: unique symbol;
+/** A capability id string branded with the service type `T` it resolves to. */
+export type CapabilityId<T> = string & {
+    /** Phantom — never present at runtime; carries `T` for `defineCapability<T>`. */
+    readonly [CapabilityIdBrand]?: T;
+};
+/** Brand a plain id string as a `CapabilityId<T>`. */
+export declare function makeCapabilityId<T>(id: string): CapabilityId<T>;
+export {};

package/dist/src/capability-id.js

@@ -0,0 +1,8 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+export {
+  makeCapabilityId
+};

package/dist/src/cli-output.d.ts

@@ -0,0 +1,348 @@
+import { Schema } from "effect";
+export declare const CLI_OUTPUT_VERSION: 1;
+/** Loose envelope shape shared by every schematized command. */
+export declare const RigCliOutputEnvelope: Schema.Struct<{
+    readonly v: Schema.Literal<1>;
+    readonly command: Schema.String;
+    readonly data: Schema.Unknown;
+}>;
+export type RigCliOutputEnvelope = typeof RigCliOutputEnvelope.Type;
+/** Task summary as emitted by `rig task list|show|next` (summarizeTask). */
+export declare const CliTaskSummary: Schema.Struct<{
+    readonly id: Schema.NullOr<Schema.String>;
+    readonly title: Schema.NullOr<Schema.String>;
+    readonly status: Schema.NullOr<Schema.String>;
+    readonly source: Schema.optional<Schema.String>;
+    readonly url: Schema.optional<Schema.String>;
+    readonly number: Schema.optional<Schema.Number>;
+    readonly labels: Schema.optional<Schema.$Array<Schema.Unknown>>;
+    readonly assignees: Schema.optional<Schema.$Array<Schema.Unknown>>;
+    readonly readiness: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Boolean]>>;
+    readonly validators: Schema.optional<Schema.$Array<Schema.Unknown>>;
+    readonly raw: Schema.optional<Schema.Unknown>;
+}>;
+export type CliTaskSummary = typeof CliTaskSummary.Type;
+export declare const CliTaskFilters: Schema.Struct<{
+    readonly assignee: Schema.optional<Schema.String>;
+    readonly state: Schema.optional<Schema.String>;
+    readonly status: Schema.optional<Schema.String>;
+    readonly limit: Schema.optional<Schema.Number>;
+}>;
+export type CliTaskFilters = typeof CliTaskFilters.Type;
+/**
+ * Run records cross local disk state and remote server payloads, so the
+ * record itself stays an open map; identity fields are validated where the
+ * emitting command guarantees them.
+ */
+export declare const CliRunRecord: Schema.$Record<Schema.String, Schema.Unknown>;
+export type CliRunRecord = typeof CliRunRecord.Type;
+export declare const CliInboxRecord: Schema.$Record<Schema.String, Schema.Unknown>;
+export type CliInboxRecord = typeof CliInboxRecord.Type;
+export declare const CliDoctorCheck: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly label: Schema.String;
+    readonly status: Schema.Literals<readonly ["pass", "warn", "fail"]>;
+    readonly detail: Schema.optional<Schema.String>;
+    readonly remediation: Schema.optional<Schema.String>;
+}>;
+export type CliDoctorCheck = typeof CliDoctorCheck.Type;
+export declare const CliServerConnection: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"local">;
+    readonly mode: Schema.Literal<"auto">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"remote">;
+    readonly baseUrl: Schema.String;
+}>]>;
+export type CliServerConnection = typeof CliServerConnection.Type;
+export declare const CliRepoConnectionState: Schema.Struct<{
+    readonly selected: Schema.String;
+    readonly project: Schema.optional<Schema.String>;
+    readonly linkedAt: Schema.optional<Schema.String>;
+    readonly serverProjectRoot: Schema.optional<Schema.String>;
+    readonly serverProjectRootAlias: Schema.optional<Schema.String>;
+    readonly serverProjectRootBaseUrl: Schema.optional<Schema.String>;
+}>;
+export type CliRepoConnectionState = typeof CliRepoConnectionState.Type;
+export declare const CliRemoteProjectLink: Schema.Struct<{
+    readonly ok: Schema.Boolean;
+    readonly status: Schema.String;
+    readonly alias: Schema.optional<Schema.String>;
+    readonly baseUrl: Schema.optional<Schema.String>;
+    readonly repoSlug: Schema.optional<Schema.String>;
+    readonly serverProjectRoot: Schema.optional<Schema.String>;
+    readonly source: Schema.optional<Schema.String>;
+    readonly prepared: Schema.optional<Schema.Boolean>;
+    readonly validated: Schema.optional<Schema.Boolean>;
+    readonly statusCode: Schema.optional<Schema.Number>;
+    readonly message: Schema.String;
+    readonly hint: Schema.String;
+    readonly next: Schema.optional<Schema.String>;
+    readonly skippedCandidates: Schema.optional<Schema.$Array<Schema.String>>;
+}>;
+export type CliRemoteProjectLink = typeof CliRemoteProjectLink.Type;
+export declare const RigTaskListOutput: Schema.Struct<{
+    readonly v: Schema.Literal<1>;
+    readonly command: Schema.Literal<"task list">;
+    readonly data: Schema.Struct<{
+        readonly count: Schema.Number;
+        readonly filters: Schema.Struct<{
+            readonly assignee: Schema.optional<Schema.String>;
+            readonly state: Schema.optional<Schema.String>;
+            readonly status: Schema.optional<Schema.String>;
+            readonly limit: Schema.optional<Schema.Number>;
+        }>;
+        readonly raw: Schema.Boolean;
+        readonly tasks: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.NullOr<Schema.String>;
+            readonly title: Schema.NullOr<Schema.String>;
+            readonly status: Schema.NullOr<Schema.String>;
+            readonly source: Schema.optional<Schema.String>;
+            readonly url: Schema.optional<Schema.String>;
+            readonly number: Schema.optional<Schema.Number>;
+            readonly labels: Schema.optional<Schema.$Array<Schema.Unknown>>;
+            readonly assignees: Schema.optional<Schema.$Array<Schema.Unknown>>;
+            readonly readiness: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Boolean]>>;
+            readonly validators: Schema.optional<Schema.$Array<Schema.Unknown>>;
+            readonly raw: Schema.optional<Schema.Unknown>;
+        }>>;
+    }>;
+}>;
+export type RigTaskListOutput = typeof RigTaskListOutput.Type;
+export declare const RigTaskShowOutput: Schema.Struct<{
+    readonly v: Schema.Literal<1>;
+    readonly command: Schema.Literal<"task show">;
+    readonly data: Schema.Struct<{
+        readonly task: Schema.Struct<{
+            readonly id: Schema.NullOr<Schema.String>;
+            readonly title: Schema.NullOr<Schema.String>;
+            readonly status: Schema.NullOr<Schema.String>;
+            readonly source: Schema.optional<Schema.String>;
+            readonly url: Schema.optional<Schema.String>;
+            readonly number: Schema.optional<Schema.Number>;
+            readonly labels: Schema.optional<Schema.$Array<Schema.Unknown>>;
+            readonly assignees: Schema.optional<Schema.$Array<Schema.Unknown>>;
+            readonly readiness: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Boolean]>>;
+            readonly validators: Schema.optional<Schema.$Array<Schema.Unknown>>;
+            readonly raw: Schema.optional<Schema.Unknown>;
+        }>;
+        readonly raw: Schema.Boolean;
+    }>;
+}>;
+export type RigTaskShowOutput = typeof RigTaskShowOutput.Type;
+export declare const RigRunListOutput: Schema.Struct<{
+    readonly v: Schema.Literal<1>;
+    readonly command: Schema.Literal<"run list">;
+    readonly data: Schema.Struct<{
+        readonly runs: Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>;
+        readonly source: Schema.Literals<readonly ["local", "server"]>;
+    }>;
+}>;
+export type RigRunListOutput = typeof RigRunListOutput.Type;
+export declare const RigRunShowOutput: Schema.Struct<{
+    readonly v: Schema.Literal<1>;
+    readonly command: Schema.Literal<"run show">;
+    readonly data: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+export type RigRunShowOutput = typeof RigRunShowOutput.Type;
+export declare const RigServerUseOutput: Schema.Struct<{
+    readonly v: Schema.Literal<1>;
+    readonly command: Schema.Literal<"server use">;
+    readonly data: Schema.Struct<{
+        readonly selected: Schema.String;
+        readonly repo: Schema.NullOr<Schema.Struct<{
+            readonly selected: Schema.String;
+            readonly project: Schema.optional<Schema.String>;
+            readonly linkedAt: Schema.optional<Schema.String>;
+            readonly serverProjectRoot: Schema.optional<Schema.String>;
+            readonly serverProjectRootAlias: Schema.optional<Schema.String>;
+            readonly serverProjectRootBaseUrl: Schema.optional<Schema.String>;
+        }>>;
+        readonly remoteProjectLink: Schema.NullOr<Schema.Struct<{
+            readonly ok: Schema.Boolean;
+            readonly status: Schema.String;
+            readonly alias: Schema.optional<Schema.String>;
+            readonly baseUrl: Schema.optional<Schema.String>;
+            readonly repoSlug: Schema.optional<Schema.String>;
+            readonly serverProjectRoot: Schema.optional<Schema.String>;
+            readonly source: Schema.optional<Schema.String>;
+            readonly prepared: Schema.optional<Schema.Boolean>;
+            readonly validated: Schema.optional<Schema.Boolean>;
+            readonly statusCode: Schema.optional<Schema.Number>;
+            readonly message: Schema.String;
+            readonly hint: Schema.String;
+            readonly next: Schema.optional<Schema.String>;
+            readonly skippedCandidates: Schema.optional<Schema.$Array<Schema.String>>;
+        }>>;
+    }>;
+}>;
+export type RigServerUseOutput = typeof RigServerUseOutput.Type;
+export declare const RigServerStatusOutput: Schema.Struct<{
+    readonly v: Schema.Literal<1>;
+    readonly command: Schema.Literal<"server status">;
+    readonly data: Schema.Struct<{
+        readonly selected: Schema.String;
+        readonly repo: Schema.NullOr<Schema.Struct<{
+            readonly selected: Schema.String;
+            readonly project: Schema.optional<Schema.String>;
+            readonly linkedAt: Schema.optional<Schema.String>;
+            readonly serverProjectRoot: Schema.optional<Schema.String>;
+            readonly serverProjectRootAlias: Schema.optional<Schema.String>;
+            readonly serverProjectRootBaseUrl: Schema.optional<Schema.String>;
+        }>>;
+        readonly connections: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"local">;
+            readonly mode: Schema.Literal<"auto">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"remote">;
+            readonly baseUrl: Schema.String;
+        }>]>>;
+        readonly remoteProjectLink: Schema.NullOr<Schema.Struct<{
+            readonly ok: Schema.Boolean;
+            readonly status: Schema.String;
+            readonly alias: Schema.optional<Schema.String>;
+            readonly baseUrl: Schema.optional<Schema.String>;
+            readonly repoSlug: Schema.optional<Schema.String>;
+            readonly serverProjectRoot: Schema.optional<Schema.String>;
+            readonly source: Schema.optional<Schema.String>;
+            readonly prepared: Schema.optional<Schema.Boolean>;
+            readonly validated: Schema.optional<Schema.Boolean>;
+            readonly statusCode: Schema.optional<Schema.Number>;
+            readonly message: Schema.String;
+            readonly hint: Schema.String;
+            readonly next: Schema.optional<Schema.String>;
+            readonly skippedCandidates: Schema.optional<Schema.$Array<Schema.String>>;
+        }>>;
+    }>;
+}>;
+export type RigServerStatusOutput = typeof RigServerStatusOutput.Type;
+export declare const RigServerRepairLinkOutput: Schema.Struct<{
+    readonly v: Schema.Literal<1>;
+    readonly command: Schema.Literal<"server repair-link">;
+    readonly data: Schema.Struct<{
+        readonly ok: Schema.Boolean;
+        readonly status: Schema.String;
+        readonly alias: Schema.optional<Schema.String>;
+        readonly baseUrl: Schema.optional<Schema.String>;
+        readonly repoSlug: Schema.optional<Schema.String>;
+        readonly serverProjectRoot: Schema.optional<Schema.String>;
+        readonly source: Schema.optional<Schema.String>;
+        readonly prepared: Schema.optional<Schema.Boolean>;
+        readonly validated: Schema.optional<Schema.Boolean>;
+        readonly statusCode: Schema.optional<Schema.Number>;
+        readonly message: Schema.String;
+        readonly hint: Schema.String;
+        readonly next: Schema.optional<Schema.String>;
+        readonly skippedCandidates: Schema.optional<Schema.$Array<Schema.String>>;
+    }>;
+}>;
+export type RigServerRepairLinkOutput = typeof RigServerRepairLinkOutput.Type;
+export declare const RigInboxApprovalsOutput: Schema.Struct<{
+    readonly v: Schema.Literal<1>;
+    readonly command: Schema.Literal<"inbox approvals">;
+    readonly data: Schema.Struct<{
+        readonly approvals: Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>;
+}>;
+export type RigInboxApprovalsOutput = typeof RigInboxApprovalsOutput.Type;
+export declare const RigInboxInputsOutput: Schema.Struct<{
+    readonly v: Schema.Literal<1>;
+    readonly command: Schema.Literal<"inbox inputs">;
+    readonly data: Schema.Struct<{
+        readonly requests: Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>;
+}>;
+export type RigInboxInputsOutput = typeof RigInboxInputsOutput.Type;
+export declare const RigDoctorCheckOutput: Schema.Struct<{
+    readonly v: Schema.Literal<1>;
+    readonly command: Schema.Literal<"doctor check">;
+    readonly data: Schema.Struct<{
+        readonly checks: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly label: Schema.String;
+            readonly status: Schema.Literals<readonly ["pass", "warn", "fail"]>;
+            readonly detail: Schema.optional<Schema.String>;
+            readonly remediation: Schema.optional<Schema.String>;
+        }>>;
+        readonly failures: Schema.Number;
+    }>;
+}>;
+export type RigDoctorCheckOutput = typeof RigDoctorCheckOutput.Type;
+/** Fleet metrics computed from on-disk run journals (`rig stats`). */
+export declare const RigStatsData: Schema.Struct<{
+    /** ISO timestamp of the window start, or null for all-time. */
+    readonly since: Schema.NullOr<Schema.String>;
+    readonly totalRuns: Schema.Number;
+    /** Run count per terminal/current status. */
+    readonly statusCounts: Schema.$Record<Schema.String, Schema.Number>;
+    readonly completedRuns: Schema.Number;
+    readonly failedRuns: Schema.Number;
+    readonly needsAttentionRuns: Schema.Number;
+    /** Rates over totalRuns; null when there are no runs in the window. */
+    readonly completionRate: Schema.NullOr<Schema.Number>;
+    readonly failureRate: Schema.NullOr<Schema.Number>;
+    readonly needsAttentionRate: Schema.NullOr<Schema.Number>;
+    /** Median createdAt -> completedAt for completed runs, in milliseconds. */
+    readonly medianCompletionMs: Schema.NullOr<Schema.Number>;
+    readonly steeringTotal: Schema.Number;
+    /** Average steering interventions per run; null when there are no runs. */
+    readonly steeringPerRun: Schema.NullOr<Schema.Number>;
+    readonly stallTotal: Schema.Number;
+    readonly approvalsRequested: Schema.Number;
+    readonly approvalsApproved: Schema.Number;
+    readonly approvalsRejected: Schema.Number;
+    readonly approvalsPending: Schema.Number;
+}>;
+export type RigStatsData = typeof RigStatsData.Type;
+export declare const RigStatsOutput: Schema.Struct<{
+    readonly v: Schema.Literal<1>;
+    readonly command: Schema.Literal<"stats show">;
+    readonly data: Schema.Struct<{
+        /** ISO timestamp of the window start, or null for all-time. */
+        readonly since: Schema.NullOr<Schema.String>;
+        readonly totalRuns: Schema.Number;
+        /** Run count per terminal/current status. */
+        readonly statusCounts: Schema.$Record<Schema.String, Schema.Number>;
+        readonly completedRuns: Schema.Number;
+        readonly failedRuns: Schema.Number;
+        readonly needsAttentionRuns: Schema.Number;
+        /** Rates over totalRuns; null when there are no runs in the window. */
+        readonly completionRate: Schema.NullOr<Schema.Number>;
+        readonly failureRate: Schema.NullOr<Schema.Number>;
+        readonly needsAttentionRate: Schema.NullOr<Schema.Number>;
+        /** Median createdAt -> completedAt for completed runs, in milliseconds. */
+        readonly medianCompletionMs: Schema.NullOr<Schema.Number>;
+        readonly steeringTotal: Schema.Number;
+        /** Average steering interventions per run; null when there are no runs. */
+        readonly steeringPerRun: Schema.NullOr<Schema.Number>;
+        readonly stallTotal: Schema.Number;
+        readonly approvalsRequested: Schema.Number;
+        readonly approvalsApproved: Schema.Number;
+        readonly approvalsRejected: Schema.Number;
+        readonly approvalsPending: Schema.Number;
+    }>;
+}>;
+export type RigStatsOutput = typeof RigStatsOutput.Type;
+export type OutputMode = "text" | "json";
+export type CommandExecutionResult = {
+    command: string[];
+    formattedCommand: string;
+    exitCode: number;
+    durationMs: number;
+    startedAt: string;
+    finishedAt: string;
+    stdout?: string;
+    stderr?: string;
+};
+/** Structured outcome a `rig <group> <command>` handler returns to the runner. */
+export type CommandOutcome = {
+    readonly ok: boolean;
+    readonly group: string;
+    readonly command: string;
+    readonly details?: Record<string, unknown>;
+};
+export type PluginValidatorResult = {
+    id: string;
+    passed: boolean;
+    summary: string;
+    details?: string;
+};