@h-rig/contracts 0.0.6-alpha.77 → 0.0.6-alpha.79

package/dist/src/runtime.d.ts

@@ -0,0 +1,103 @@
+import { Schema } from "effect";
+export declare const RunKind: Schema.Literals<readonly ["adhoc", "task", "batch", "validation", "review"]>;
+export type RunKind = typeof RunKind.Type;
+export declare const RunMode: Schema.Literals<readonly ["interactive", "autonomous", "supervised"]>;
+export type RunMode = typeof RunMode.Type;
+export declare const RunStatus: Schema.Literals<readonly ["created", "queued", "preparing", "running", "waiting-approval", "waiting-user-input", "paused", "validating", "reviewing", "closing-out", "needs-attention", "completed", "failed", "stopped"]>;
+export type RunStatus = typeof RunStatus.Type;
+export declare const EngineSandboxMode: Schema.Literals<readonly ["read-only", "workspace-write", "danger-full-access"]>;
+export type EngineSandboxMode = typeof EngineSandboxMode.Type;
+export declare const IsolationMode: Schema.Literals<readonly ["none", "env", "worktree"]>;
+export type IsolationMode = typeof IsolationMode.Type;
+export declare const RuntimeStatus: Schema.Literals<readonly ["prepared", "starting", "running", "interrupted", "exited", "failed", "destroyed"]>;
+export type RuntimeStatus = typeof RuntimeStatus.Type;
+export declare const RunExecutionTarget: Schema.Literals<readonly ["local", "remote"]>;
+export type RunExecutionTarget = typeof RunExecutionTarget.Type;
+export declare const RunSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "RunId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly title: Schema.Trim;
+    readonly runKind: Schema.Literals<readonly ["adhoc", "task", "batch", "validation", "review"]>;
+    readonly mode: Schema.Literals<readonly ["interactive", "autonomous", "supervised"]>;
+    readonly runtimeMode: Schema.Literals<readonly ["approval-required", "full-access"]>;
+    readonly interactionMode: Schema.Literals<readonly ["default", "plan"]>;
+    readonly status: Schema.Literals<readonly ["created", "queued", "preparing", "running", "waiting-approval", "waiting-user-input", "paused", "validating", "reviewing", "closing-out", "needs-attention", "completed", "failed", "stopped"]>;
+    readonly runtimeAdapter: Schema.Trim;
+    readonly model: Schema.NullOr<Schema.Trim>;
+    readonly initialPrompt: Schema.NullOr<Schema.String>;
+    readonly executionTarget: Schema.optional<Schema.Literals<readonly ["local", "remote"]>>;
+    readonly remoteHostId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly remoteLeaseId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly remoteLeaseClaimedAt: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly activeRuntimeId: Schema.NullOr<Schema.brand<Schema.Trim, "EngineRuntimeId">>;
+    readonly latestMessageId: Schema.NullOr<Schema.Trim>;
+    readonly pendingApprovalCount: Schema.Int;
+    readonly pendingUserInputCount: Schema.Int;
+    readonly branch: Schema.NullOr<Schema.Trim>;
+    readonly worktreePath: Schema.NullOr<Schema.Trim>;
+    readonly errorText: Schema.NullOr<Schema.String>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly startedAt: Schema.NullOr<Schema.String>;
+    readonly completedAt: Schema.NullOr<Schema.String>;
+}>;
+export type RunSummary = typeof RunSummary.Type;
+export declare const RuntimeSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "EngineRuntimeId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly adapterKind: Schema.Trim;
+    readonly executionTarget: Schema.optional<Schema.Literals<readonly ["local", "remote"]>>;
+    readonly remoteHostId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly status: Schema.Literals<readonly ["prepared", "starting", "running", "interrupted", "exited", "failed", "destroyed"]>;
+    readonly sandboxMode: Schema.Literals<readonly ["read-only", "workspace-write", "danger-full-access"]>;
+    readonly isolationMode: Schema.Literals<readonly ["none", "env", "worktree"]>;
+    readonly workspaceDir: Schema.NullOr<Schema.Trim>;
+    readonly homeDir: Schema.NullOr<Schema.Trim>;
+    readonly tmpDir: Schema.NullOr<Schema.Trim>;
+    readonly cacheDir: Schema.NullOr<Schema.Trim>;
+    readonly logsDir: Schema.NullOr<Schema.Trim>;
+    readonly stateDir: Schema.NullOr<Schema.Trim>;
+    readonly sessionDir: Schema.NullOr<Schema.Trim>;
+    readonly sessionLogPath: Schema.NullOr<Schema.Trim>;
+    readonly pid: Schema.NullOr<Schema.Int>;
+    readonly startedAt: Schema.NullOr<Schema.String>;
+    readonly updatedAt: Schema.String;
+    readonly exitedAt: Schema.NullOr<Schema.String>;
+}>;
+export type RuntimeSummary = typeof RuntimeSummary.Type;
+export declare const ApprovalStatus: Schema.Literals<readonly ["pending", "resolved"]>;
+export type ApprovalStatus = typeof ApprovalStatus.Type;
+export declare const ApprovalSummary: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly actionId: Schema.NullOr<Schema.Trim>;
+    readonly requestKind: Schema.Trim;
+    readonly status: Schema.Literals<readonly ["pending", "resolved"]>;
+    readonly payload: Schema.Unknown;
+    readonly createdAt: Schema.String;
+    readonly resolvedAt: Schema.NullOr<Schema.String>;
+}>;
+export type ApprovalSummary = typeof ApprovalSummary.Type;
+export declare const UserInputRequestSummary: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly status: Schema.Literals<readonly ["pending", "resolved"]>;
+    readonly payload: Schema.Unknown;
+    readonly createdAt: Schema.String;
+    readonly resolvedAt: Schema.NullOr<Schema.String>;
+}>;
+export type UserInputRequestSummary = typeof UserInputRequestSummary.Type;
+export declare const WorktreeSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "WorktreeId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly branchName: Schema.Trim;
+    readonly path: Schema.Trim;
+    readonly status: Schema.Trim;
+    readonly createdAt: Schema.String;
+    readonly cleanedAt: Schema.NullOr<Schema.String>;
+}>;
+export type WorktreeSummary = typeof WorktreeSummary.Type;

package/dist/src/server.d.ts

@@ -0,0 +1,106 @@
+import { Schema } from "effect";
+export declare const ServerConfigIssue: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"keybindings.malformed-config">;
+    readonly message: Schema.Trim;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"keybindings.invalid-entry">;
+    readonly message: Schema.Trim;
+    readonly index: Schema.Number;
+}>]>;
+export type ServerConfigIssue = typeof ServerConfigIssue.Type;
+export declare const ServerProviderStatusState: Schema.Literals<readonly ["ready", "warning", "error"]>;
+export type ServerProviderStatusState = typeof ServerProviderStatusState.Type;
+export declare const ServerProviderAuthStatus: Schema.Literals<readonly ["authenticated", "unauthenticated", "unknown"]>;
+export type ServerProviderAuthStatus = typeof ServerProviderAuthStatus.Type;
+export declare const ServerProviderStatus: Schema.Struct<{
+    readonly provider: Schema.Literals<readonly ["codex", "claude"]>;
+    readonly status: Schema.Literals<readonly ["ready", "warning", "error"]>;
+    readonly available: Schema.Boolean;
+    readonly authStatus: Schema.Literals<readonly ["authenticated", "unauthenticated", "unknown"]>;
+    readonly checkedAt: Schema.String;
+    readonly message: Schema.optional<Schema.Trim>;
+}>;
+export type ServerProviderStatus = typeof ServerProviderStatus.Type;
+export declare const ServerConfig: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly rigRoot: Schema.NullOr<Schema.Trim>;
+    readonly keybindingsConfigPath: Schema.Trim;
+    readonly keybindings: Schema.$Array<Schema.Struct<{
+        readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+        readonly shortcut: Schema.Struct<{
+            readonly key: Schema.Trim;
+            readonly metaKey: Schema.Boolean;
+            readonly ctrlKey: Schema.Boolean;
+            readonly shiftKey: Schema.Boolean;
+            readonly altKey: Schema.Boolean;
+            readonly modKey: Schema.Boolean;
+        }>;
+        readonly whenAst: Schema.optional<Schema.Schema<import("./keybindings").KeybindingWhenNode>>;
+    }>>;
+    readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.malformed-config">;
+        readonly message: Schema.Trim;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.invalid-entry">;
+        readonly message: Schema.Trim;
+        readonly index: Schema.Number;
+    }>]>>;
+    readonly providers: Schema.$Array<Schema.Struct<{
+        readonly provider: Schema.Literals<readonly ["codex", "claude"]>;
+        readonly status: Schema.Literals<readonly ["ready", "warning", "error"]>;
+        readonly available: Schema.Boolean;
+        readonly authStatus: Schema.Literals<readonly ["authenticated", "unauthenticated", "unknown"]>;
+        readonly checkedAt: Schema.String;
+        readonly message: Schema.optional<Schema.Trim>;
+    }>>;
+    readonly availableEditors: Schema.$Array<Schema.Literals<("cursor" | "vscode" | "zed" | "file-manager")[]>>;
+}>;
+export type ServerConfig = typeof ServerConfig.Type;
+export declare const ServerUpsertKeybindingInput: Schema.Struct<{
+    readonly key: Schema.Trim;
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+    readonly when: Schema.optional<Schema.Trim>;
+}>;
+export type ServerUpsertKeybindingInput = typeof ServerUpsertKeybindingInput.Type;
+export declare const ServerUpsertKeybindingResult: Schema.Struct<{
+    readonly keybindings: Schema.$Array<Schema.Struct<{
+        readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+        readonly shortcut: Schema.Struct<{
+            readonly key: Schema.Trim;
+            readonly metaKey: Schema.Boolean;
+            readonly ctrlKey: Schema.Boolean;
+            readonly shiftKey: Schema.Boolean;
+            readonly altKey: Schema.Boolean;
+            readonly modKey: Schema.Boolean;
+        }>;
+        readonly whenAst: Schema.optional<Schema.Schema<import("./keybindings").KeybindingWhenNode>>;
+    }>>;
+    readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.malformed-config">;
+        readonly message: Schema.Trim;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.invalid-entry">;
+        readonly message: Schema.Trim;
+        readonly index: Schema.Number;
+    }>]>>;
+}>;
+export type ServerUpsertKeybindingResult = typeof ServerUpsertKeybindingResult.Type;
+export declare const ServerConfigUpdatedPayload: Schema.Struct<{
+    readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.malformed-config">;
+        readonly message: Schema.Trim;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.invalid-entry">;
+        readonly message: Schema.Trim;
+        readonly index: Schema.Number;
+    }>]>>;
+    readonly providers: Schema.$Array<Schema.Struct<{
+        readonly provider: Schema.Literals<readonly ["codex", "claude"]>;
+        readonly status: Schema.Literals<readonly ["ready", "warning", "error"]>;
+        readonly available: Schema.Boolean;
+        readonly authStatus: Schema.Literals<readonly ["authenticated", "unauthenticated", "unknown"]>;
+        readonly checkedAt: Schema.String;
+        readonly message: Schema.optional<Schema.Trim>;
+    }>>;
+}>;
+export type ServerConfigUpdatedPayload = typeof ServerConfigUpdatedPayload.Type;

package/dist/src/serviceFabric.d.ts

@@ -0,0 +1,62 @@
+import { Schema } from "effect";
+export declare const ServiceFabricWorkspaceInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+}>;
+export type ServiceFabricWorkspaceInput = typeof ServiceFabricWorkspaceInput.Type;
+export declare const ServiceFabricUpInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly services: Schema.optional<Schema.$Array<Schema.Trim>>;
+}>;
+export type ServiceFabricUpInput = typeof ServiceFabricUpInput.Type;
+export declare const ServiceFabricUpResult: Schema.Struct<{
+    readonly plan: Schema.Struct<{
+        readonly generatedAt: Schema.String;
+        readonly serviceCount: Schema.Number;
+        readonly services: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.Trim;
+            readonly relativeRootPath: Schema.Trim;
+            readonly absoluteRootPath: Schema.Trim;
+            readonly port: Schema.Number;
+            readonly healthcheck: Schema.Trim;
+            readonly routePrefix: Schema.NullOr<Schema.Trim>;
+            readonly mode: Schema.Literals<readonly ["stub", "process"]>;
+            readonly command: Schema.NullOr<Schema.String>;
+            readonly environment: Schema.Unknown;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.String>;
+    }>;
+    readonly state: Schema.Struct<{
+        readonly generatedAt: Schema.String;
+        readonly rootPath: Schema.Trim;
+        readonly services: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.Trim;
+            readonly pid: Schema.Number;
+            readonly mode: Schema.Literals<readonly ["stub", "process"]>;
+            readonly port: Schema.Number;
+            readonly healthcheck: Schema.Trim;
+            readonly routePrefix: Schema.NullOr<Schema.Trim>;
+            readonly relativeRootPath: Schema.Trim;
+            readonly logPath: Schema.Trim;
+        }>>;
+    }>;
+    readonly summary: Schema.Struct<{
+        readonly updatedAt: Schema.String;
+        readonly status: Schema.Literals<readonly ["empty", "booting", "ready", "degraded", "stopped"]>;
+        readonly serviceCount: Schema.Number;
+        readonly healthyServiceCount: Schema.Number;
+        readonly stateDir: Schema.Trim;
+        readonly services: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.Trim;
+            readonly relativeRootPath: Schema.Trim;
+            readonly mode: Schema.Literals<readonly ["stub", "process"]>;
+            readonly port: Schema.Number;
+            readonly healthcheck: Schema.Trim;
+            readonly routePrefix: Schema.NullOr<Schema.Trim>;
+            readonly status: Schema.Literals<readonly ["planned", "booting", "healthy", "degraded", "failed", "stopped"]>;
+            readonly pid: Schema.NullOr<Schema.Number>;
+            readonly logPath: Schema.NullOr<Schema.Trim>;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.String>;
+    }>;
+}>;
+export type ServiceFabricUpResult = typeof ServiceFabricUpResult.Type;

package/dist/src/task-source.d.ts

@@ -0,0 +1,28 @@
+import type { TaskSourceRegistration } from "./plugin";
+/**
+ * A single task record returned by a task source adapter.
+ * Open-ended to allow adapters to include source-specific fields.
+ */
+export interface TaskRecord {
+    id: string;
+    deps: readonly string[];
+    status: "ready" | "in_progress" | "closed" | "blocked" | "open" | string;
+    [extra: string]: unknown;
+}
+/**
+ * A registered task source adapter — combines the plugin-level registration
+ * metadata with the runtime-callable interface.
+ */
+export interface TaskSourceUpdate {
+    status?: TaskRecord["status"];
+    title?: string;
+    body?: string;
+    comment?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RegisteredTaskSource extends TaskSourceRegistration {
+    list(): Promise<readonly TaskRecord[]>;
+    get?(id: string): Promise<TaskRecord | undefined>;
+    updateStatus?(id: string, status: TaskRecord["status"]): Promise<void>;
+    updateTask?(id: string, update: TaskSourceUpdate): Promise<void>;
+}

package/dist/src/terminal.d.ts

@@ -0,0 +1,130 @@
+import { Schema } from "effect";
+export declare const DEFAULT_TERMINAL_ID = "default";
+export declare const TerminalThreadInput: Schema.Struct<{
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalThreadInput = Schema.Codec.Encoded<typeof TerminalThreadInput>;
+declare const TerminalSessionInput: Schema.Struct<{
+    readonly terminalId: Schema.withDecodingDefault<Schema.Trim>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalSessionInput = Schema.Codec.Encoded<typeof TerminalSessionInput>;
+export declare const TerminalOpenInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly cols: Schema.optional<Schema.Int>;
+    readonly rows: Schema.optional<Schema.Int>;
+    readonly env: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly terminalId: Schema.withDecodingDefault<Schema.Trim>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalOpenInput = Schema.Codec.Encoded<typeof TerminalOpenInput>;
+export declare const TerminalWriteInput: Schema.Struct<{
+    readonly data: Schema.String;
+    readonly terminalId: Schema.withDecodingDefault<Schema.Trim>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalWriteInput = Schema.Codec.Encoded<typeof TerminalWriteInput>;
+export declare const TerminalResizeInput: Schema.Struct<{
+    readonly cols: Schema.Int;
+    readonly rows: Schema.Int;
+    readonly terminalId: Schema.withDecodingDefault<Schema.Trim>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalResizeInput = Schema.Codec.Encoded<typeof TerminalResizeInput>;
+export declare const TerminalClearInput: Schema.Struct<{
+    readonly terminalId: Schema.withDecodingDefault<Schema.Trim>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalClearInput = Schema.Codec.Encoded<typeof TerminalClearInput>;
+export declare const TerminalRestartInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly cols: Schema.Int;
+    readonly rows: Schema.Int;
+    readonly env: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly threadId: Schema.Trim;
+}>;
+export declare const TerminalCloseInput: Schema.Struct<{
+    readonly terminalId: Schema.optional<Schema.Trim>;
+    readonly deleteHistory: Schema.optional<Schema.Boolean>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalCloseInput = Schema.Codec.Encoded<typeof TerminalCloseInput>;
+export declare const TerminalSessionStatus: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+export type TerminalSessionStatus = typeof TerminalSessionStatus.Type;
+export declare const TerminalSessionSnapshot: Schema.Struct<{
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly cwd: Schema.String;
+    readonly status: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+    readonly pid: Schema.NullOr<Schema.Int>;
+    readonly history: Schema.String;
+    readonly exitCode: Schema.NullOr<Schema.Int>;
+    readonly exitSignal: Schema.NullOr<Schema.String>;
+    readonly updatedAt: Schema.String;
+}>;
+export type TerminalSessionSnapshot = typeof TerminalSessionSnapshot.Type;
+export declare const TerminalEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"started">;
+    readonly snapshot: Schema.Struct<{
+        readonly threadId: Schema.String;
+        readonly terminalId: Schema.String;
+        readonly cwd: Schema.String;
+        readonly status: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+        readonly pid: Schema.NullOr<Schema.Int>;
+        readonly history: Schema.String;
+        readonly exitCode: Schema.NullOr<Schema.Int>;
+        readonly exitSignal: Schema.NullOr<Schema.String>;
+        readonly updatedAt: Schema.String;
+    }>;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"output">;
+    readonly data: Schema.String;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"exited">;
+    readonly exitCode: Schema.NullOr<Schema.Int>;
+    readonly exitSignal: Schema.NullOr<Schema.String>;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"error">;
+    readonly message: Schema.String;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"cleared">;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"restarted">;
+    readonly snapshot: Schema.Struct<{
+        readonly threadId: Schema.String;
+        readonly terminalId: Schema.String;
+        readonly cwd: Schema.String;
+        readonly status: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+        readonly pid: Schema.NullOr<Schema.Int>;
+        readonly history: Schema.String;
+        readonly exitCode: Schema.NullOr<Schema.Int>;
+        readonly exitSignal: Schema.NullOr<Schema.String>;
+        readonly updatedAt: Schema.String;
+    }>;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"activity">;
+    readonly hasRunningSubprocess: Schema.Boolean;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>]>;
+export type TerminalEvent = typeof TerminalEvent.Type;
+export {};

package/dist/src/validation.d.ts

@@ -0,0 +1,14 @@
+import { Schema } from "effect";
+export declare const ValidationStatus: Schema.Literals<readonly ["pending", "running", "passed", "failed", "skipped"]>;
+export type ValidationStatus = typeof ValidationStatus.Type;
+export declare const ValidationSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "ValidationResultId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly validatorKey: Schema.Trim;
+    readonly status: Schema.Literals<readonly ["pending", "running", "passed", "failed", "skipped"]>;
+    readonly output: Schema.Unknown;
+    readonly startedAt: Schema.String;
+    readonly completedAt: Schema.NullOr<Schema.String>;
+}>;
+export type ValidationSummary = typeof ValidationSummary.Type;

package/dist/src/workspace.d.ts

@@ -0,0 +1,204 @@
+import { Schema } from "effect";
+export declare const WorkspaceSourceKind: Schema.Literals<readonly ["native", "rig-import", "manual", "remote"]>;
+export type WorkspaceSourceKind = typeof WorkspaceSourceKind.Type;
+export declare const WorkspaceTopologyStatus: Schema.Literals<readonly ["empty", "ready", "degraded"]>;
+export type WorkspaceTopologyStatus = typeof WorkspaceTopologyStatus.Type;
+export declare const WorkspaceRemoteFleetStatus: Schema.Literals<readonly ["empty", "ready", "degraded"]>;
+export type WorkspaceRemoteFleetStatus = typeof WorkspaceRemoteFleetStatus.Type;
+export declare const WorkspaceServiceFabricStatus: Schema.Literals<readonly ["empty", "booting", "ready", "degraded", "stopped"]>;
+export type WorkspaceServiceFabricStatus = typeof WorkspaceServiceFabricStatus.Type;
+export declare const WorkspaceRemoteHostStatus: Schema.Literals<readonly ["registering", "ready", "busy", "degraded", "draining", "offline", "quarantined"]>;
+export type WorkspaceRemoteHostStatus = typeof WorkspaceRemoteHostStatus.Type;
+export declare const WorkspaceTopologyServiceSummary: Schema.Struct<{
+    readonly name: Schema.Trim;
+    readonly relativeRootPath: Schema.Trim;
+    readonly runtime: Schema.Trim;
+    readonly port: Schema.NullOr<Schema.Number>;
+    readonly healthcheck: Schema.NullOr<Schema.Trim>;
+    readonly sourceOfTruth: Schema.Struct<{
+        readonly code: Schema.NullOr<Schema.Trim>;
+        readonly tests: Schema.NullOr<Schema.Trim>;
+        readonly infra: Schema.NullOr<Schema.Trim>;
+        readonly deploy: Schema.NullOr<Schema.Trim>;
+        readonly dependencies: Schema.NullOr<Schema.Trim>;
+    }>;
+    readonly splitReadyChecklist: Schema.$Array<Schema.Trim>;
+}>;
+export type WorkspaceTopologyServiceSummary = typeof WorkspaceTopologyServiceSummary.Type;
+export declare const WorkspaceTopologySummary: Schema.Struct<{
+    readonly compiledAt: Schema.String;
+    readonly status: Schema.Literals<readonly ["empty", "ready", "degraded"]>;
+    readonly manifestCount: Schema.Number;
+    readonly serviceCount: Schema.Number;
+    readonly services: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.Trim;
+        readonly relativeRootPath: Schema.Trim;
+        readonly runtime: Schema.Trim;
+        readonly port: Schema.NullOr<Schema.Number>;
+        readonly healthcheck: Schema.NullOr<Schema.Trim>;
+        readonly sourceOfTruth: Schema.Struct<{
+            readonly code: Schema.NullOr<Schema.Trim>;
+            readonly tests: Schema.NullOr<Schema.Trim>;
+            readonly infra: Schema.NullOr<Schema.Trim>;
+            readonly deploy: Schema.NullOr<Schema.Trim>;
+            readonly dependencies: Schema.NullOr<Schema.Trim>;
+        }>;
+        readonly splitReadyChecklist: Schema.$Array<Schema.Trim>;
+    }>>;
+    readonly warnings: Schema.$Array<Schema.String>;
+}>;
+export type WorkspaceTopologySummary = typeof WorkspaceTopologySummary.Type;
+export declare const WorkspaceRemoteHostSummary: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly name: Schema.Trim;
+    readonly baseUrl: Schema.Trim;
+    readonly workspacePath: Schema.NullOr<Schema.Trim>;
+    readonly transport: Schema.Trim;
+    readonly hostname: Schema.NullOr<Schema.Trim>;
+    readonly region: Schema.NullOr<Schema.Trim>;
+    readonly labels: Schema.$Array<Schema.Trim>;
+    readonly capabilities: Schema.$Array<Schema.Trim>;
+    readonly runtimeAdapters: Schema.$Array<Schema.Trim>;
+    readonly status: Schema.Literals<readonly ["registering", "ready", "busy", "degraded", "draining", "offline", "quarantined"]>;
+    readonly currentLeaseCount: Schema.Number;
+    readonly lastHeartbeatAt: Schema.NullOr<Schema.String>;
+    readonly registeredAt: Schema.String;
+    readonly manifestPath: Schema.Trim;
+}>;
+export type WorkspaceRemoteHostSummary = typeof WorkspaceRemoteHostSummary.Type;
+export declare const WorkspaceRemoteFleetSummary: Schema.Struct<{
+    readonly updatedAt: Schema.String;
+    readonly status: Schema.Literals<readonly ["empty", "ready", "degraded"]>;
+    readonly manifestCount: Schema.Number;
+    readonly hostCount: Schema.Number;
+    readonly onlineHostCount: Schema.Number;
+    readonly hosts: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly name: Schema.Trim;
+        readonly baseUrl: Schema.Trim;
+        readonly workspacePath: Schema.NullOr<Schema.Trim>;
+        readonly transport: Schema.Trim;
+        readonly hostname: Schema.NullOr<Schema.Trim>;
+        readonly region: Schema.NullOr<Schema.Trim>;
+        readonly labels: Schema.$Array<Schema.Trim>;
+        readonly capabilities: Schema.$Array<Schema.Trim>;
+        readonly runtimeAdapters: Schema.$Array<Schema.Trim>;
+        readonly status: Schema.Literals<readonly ["registering", "ready", "busy", "degraded", "draining", "offline", "quarantined"]>;
+        readonly currentLeaseCount: Schema.Number;
+        readonly lastHeartbeatAt: Schema.NullOr<Schema.String>;
+        readonly registeredAt: Schema.String;
+        readonly manifestPath: Schema.Trim;
+    }>>;
+    readonly warnings: Schema.$Array<Schema.String>;
+}>;
+export type WorkspaceRemoteFleetSummary = typeof WorkspaceRemoteFleetSummary.Type;
+export declare const WorkspaceServiceFabricServiceSummary: Schema.Struct<{
+    readonly name: Schema.Trim;
+    readonly relativeRootPath: Schema.Trim;
+    readonly mode: Schema.Literals<readonly ["stub", "process"]>;
+    readonly port: Schema.Number;
+    readonly healthcheck: Schema.Trim;
+    readonly routePrefix: Schema.NullOr<Schema.Trim>;
+    readonly status: Schema.Literals<readonly ["planned", "booting", "healthy", "degraded", "failed", "stopped"]>;
+    readonly pid: Schema.NullOr<Schema.Number>;
+    readonly logPath: Schema.NullOr<Schema.Trim>;
+}>;
+export type WorkspaceServiceFabricServiceSummary = typeof WorkspaceServiceFabricServiceSummary.Type;
+export declare const WorkspaceServiceFabricSummary: Schema.Struct<{
+    readonly updatedAt: Schema.String;
+    readonly status: Schema.Literals<readonly ["empty", "booting", "ready", "degraded", "stopped"]>;
+    readonly serviceCount: Schema.Number;
+    readonly healthyServiceCount: Schema.Number;
+    readonly stateDir: Schema.Trim;
+    readonly services: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.Trim;
+        readonly relativeRootPath: Schema.Trim;
+        readonly mode: Schema.Literals<readonly ["stub", "process"]>;
+        readonly port: Schema.Number;
+        readonly healthcheck: Schema.Trim;
+        readonly routePrefix: Schema.NullOr<Schema.Trim>;
+        readonly status: Schema.Literals<readonly ["planned", "booting", "healthy", "degraded", "failed", "stopped"]>;
+        readonly pid: Schema.NullOr<Schema.Number>;
+        readonly logPath: Schema.NullOr<Schema.Trim>;
+    }>>;
+    readonly warnings: Schema.$Array<Schema.String>;
+}>;
+export type WorkspaceServiceFabricSummary = typeof WorkspaceServiceFabricSummary.Type;
+export declare const WorkspaceSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly title: Schema.Trim;
+    readonly rootPath: Schema.Trim;
+    readonly sourceKind: Schema.Literals<readonly ["native", "rig-import", "manual", "remote"]>;
+    readonly defaultRuntimeAdapter: Schema.optional<Schema.Trim>;
+    readonly defaultProvider: Schema.optional<Schema.Literals<readonly ["codex", "claude"]>>;
+    readonly defaultModel: Schema.NullOr<Schema.Trim>;
+    readonly topology: Schema.optional<Schema.Struct<{
+        readonly compiledAt: Schema.String;
+        readonly status: Schema.Literals<readonly ["empty", "ready", "degraded"]>;
+        readonly manifestCount: Schema.Number;
+        readonly serviceCount: Schema.Number;
+        readonly services: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.Trim;
+            readonly relativeRootPath: Schema.Trim;
+            readonly runtime: Schema.Trim;
+            readonly port: Schema.NullOr<Schema.Number>;
+            readonly healthcheck: Schema.NullOr<Schema.Trim>;
+            readonly sourceOfTruth: Schema.Struct<{
+                readonly code: Schema.NullOr<Schema.Trim>;
+                readonly tests: Schema.NullOr<Schema.Trim>;
+                readonly infra: Schema.NullOr<Schema.Trim>;
+                readonly deploy: Schema.NullOr<Schema.Trim>;
+                readonly dependencies: Schema.NullOr<Schema.Trim>;
+            }>;
+            readonly splitReadyChecklist: Schema.$Array<Schema.Trim>;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.String>;
+    }>>;
+    readonly remoteFleet: Schema.optional<Schema.Struct<{
+        readonly updatedAt: Schema.String;
+        readonly status: Schema.Literals<readonly ["empty", "ready", "degraded"]>;
+        readonly manifestCount: Schema.Number;
+        readonly hostCount: Schema.Number;
+        readonly onlineHostCount: Schema.Number;
+        readonly hosts: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.Trim;
+            readonly name: Schema.Trim;
+            readonly baseUrl: Schema.Trim;
+            readonly workspacePath: Schema.NullOr<Schema.Trim>;
+            readonly transport: Schema.Trim;
+            readonly hostname: Schema.NullOr<Schema.Trim>;
+            readonly region: Schema.NullOr<Schema.Trim>;
+            readonly labels: Schema.$Array<Schema.Trim>;
+            readonly capabilities: Schema.$Array<Schema.Trim>;
+            readonly runtimeAdapters: Schema.$Array<Schema.Trim>;
+            readonly status: Schema.Literals<readonly ["registering", "ready", "busy", "degraded", "draining", "offline", "quarantined"]>;
+            readonly currentLeaseCount: Schema.Number;
+            readonly lastHeartbeatAt: Schema.NullOr<Schema.String>;
+            readonly registeredAt: Schema.String;
+            readonly manifestPath: Schema.Trim;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.String>;
+    }>>;
+    readonly serviceFabric: Schema.optional<Schema.Struct<{
+        readonly updatedAt: Schema.String;
+        readonly status: Schema.Literals<readonly ["empty", "booting", "ready", "degraded", "stopped"]>;
+        readonly serviceCount: Schema.Number;
+        readonly healthyServiceCount: Schema.Number;
+        readonly stateDir: Schema.Trim;
+        readonly services: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.Trim;
+            readonly relativeRootPath: Schema.Trim;
+            readonly mode: Schema.Literals<readonly ["stub", "process"]>;
+            readonly port: Schema.Number;
+            readonly healthcheck: Schema.Trim;
+            readonly routePrefix: Schema.NullOr<Schema.Trim>;
+            readonly status: Schema.Literals<readonly ["planned", "booting", "healthy", "degraded", "failed", "stopped"]>;
+            readonly pid: Schema.NullOr<Schema.Number>;
+            readonly logPath: Schema.NullOr<Schema.Trim>;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.String>;
+    }>>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+}>;
+export type WorkspaceSummary = typeof WorkspaceSummary.Type;