@h-rig/contracts 0.0.0-e2e-live.20260630085347

package/dist/src/prompt.d.ts

@@ -0,0 +1,29 @@
+/**
+ * prompt.ts — pure capability vocabulary for agent prompt assembly.
+ *
+ * Moved here from `@rig/prompt-plugin` (where it was defined locally): the FLOOR
+ * cannot resolve a capability whose id/input type only exist inside a plugin
+ * without importing the plugin. The plugin OWNS the impl
+ * (`readPriorPrProgressPromptSection`, lazy-loaded inside `run()`) and registers
+ * it under this id; consumers resolve it off the host. Types only here.
+ */
+import type { CapabilityId } from "./capability-id";
+/**
+ * Capability id: agent prompt assembly — the prior-progress section of what the
+ * agent is told for a re-dispatched task.
+ */
+export declare const PRIOR_PROGRESS_PROMPT_CAPABILITY_ID = "prompt.prior-progress";
+/** Pure input: which workspace + task to assemble the prior-progress section for. */
+export type PriorProgressPromptInput = {
+    readonly projectRoot: string;
+    readonly taskId: string;
+};
+/**
+ * The cohesive prompt-assembly operation: returns the prior-PR-progress prompt
+ * section, or null when there is no prior progress. Async (reads fs).
+ */
+export interface PriorProgressPromptService {
+    readPriorProgressSection(input: PriorProgressPromptInput): Promise<string | null>;
+}
+/** Typed capability id; string value is {@link PRIOR_PROGRESS_PROMPT_CAPABILITY_ID}. */
+export declare const PRIOR_PROGRESS_PROMPT: CapabilityId<PriorProgressPromptService>;

package/dist/src/prompt.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/prompt.ts
+var PRIOR_PROGRESS_PROMPT_CAPABILITY_ID = "prompt.prior-progress";
+var PRIOR_PROGRESS_PROMPT = makeCapabilityId(PRIOR_PROGRESS_PROMPT_CAPABILITY_ID);
+export {
+  PRIOR_PROGRESS_PROMPT_CAPABILITY_ID,
+  PRIOR_PROGRESS_PROMPT
+};

package/dist/src/protocol-version.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Rig client–server protocol version.
+ *
+ * A single integer shared by the server (reported in the
+ * `GET /api/server/status` bootstrap payload as `protocolVersion`) and by
+ * clients that speak the HTTP/WS surface (the pi-rig bridge validates it at
+ * extension init and disables itself on mismatch instead of failing on a
+ * random later request).
+ *
+ * Bump rules:
+ * - Increment whenever a change to the server API surface would break an
+ *   older client (removed/renamed routes, changed payload shapes, changed
+ *   steering/event semantics).
+ * - Purely additive changes (new routes, new optional fields) do NOT require
+ *   a bump.
+ *
+ * History:
+ * - 1: first explicit version (2026-06). Servers older than this do not
+ *   report `protocolVersion` at all; clients treat the missing field as v0.
+ */
+export declare const RIG_PROTOCOL_VERSION = 1;

package/dist/src/protocol-version.js

@@ -0,0 +1,6 @@
+// @bun
+// packages/contracts/src/protocol-version.ts
+var RIG_PROTOCOL_VERSION = 1;
+export {
+  RIG_PROTOCOL_VERSION
+};

package/dist/src/provider-instructions.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Pure provider-instruction contract types.
+ *
+ * Neutral home for the agent-harness provider identity so the dumb runtime
+ * substrate (native/task-ops, hooks/inject-context) and the
+ * @rig/provider-plugin that owns the instruction text can both reference it
+ * without a substrate->plugin import cycle. Carries no behaviour and imports
+ * nothing — exactly like `memory.ts` / `lifecycle-capabilities.ts`.
+ *
+ * The plugin registers its executable `RuntimeInstructionService` impl under the
+ * typed id {@link RUNTIME_INSTRUCTION} (whose string value is
+ * {@link RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID}) via `*.provide`; the runtime
+ * resolves it by id from `pluginHost.listExecutableCapabilities()` via the
+ * `defineCapability` seam (`@rig/core/capability`), re-exported from the thin
+ * `@rig/runtime/control-plane/provider-instruction-port`.
+ */
+import type { CapabilityId } from "./capability-id";
+/** Capability id the provider plugin registers its instruction service under. */
+export declare const RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID = "provider.runtime-instructions";
+/** The agent harness adapter the runtime is currently wired to. */
+export type RuntimeInstructionProvider = "pi";
+/**
+ * The cohesive set of agent-harness instruction builders the runtime consumers
+ * depend on. This is pure capability VOCAB: the `@rig/provider-plugin` provides a
+ * concrete impl (statically checked against this interface via the typed
+ * capability seam), 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 RuntimeInstructionService {
+    normalizeProvider(value: string | undefined | null): RuntimeInstructionProvider;
+    buildTaskRunInstructionLines(provider: RuntimeInstructionProvider): string[];
+    buildRuntimeContextLines(provider: RuntimeInstructionProvider): string[];
+}
+/**
+ * The typed capability id the provider plugin provides and consumers require.
+ * Phantom-typed with `RuntimeInstructionService` so `resolve(host)` returns a
+ * `RuntimeInstructionService` with no cast leaking to callers. Its string value
+ * is {@link RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID}, so it indexes the same
+ * host entry.
+ */
+export declare const RUNTIME_INSTRUCTION: CapabilityId<RuntimeInstructionService>;

package/dist/src/provider-instructions.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/provider-instructions.ts
+var RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID = "provider.runtime-instructions";
+var RUNTIME_INSTRUCTION = makeCapabilityId(RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID);
+export {
+  RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID,
+  RUNTIME_INSTRUCTION
+};

package/dist/src/provider.d.ts

@@ -0,0 +1,105 @@
+import { Schema } from "effect";
+import type { CapabilityId } from "./capability-id";
+export declare const ProviderSession: Schema.Struct<{
+    readonly provider: Schema.Literals<readonly ["codex", "claude"]>;
+    readonly status: Schema.Literals<readonly ["connecting", "ready", "running", "error", "closed"]>;
+    readonly runtimeMode: Schema.Literals<readonly ["approval-required", "full-access"]>;
+    readonly cwd: Schema.optional<Schema.Trim>;
+    readonly model: Schema.optional<Schema.Trim>;
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly resumeCursor: Schema.optional<Schema.Unknown>;
+    readonly activeTurnId: Schema.optional<Schema.brand<Schema.Trim, "TurnId">>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly lastError: Schema.optional<Schema.Trim>;
+}>;
+export type ProviderSession = typeof ProviderSession.Type;
+export declare const ProviderSessionStartInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly provider: Schema.optional<Schema.Literals<readonly ["codex", "claude"]>>;
+    readonly cwd: Schema.optional<Schema.Trim>;
+    readonly model: Schema.optional<Schema.Trim>;
+    readonly modelOptions: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly resumeCursor: Schema.optional<Schema.Unknown>;
+    readonly serviceTier: Schema.optional<Schema.NullOr<Schema.Literals<readonly ["fast", "flex"]>>>;
+    readonly approvalPolicy: Schema.optional<Schema.Literals<readonly ["untrusted", "on-failure", "on-request", "never"]>>;
+    readonly sandboxMode: Schema.optional<Schema.Literals<readonly ["read-only", "workspace-write", "danger-full-access"]>>;
+    readonly providerOptions: Schema.optional<Schema.Struct<{
+        readonly codex: Schema.optional<Schema.Struct<{
+            readonly binaryPath: Schema.optional<Schema.Trim>;
+            readonly homePath: Schema.optional<Schema.Trim>;
+        }>>;
+    }>>;
+    readonly runtimeMode: Schema.Literals<readonly ["approval-required", "full-access"]>;
+}>;
+export type ProviderSessionStartInput = typeof ProviderSessionStartInput.Type;
+export declare const ProviderSendTurnInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly input: Schema.optional<Schema.Trim>;
+    readonly attachments: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly id: Schema.Trim;
+        readonly name: Schema.Trim;
+        readonly mimeType: Schema.Trim;
+        readonly sizeBytes: Schema.Int;
+    }>]>>>;
+    readonly model: Schema.optional<Schema.Trim>;
+    readonly serviceTier: Schema.optional<Schema.NullOr<Schema.Literals<readonly ["fast", "flex"]>>>;
+    readonly modelOptions: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly interactionMode: Schema.optional<Schema.Literals<readonly ["default", "plan"]>>;
+}>;
+export type ProviderSendTurnInput = typeof ProviderSendTurnInput.Type;
+export declare const ProviderTurnStartResult: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly turnId: Schema.brand<Schema.Trim, "TurnId">;
+    readonly resumeCursor: Schema.optional<Schema.Unknown>;
+}>;
+export type ProviderTurnStartResult = typeof ProviderTurnStartResult.Type;
+export declare const ProviderInterruptTurnInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly turnId: Schema.optional<Schema.brand<Schema.Trim, "TurnId">>;
+}>;
+export type ProviderInterruptTurnInput = typeof ProviderInterruptTurnInput.Type;
+export declare const ProviderStopSessionInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+}>;
+export type ProviderStopSessionInput = typeof ProviderStopSessionInput.Type;
+export declare const ProviderRespondToRequestInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+    readonly decision: Schema.Literals<readonly ["accept", "acceptForSession", "decline", "cancel"]>;
+}>;
+export type ProviderRespondToRequestInput = typeof ProviderRespondToRequestInput.Type;
+export declare const ProviderRespondToUserInputInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+    readonly answers: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+export type ProviderRespondToUserInputInput = typeof ProviderRespondToUserInputInput.Type;
+export declare const ProviderEvent: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "EventId">;
+    readonly kind: Schema.Literals<readonly ["session", "notification", "request", "error"]>;
+    readonly provider: Schema.Literals<readonly ["codex", "claude"]>;
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly createdAt: Schema.String;
+    readonly method: Schema.Trim;
+    readonly message: Schema.optional<Schema.Trim>;
+    readonly turnId: Schema.optional<Schema.brand<Schema.Trim, "TurnId">>;
+    readonly itemId: Schema.optional<Schema.brand<Schema.Trim, "ProviderItemId">>;
+    readonly requestId: Schema.optional<Schema.brand<Schema.Trim, "ApprovalRequestId">>;
+    readonly requestKind: Schema.optional<Schema.Literals<readonly ["command", "file-read", "file-change"]>>;
+    readonly textDelta: Schema.optional<Schema.String>;
+    readonly payload: Schema.optional<Schema.Unknown>;
+}>;
+export type ProviderEvent = typeof ProviderEvent.Type;
+export interface AgentHarnessRunWrapperInput {
+    readonly argv: readonly string[];
+}
+export interface AgentHarnessService {
+    /** Provider-owned source entrypoint used when a project-local rig-agent binary must be materialized from source. */
+    readonly resolveAgentWrapperEntrypoint: () => string;
+    readonly runAgentWrapper: (input: AgentHarnessRunWrapperInput) => Promise<number>;
+    readonly runRigAgentEntrypoint: () => Promise<void>;
+}
+export declare const AGENT_HARNESS_CAPABILITY_ID = "rig.provider.agent-harness";
+export declare const AGENT_HARNESS: CapabilityId<AgentHarnessService>;

package/dist/src/provider.js

@@ -0,0 +1,194 @@
+// @bun
+// packages/contracts/src/provider.ts
+import { Schema as Schema4 } from "effect";
+
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// 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/model.ts
+import { Schema as Schema2 } from "effect";
+var ModelSlug = Schema2.String;
+var ProviderModelOptions = Schema2.Record(Schema2.String, Schema2.Unknown);
+
+// packages/contracts/src/orchestration.ts
+import { Schema as Schema3 } from "effect";
+var ProviderKind = Schema3.Literals(["codex", "claude"]);
+var ProviderApprovalPolicy = Schema3.Literals([
+  "untrusted",
+  "on-failure",
+  "on-request",
+  "never"
+]);
+var ProviderSandboxMode = Schema3.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var ProviderServiceTier = Schema3.Literals(["fast", "flex"]);
+var RuntimeMode = Schema3.Literals(["approval-required", "full-access"]);
+var ProviderInteractionMode = Schema3.Literals(["default", "plan"]);
+var ProviderRequestKind = Schema3.Literals(["command", "file-read", "file-change"]);
+var ProviderApprovalDecision = Schema3.Literals([
+  "accept",
+  "acceptForSession",
+  "decline",
+  "cancel"
+]);
+var ProviderUserInputAnswers = Schema3.Record(Schema3.String, Schema3.Unknown);
+var PROVIDER_SEND_TURN_MAX_INPUT_CHARS = 120000;
+var PROVIDER_SEND_TURN_MAX_ATTACHMENTS = 8;
+var PROVIDER_SEND_TURN_MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+var CHAT_ATTACHMENT_ID_MAX_CHARS = 128;
+var ChatAttachmentId = TrimmedNonEmptyString.check(Schema3.isMaxLength(CHAT_ATTACHMENT_ID_MAX_CHARS), Schema3.isPattern(/^[a-z0-9_-]+$/i));
+var ChatImageAttachment = Schema3.Struct({
+  type: Schema3.Literal("image"),
+  id: ChatAttachmentId,
+  name: TrimmedNonEmptyString.check(Schema3.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema3.isMaxLength(100), Schema3.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema3.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES))
+});
+var ChatAttachment = Schema3.Union([ChatImageAttachment]);
+
+// packages/contracts/src/provider.ts
+var TrimmedNonEmptyStringSchema = TrimmedNonEmptyString;
+var ProviderSessionStatus = Schema4.Literals([
+  "connecting",
+  "ready",
+  "running",
+  "error",
+  "closed"
+]);
+var ProviderSession = Schema4.Struct({
+  provider: ProviderKind,
+  status: ProviderSessionStatus,
+  runtimeMode: RuntimeMode,
+  cwd: Schema4.optional(TrimmedNonEmptyStringSchema),
+  model: Schema4.optional(TrimmedNonEmptyStringSchema),
+  threadId: ThreadId,
+  resumeCursor: Schema4.optional(Schema4.Unknown),
+  activeTurnId: Schema4.optional(TurnId),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  lastError: Schema4.optional(TrimmedNonEmptyStringSchema)
+});
+var CodexProviderStartOptions = Schema4.Struct({
+  binaryPath: Schema4.optional(TrimmedNonEmptyStringSchema),
+  homePath: Schema4.optional(TrimmedNonEmptyStringSchema)
+});
+var ProviderStartOptions = Schema4.Struct({
+  codex: Schema4.optional(CodexProviderStartOptions)
+});
+var ProviderSessionStartInput = Schema4.Struct({
+  threadId: ThreadId,
+  provider: Schema4.optional(ProviderKind),
+  cwd: Schema4.optional(TrimmedNonEmptyStringSchema),
+  model: Schema4.optional(TrimmedNonEmptyStringSchema),
+  modelOptions: Schema4.optional(ProviderModelOptions),
+  resumeCursor: Schema4.optional(Schema4.Unknown),
+  serviceTier: Schema4.optional(Schema4.NullOr(ProviderServiceTier)),
+  approvalPolicy: Schema4.optional(ProviderApprovalPolicy),
+  sandboxMode: Schema4.optional(ProviderSandboxMode),
+  providerOptions: Schema4.optional(ProviderStartOptions),
+  runtimeMode: RuntimeMode
+});
+var ProviderSendTurnInput = Schema4.Struct({
+  threadId: ThreadId,
+  input: Schema4.optional(TrimmedNonEmptyStringSchema.check(Schema4.isMaxLength(PROVIDER_SEND_TURN_MAX_INPUT_CHARS))),
+  attachments: Schema4.optional(Schema4.Array(ChatAttachment).check(Schema4.isMaxLength(PROVIDER_SEND_TURN_MAX_ATTACHMENTS))),
+  model: Schema4.optional(TrimmedNonEmptyStringSchema),
+  serviceTier: Schema4.optional(Schema4.NullOr(ProviderServiceTier)),
+  modelOptions: Schema4.optional(ProviderModelOptions),
+  interactionMode: Schema4.optional(ProviderInteractionMode)
+});
+var ProviderTurnStartResult = Schema4.Struct({
+  threadId: ThreadId,
+  turnId: TurnId,
+  resumeCursor: Schema4.optional(Schema4.Unknown)
+});
+var ProviderInterruptTurnInput = Schema4.Struct({
+  threadId: ThreadId,
+  turnId: Schema4.optional(TurnId)
+});
+var ProviderStopSessionInput = Schema4.Struct({
+  threadId: ThreadId
+});
+var ProviderRespondToRequestInput = Schema4.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision
+});
+var ProviderRespondToUserInputInput = Schema4.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers
+});
+var ProviderEventKind = Schema4.Literals(["session", "notification", "request", "error"]);
+var ProviderEvent = Schema4.Struct({
+  id: EventId,
+  kind: ProviderEventKind,
+  provider: ProviderKind,
+  threadId: ThreadId,
+  createdAt: IsoDateTime,
+  method: TrimmedNonEmptyStringSchema,
+  message: Schema4.optional(TrimmedNonEmptyStringSchema),
+  turnId: Schema4.optional(TurnId),
+  itemId: Schema4.optional(ProviderItemId),
+  requestId: Schema4.optional(ApprovalRequestId),
+  requestKind: Schema4.optional(ProviderRequestKind),
+  textDelta: Schema4.optional(Schema4.String),
+  payload: Schema4.optional(Schema4.Unknown)
+});
+var AGENT_HARNESS_CAPABILITY_ID = "rig.provider.agent-harness";
+var AGENT_HARNESS = makeCapabilityId(AGENT_HARNESS_CAPABILITY_ID);
+export {
+  ProviderTurnStartResult,
+  ProviderStopSessionInput,
+  ProviderSessionStartInput,
+  ProviderSession,
+  ProviderSendTurnInput,
+  ProviderRespondToUserInputInput,
+  ProviderRespondToRequestInput,
+  ProviderInterruptTurnInput,
+  ProviderEvent,
+  AGENT_HARNESS_CAPABILITY_ID,
+  AGENT_HARNESS
+};

package/dist/src/remote-control.d.ts

@@ -0,0 +1,93 @@
+import type { CapabilityId } from "./capability-id";
+export type RemoteControlEnv = Readonly<Record<string, string | undefined>>;
+export type RemoteControlJsonRecord = Record<string, unknown>;
+export type RemoteControlMessage = {
+    readonly type: string;
+    readonly id?: string;
+    readonly timestamp?: string;
+} & RemoteControlJsonRecord;
+export type RemoteControlEndpointSelection = {
+    readonly projectRoot: string;
+    readonly host?: string | undefined;
+    readonly port?: string | undefined;
+    readonly token?: string | undefined;
+    readonly remoteAlias?: string | undefined;
+    readonly env?: RemoteControlEnv | undefined;
+};
+export type RemoteControlRemote = {
+    readonly source: "flags" | "alias" | "env";
+    readonly alias?: string | undefined;
+    readonly host: string;
+    readonly port: number;
+};
+export type RemoteControlEndpoint = RemoteControlRemote & {
+    readonly token: string;
+};
+export type RemoteControlEvent = {
+    readonly receivedAt: string;
+    readonly message: RemoteControlMessage;
+};
+export type RemoteControlWatchEvent = RemoteControlEvent & {
+    readonly summary: string;
+};
+export type RemoteControlOperationResult = {
+    readonly remote: RemoteControlRemote;
+    readonly response: RemoteControlMessage;
+};
+export type RemoteControlEndpointTestResult = RemoteControlOperationResult & {
+    readonly latencyMs: number;
+};
+export type RemoteControlWatchOptions = RemoteControlEndpointSelection & {
+    readonly eventType?: string | undefined;
+    readonly seconds?: number | undefined;
+    readonly maxCaptured?: number | undefined;
+    readonly shouldStop?: (() => boolean) | undefined;
+    readonly onEvent?: ((event: RemoteControlWatchEvent) => void) | undefined;
+};
+export type RemoteControlWatchResult = {
+    readonly remote: RemoteControlRemote;
+    readonly received: number;
+    readonly dropped: number;
+    readonly captured: readonly RemoteControlMessage[];
+    readonly event: string | null;
+    readonly seconds: number | null;
+};
+export type RemoteControlStartOrchestrationOptions = {
+    readonly maxWorkers?: number | undefined;
+    readonly maxIterations?: number | undefined;
+    readonly directMerge?: boolean | undefined;
+};
+export interface RemoteControlClient {
+    readonly remote: RemoteControlRemote;
+    readonly ping: () => Promise<RemoteControlMessage>;
+    readonly getState: () => Promise<RemoteControlMessage>;
+    readonly getTasks: () => Promise<RemoteControlMessage>;
+    readonly pause: () => Promise<RemoteControlMessage>;
+    readonly resume: () => Promise<RemoteControlMessage>;
+    readonly stop: () => Promise<RemoteControlMessage>;
+    readonly continueExecution: () => Promise<RemoteControlMessage>;
+    readonly refreshTasks: () => Promise<RemoteControlMessage>;
+    readonly addIterations: (count: number) => Promise<RemoteControlMessage>;
+    readonly removeIterations: (count: number) => Promise<RemoteControlMessage>;
+    readonly getPromptPreview: (taskId: string) => Promise<RemoteControlMessage>;
+    readonly getIterationOutput: (taskId: string) => Promise<RemoteControlMessage>;
+    readonly startOrchestration: (options: RemoteControlStartOrchestrationOptions) => Promise<RemoteControlMessage>;
+    readonly pauseOrchestration: (orchestrationId: string) => Promise<RemoteControlMessage>;
+    readonly resumeOrchestration: (orchestrationId: string) => Promise<RemoteControlMessage>;
+    readonly stopOrchestration: (orchestrationId: string) => Promise<RemoteControlMessage>;
+    readonly getOrchestrationState: (orchestrationId: string) => Promise<RemoteControlMessage>;
+}
+export interface RemoteControlService {
+    readonly resolveEndpoint: (input: RemoteControlEndpointSelection) => RemoteControlRemote;
+    readonly withClient: <T>(input: RemoteControlEndpointSelection, runner: (client: RemoteControlClient) => Promise<T>) => Promise<T>;
+    readonly testEndpoint: (input: RemoteControlEndpointSelection) => Promise<RemoteControlEndpointTestResult>;
+    readonly watch: (input: RemoteControlWatchOptions) => Promise<RemoteControlWatchResult>;
+}
+export declare class RemoteControlError extends Error {
+    readonly code: string;
+    readonly exitCode: number;
+    readonly details: RemoteControlJsonRecord | undefined;
+    constructor(code: string, message: string, exitCode?: number, details?: RemoteControlJsonRecord);
+}
+export declare const REMOTE_CONTROL_CAPABILITY_ID = "rig.remote.control";
+export declare const REMOTE_CONTROL: CapabilityId<RemoteControlService>;

package/dist/src/remote-control.js

@@ -0,0 +1,26 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/remote-control.ts
+class RemoteControlError extends Error {
+  code;
+  exitCode;
+  details;
+  constructor(code, message, exitCode = 1, details) {
+    super(message);
+    this.name = "RemoteControlError";
+    this.code = code;
+    this.exitCode = exitCode;
+    this.details = details;
+  }
+}
+var REMOTE_CONTROL_CAPABILITY_ID = "rig.remote.control";
+var REMOTE_CONTROL = makeCapabilityId(REMOTE_CONTROL_CAPABILITY_ID);
+export {
+  RemoteControlError,
+  REMOTE_CONTROL_CAPABILITY_ID,
+  REMOTE_CONTROL
+};