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

package/dist/src/engine.d.ts

@@ -0,0 +1,2789 @@
+import { Schema } from "effect";
+export declare const EngineEvent: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "EventId">;
+    readonly sequence: Schema.Int;
+    readonly createdAt: Schema.String;
+    readonly type: Schema.Trim;
+    readonly aggregateId: Schema.Trim;
+    readonly payload: Schema.Unknown;
+}>;
+export type EngineEvent = typeof EngineEvent.Type;
+export declare const EngineReadModel: Schema.Struct<{
+    readonly snapshotSequence: Schema.Int;
+    readonly workspaces: Schema.$Array<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;
+    }>>;
+    readonly graphs: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "GraphId">;
+        readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+        readonly title: Schema.Trim;
+        readonly description: Schema.NullOr<Schema.String>;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+    }>>;
+    readonly tasks: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "TaskId">;
+        readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+        readonly graphId: Schema.NullOr<Schema.brand<Schema.Trim, "GraphId">>;
+        readonly externalId: Schema.NullOr<Schema.Trim>;
+        readonly title: Schema.Trim;
+        readonly description: Schema.String;
+        readonly status: Schema.Literals<readonly ["draft", "open", "ready", "queued", "running", "in_progress", "under_review", "blocked", "unknown", "completed", "failed", "cancelled", "closed"]>;
+        readonly priority: Schema.NullOr<Schema.Int>;
+        readonly role: Schema.NullOr<Schema.Trim>;
+        readonly scope: Schema.$Array<Schema.Trim>;
+        readonly validationKeys: Schema.$Array<Schema.Trim>;
+        readonly sourceIssueId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+        readonly dependencies: Schema.optional<Schema.$Array<Schema.Trim>>;
+        readonly parentChildDeps: Schema.optional<Schema.$Array<Schema.Trim>>;
+        readonly metadata: Schema.Unknown;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+    }>>;
+    readonly runs: Schema.$Array<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>;
+    }>>;
+    readonly runtimes: Schema.$Array<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>;
+    }>>;
+    readonly conversations: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "ConversationId">;
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly title: Schema.Trim;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+    }>>;
+    readonly messages: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "MessageId">;
+        readonly conversationId: Schema.brand<Schema.Trim, "ConversationId">;
+        readonly role: Schema.Literals<readonly ["user", "assistant", "system"]>;
+        readonly text: Schema.String;
+        readonly attachments: Schema.$Array<Schema.Unknown>;
+        readonly state: Schema.Literals<readonly ["streaming", "completed", "interrupted", "errored"]>;
+        readonly createdAt: Schema.String;
+        readonly completedAt: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly actions: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "ActionId">;
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly messageId: Schema.NullOr<Schema.brand<Schema.Trim, "MessageId">>;
+        readonly actionType: Schema.Trim;
+        readonly title: Schema.Trim;
+        readonly detail: Schema.NullOr<Schema.String>;
+        readonly state: Schema.Trim;
+        readonly payload: Schema.Unknown;
+        readonly startedAt: Schema.String;
+        readonly completedAt: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly logs: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly title: Schema.Trim;
+        readonly detail: Schema.NullOr<Schema.String>;
+        readonly tone: Schema.Literals<readonly ["thinking", "tool", "info", "error"]>;
+        readonly status: Schema.NullOr<Schema.Trim>;
+        readonly payload: Schema.Unknown;
+        readonly createdAt: Schema.String;
+    }>>;
+    readonly approvals: Schema.$Array<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>;
+    }>>;
+    readonly userInputs: Schema.optional<Schema.$Array<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>;
+    }>>>;
+    readonly validations: Schema.$Array<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>;
+    }>>;
+    readonly reviews: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "ReviewResultId">;
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+        readonly provider: Schema.Trim;
+        readonly mode: Schema.Literals<readonly ["off", "advisory", "required"]>;
+        readonly status: Schema.Literals<readonly ["pending", "running", "approved", "rejected", "error"]>;
+        readonly summary: Schema.NullOr<Schema.String>;
+        readonly output: Schema.Unknown;
+        readonly createdAt: Schema.String;
+        readonly completedAt: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly artifacts: Schema.$Array<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;
+    }>>;
+    readonly policyDecisions: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly actionId: Schema.NullOr<Schema.brand<Schema.Trim, "ActionId">>;
+        readonly decision: Schema.Literals<readonly ["allow", "warn", "block"]>;
+        readonly mode: Schema.Literals<readonly ["off", "observe", "enforce"]>;
+        readonly matchedRules: Schema.$Array<Schema.Trim>;
+        readonly reason: Schema.String;
+        readonly createdAt: Schema.String;
+    }>>;
+    readonly queue: Schema.$Array<Schema.Struct<{
+        readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+        readonly score: Schema.Int;
+        readonly unblockCount: Schema.Int;
+        readonly position: Schema.Int;
+    }>>;
+    readonly worktrees: Schema.$Array<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>;
+    }>>;
+    readonly remoteEndpoints: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+        readonly alias: Schema.Trim;
+        readonly host: Schema.Trim;
+        readonly port: Schema.Int;
+        readonly token: Schema.String;
+        readonly tokenConfigured: Schema.optional<Schema.Boolean>;
+        readonly autoConnect: Schema.optional<Schema.Boolean>;
+        readonly addedAt: Schema.String;
+        readonly lastConnectedAt: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly remoteConnections: Schema.$Array<Schema.Struct<{
+        readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+        readonly status: Schema.Literals<readonly ["disconnected", "connecting", "authenticating", "connected", "reconnecting", "error"]>;
+        readonly error: Schema.NullOr<Schema.String>;
+        readonly connectedAt: Schema.NullOr<Schema.String>;
+        readonly tokenExpiresAt: Schema.NullOr<Schema.String>;
+        readonly latencyMs: Schema.NullOr<Schema.Number>;
+        readonly subscribedEvents: Schema.$Array<Schema.String>;
+    }>>;
+    readonly remoteOrchestrations: Schema.$Array<Schema.Struct<{
+        readonly orchestrationId: Schema.Trim;
+        readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+        readonly status: Schema.Literals<readonly ["running", "paused", "stopped", "completed"]>;
+        readonly totalTasks: Schema.Int;
+        readonly totalGroups: Schema.Int;
+        readonly maxParallelism: Schema.Int;
+        readonly startedAt: Schema.String;
+    }>>;
+    readonly updatedAt: Schema.String;
+}>;
+export type EngineReadModel = typeof EngineReadModel.Type;
+export declare const RuntimeAdapterKind: Schema.Literals<readonly ["codex", "claude-code", "pi"]>;
+export type RuntimeAdapterKind = typeof RuntimeAdapterKind.Type;
+export declare const WorkspaceRegisterCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"workspace.register">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly title: Schema.Trim;
+    readonly rootPath: Schema.Trim;
+    readonly defaultModel: Schema.optional<Schema.Trim>;
+    readonly createdAt: Schema.String;
+}>;
+export type WorkspaceRegisterCommand = typeof WorkspaceRegisterCommand.Type;
+export declare const WorkspaceImportRigCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"workspace.importRig">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly rootPath: Schema.Trim;
+    readonly title: Schema.optional<Schema.Trim>;
+    readonly createdAt: Schema.String;
+}>;
+export type WorkspaceImportRigCommand = typeof WorkspaceImportRigCommand.Type;
+export declare const RunCreateAdhocCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"run.createAdhoc">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly title: Schema.Trim;
+    readonly runtimeAdapter: Schema.optional<Schema.Literals<readonly ["codex", "claude-code", "pi"]>>;
+    readonly model: Schema.optional<Schema.Trim>;
+    readonly executionTarget: Schema.optional<Schema.Literals<readonly ["local", "remote"]>>;
+    readonly remoteHostId: Schema.optional<Schema.Trim>;
+    readonly runtimeMode: Schema.withDecodingDefault<Schema.Literals<readonly ["approval-required", "full-access"]>>;
+    readonly interactionMode: Schema.withDecodingDefault<Schema.Literals<readonly ["default", "plan"]>>;
+    readonly initialPrompt: Schema.optional<Schema.String>;
+    readonly createdAt: Schema.String;
+}>;
+export type RunCreateAdhocCommand = typeof RunCreateAdhocCommand.Type;
+export declare const RunCreateForTaskCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"run.createForTask">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly runtimeAdapter: Schema.optional<Schema.Literals<readonly ["codex", "claude-code", "pi"]>>;
+    readonly model: Schema.optional<Schema.Trim>;
+    readonly executionTarget: Schema.optional<Schema.Literals<readonly ["local", "remote"]>>;
+    readonly remoteHostId: Schema.optional<Schema.Trim>;
+    readonly runtimeMode: Schema.withDecodingDefault<Schema.Literals<readonly ["approval-required", "full-access"]>>;
+    readonly interactionMode: Schema.withDecodingDefault<Schema.Literals<readonly ["default", "plan"]>>;
+    readonly createdAt: Schema.String;
+}>;
+export type RunCreateForTaskCommand = typeof RunCreateForTaskCommand.Type;
+export declare const RunSubmitUserMessageCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"run.submitUserMessage">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly messageId: Schema.brand<Schema.Trim, "MessageId">;
+    readonly text: Schema.String;
+    readonly attachments: Schema.optional<Schema.$Array<Schema.Unknown>>;
+    readonly createdAt: Schema.String;
+}>;
+export type RunSubmitUserMessageCommand = typeof RunSubmitUserMessageCommand.Type;
+export declare const RunInterruptCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"run.interrupt">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly createdAt: Schema.String;
+}>;
+export type RunInterruptCommand = typeof RunInterruptCommand.Type;
+export declare const RunStopCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"run.stop">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly createdAt: Schema.String;
+}>;
+export type RunStopCommand = typeof RunStopCommand.Type;
+export declare const RunSetRuntimeModeCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"run.setRuntimeMode">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly runtimeMode: Schema.Literals<readonly ["approval-required", "full-access"]>;
+    readonly createdAt: Schema.String;
+}>;
+export type RunSetRuntimeModeCommand = typeof RunSetRuntimeModeCommand.Type;
+export declare const RunSetInteractionModeCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"run.setInteractionMode">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly interactionMode: Schema.Literals<readonly ["default", "plan"]>;
+    readonly createdAt: Schema.String;
+}>;
+export type RunSetInteractionModeCommand = typeof RunSetInteractionModeCommand.Type;
+export declare const RunRespondApprovalCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"run.respondApproval">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+    readonly decision: Schema.Literals<readonly ["accept", "acceptForSession", "decline", "cancel"]>;
+    readonly createdAt: Schema.String;
+}>;
+export type RunRespondApprovalCommand = typeof RunRespondApprovalCommand.Type;
+export declare const RunRespondUserInputCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"run.respondUserInput">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+    readonly answers: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly createdAt: Schema.String;
+}>;
+export type RunRespondUserInputCommand = typeof RunRespondUserInputCommand.Type;
+export declare const RuntimePrepareCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.prepare">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly adapter: Schema.Literals<readonly ["codex", "claude-code", "pi"]>;
+    readonly executionTarget: Schema.optional<Schema.Literals<readonly ["local", "remote"]>>;
+    readonly remoteHostId: Schema.optional<Schema.Trim>;
+    readonly model: Schema.optional<Schema.Trim>;
+    readonly createdAt: Schema.String;
+}>;
+export type RuntimePrepareCommand = typeof RuntimePrepareCommand.Type;
+export declare const RuntimeAttachCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.attach">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly runtimeId: Schema.brand<Schema.Trim, "EngineRuntimeId">;
+    readonly createdAt: Schema.String;
+}>;
+export type RuntimeAttachCommand = typeof RuntimeAttachCommand.Type;
+export declare const RuntimeDetachCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.detach">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly reason: Schema.Trim;
+    readonly createdAt: Schema.String;
+}>;
+export type RuntimeDetachCommand = typeof RuntimeDetachCommand.Type;
+export declare const GraphUpdateTaskStatusCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"graph.updateTaskStatus">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly status: Schema.Literals<readonly ["draft", "open", "ready", "queued", "running", "in_progress", "under_review", "blocked", "unknown", "completed", "failed", "cancelled", "closed"]>;
+    readonly createdAt: Schema.String;
+}>;
+export type GraphUpdateTaskStatusCommand = typeof GraphUpdateTaskStatusCommand.Type;
+export declare const TaskEnqueueCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"task.enqueue">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly score: Schema.Int;
+    readonly createdAt: Schema.String;
+}>;
+export type TaskEnqueueCommand = typeof TaskEnqueueCommand.Type;
+export declare const WorkspaceHydrateImportedStateCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"workspace.hydrateImportedState">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly rootPath: Schema.optional<Schema.String>;
+    readonly graph: Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "GraphId">;
+        readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+        readonly title: Schema.Trim;
+        readonly description: Schema.NullOr<Schema.String>;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+    }>;
+    readonly tasks: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "TaskId">;
+        readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+        readonly graphId: Schema.NullOr<Schema.brand<Schema.Trim, "GraphId">>;
+        readonly externalId: Schema.NullOr<Schema.Trim>;
+        readonly title: Schema.Trim;
+        readonly description: Schema.String;
+        readonly status: Schema.Literals<readonly ["draft", "open", "ready", "queued", "running", "in_progress", "under_review", "blocked", "unknown", "completed", "failed", "cancelled", "closed"]>;
+        readonly priority: Schema.NullOr<Schema.Int>;
+        readonly role: Schema.NullOr<Schema.Trim>;
+        readonly scope: Schema.$Array<Schema.Trim>;
+        readonly validationKeys: Schema.$Array<Schema.Trim>;
+        readonly sourceIssueId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+        readonly dependencies: Schema.optional<Schema.$Array<Schema.Trim>>;
+        readonly parentChildDeps: Schema.optional<Schema.$Array<Schema.Trim>>;
+        readonly metadata: Schema.Unknown;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+    }>>;
+    readonly runs: Schema.$Array<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>;
+    }>>;
+    readonly runtimes: Schema.$Array<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>;
+    }>>;
+    readonly actions: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "ActionId">;
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly messageId: Schema.NullOr<Schema.brand<Schema.Trim, "MessageId">>;
+        readonly actionType: Schema.Trim;
+        readonly title: Schema.Trim;
+        readonly detail: Schema.NullOr<Schema.String>;
+        readonly state: Schema.Trim;
+        readonly payload: Schema.Unknown;
+        readonly startedAt: Schema.String;
+        readonly completedAt: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly logs: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly title: Schema.Trim;
+        readonly detail: Schema.NullOr<Schema.String>;
+        readonly tone: Schema.Literals<readonly ["thinking", "tool", "info", "error"]>;
+        readonly status: Schema.NullOr<Schema.Trim>;
+        readonly payload: Schema.Unknown;
+        readonly createdAt: Schema.String;
+    }>>>;
+    readonly validations: Schema.$Array<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>;
+    }>>;
+    readonly reviews: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "ReviewResultId">;
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+        readonly provider: Schema.Trim;
+        readonly mode: Schema.Literals<readonly ["off", "advisory", "required"]>;
+        readonly status: Schema.Literals<readonly ["pending", "running", "approved", "rejected", "error"]>;
+        readonly summary: Schema.NullOr<Schema.String>;
+        readonly output: Schema.Unknown;
+        readonly createdAt: Schema.String;
+        readonly completedAt: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly artifacts: Schema.$Array<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;
+    }>>;
+    readonly policyDecisions: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly actionId: Schema.NullOr<Schema.brand<Schema.Trim, "ActionId">>;
+        readonly decision: Schema.Literals<readonly ["allow", "warn", "block"]>;
+        readonly mode: Schema.Literals<readonly ["off", "observe", "enforce"]>;
+        readonly matchedRules: Schema.$Array<Schema.Trim>;
+        readonly reason: Schema.String;
+        readonly createdAt: Schema.String;
+    }>>;
+    readonly queue: Schema.$Array<Schema.Struct<{
+        readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+        readonly score: Schema.Int;
+        readonly unblockCount: Schema.Int;
+        readonly position: Schema.Int;
+    }>>;
+    readonly createdAt: Schema.String;
+}>;
+export type WorkspaceHydrateImportedStateCommand = typeof WorkspaceHydrateImportedStateCommand.Type;
+export declare const WorkspaceCompileTopologyCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"workspace.compileTopology">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly rootPath: Schema.Trim;
+    readonly topology: 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 createdAt: Schema.String;
+}>;
+export type WorkspaceCompileTopologyCommand = typeof WorkspaceCompileTopologyCommand.Type;
+export declare const WorkspaceSyncRemoteFleetCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"workspace.syncRemoteFleet">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly rootPath: Schema.Trim;
+    readonly remoteFleet: 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 createdAt: Schema.String;
+}>;
+export type WorkspaceSyncRemoteFleetCommand = typeof WorkspaceSyncRemoteFleetCommand.Type;
+export declare const WorkspaceSyncServiceFabricCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"workspace.syncServiceFabric">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly rootPath: Schema.Trim;
+    readonly serviceFabric: 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;
+}>;
+export type WorkspaceSyncServiceFabricCommand = typeof WorkspaceSyncServiceFabricCommand.Type;
+export declare const WorkspaceRegisterRemoteHostCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"workspace.registerRemoteHost">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly host: 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 createdAt: Schema.String;
+}>;
+export type WorkspaceRegisterRemoteHostCommand = typeof WorkspaceRegisterRemoteHostCommand.Type;
+export declare const WorkspaceUpdateRemoteHostStatusCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"workspace.updateRemoteHostStatus">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly status: Schema.Literals<readonly ["registering", "ready", "busy", "degraded", "draining", "offline", "quarantined"]>;
+    readonly currentLeaseCount: Schema.optional<Schema.Number>;
+    readonly lastHeartbeatAt: Schema.optional<Schema.String>;
+    readonly createdAt: Schema.String;
+}>;
+export type WorkspaceUpdateRemoteHostStatusCommand = typeof WorkspaceUpdateRemoteHostStatusCommand.Type;
+export declare const RunClaimRemoteLeaseCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"run.claimRemoteLease">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly hostId: Schema.Trim;
+    readonly leaseId: Schema.Trim;
+    readonly createdAt: Schema.String;
+}>;
+export type RunClaimRemoteLeaseCommand = typeof RunClaimRemoteLeaseCommand.Type;
+export declare const RunReleaseRemoteLeaseCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"run.releaseRemoteLease">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly leaseId: Schema.Trim;
+    readonly createdAt: Schema.String;
+}>;
+export type RunReleaseRemoteLeaseCommand = typeof RunReleaseRemoteLeaseCommand.Type;
+export declare const RuntimeRecordMessageCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.recordMessage">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly messageId: Schema.brand<Schema.Trim, "MessageId">;
+    readonly role: Schema.Literals<readonly ["user", "assistant", "system"]>;
+    readonly text: Schema.String;
+    readonly state: Schema.Literals<readonly ["streaming", "completed", "interrupted", "errored"]>;
+    readonly attachments: Schema.optional<Schema.$Array<Schema.Unknown>>;
+    readonly createdAt: Schema.String;
+    readonly completedAt: Schema.optional<Schema.String>;
+}>;
+export type RuntimeRecordMessageCommand = typeof RuntimeRecordMessageCommand.Type;
+export declare const RuntimeStartActionCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.startAction">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly actionId: Schema.brand<Schema.Trim, "ActionId">;
+    readonly messageId: Schema.optional<Schema.brand<Schema.Trim, "MessageId">>;
+    readonly actionType: Schema.Trim;
+    readonly title: Schema.Trim;
+    readonly detail: Schema.optional<Schema.String>;
+    readonly payload: Schema.Unknown;
+    readonly createdAt: Schema.String;
+}>;
+export type RuntimeStartActionCommand = typeof RuntimeStartActionCommand.Type;
+export declare const RuntimeCompleteActionCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.completeAction">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly actionId: Schema.brand<Schema.Trim, "ActionId">;
+    readonly state: Schema.Trim;
+    readonly detail: Schema.optional<Schema.String>;
+    readonly payload: Schema.Unknown;
+    readonly createdAt: Schema.String;
+}>;
+export type RuntimeCompleteActionCommand = typeof RuntimeCompleteActionCommand.Type;
+export declare const RuntimeRecordLogCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.recordLog">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly logId: Schema.Trim;
+    readonly title: Schema.Trim;
+    readonly detail: Schema.optional<Schema.String>;
+    readonly tone: Schema.Literals<readonly ["thinking", "tool", "info", "error"]>;
+    readonly status: Schema.optional<Schema.Trim>;
+    readonly payload: Schema.optional<Schema.Unknown>;
+    readonly createdAt: Schema.String;
+}>;
+export type RuntimeRecordLogCommand = typeof RuntimeRecordLogCommand.Type;
+export declare const RuntimeUpdateMetadataCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.updateMetadata">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly runtimeId: Schema.brand<Schema.Trim, "EngineRuntimeId">;
+    readonly sandboxMode: Schema.optional<Schema.Literals<readonly ["read-only", "workspace-write", "danger-full-access"]>>;
+    readonly isolationMode: Schema.optional<Schema.Literals<readonly ["none", "env", "worktree"]>>;
+    readonly workspaceDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly homeDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly tmpDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly cacheDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly logsDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly stateDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly sessionDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly sessionLogPath: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly pid: Schema.optional<Schema.Int>;
+    readonly worktreePath: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly branch: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly createdAt: Schema.String;
+}>;
+export type RuntimeUpdateMetadataCommand = typeof RuntimeUpdateMetadataCommand.Type;
+export declare const RuntimeRequestApprovalCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.requestApproval">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+    readonly requestKind: Schema.Trim;
+    readonly actionId: Schema.optional<Schema.brand<Schema.Trim, "ActionId">>;
+    readonly payload: Schema.Unknown;
+    readonly createdAt: Schema.String;
+}>;
+export type RuntimeRequestApprovalCommand = typeof RuntimeRequestApprovalCommand.Type;
+export declare const RuntimeRequestUserInputCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.requestUserInput">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+    readonly payload: Schema.Unknown;
+    readonly createdAt: Schema.String;
+}>;
+export type RuntimeRequestUserInputCommand = typeof RuntimeRequestUserInputCommand.Type;
+export declare const RunMarkCompletedCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"run.markCompleted">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly createdAt: Schema.String;
+}>;
+export type RunMarkCompletedCommand = typeof RunMarkCompletedCommand.Type;
+export declare const RunMarkFailedCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"run.markFailed">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly errorText: Schema.optional<Schema.String>;
+    readonly createdAt: Schema.String;
+}>;
+export type RunMarkFailedCommand = typeof RunMarkFailedCommand.Type;
+export declare const RunSetStatusCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"run.setStatus">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly status: Schema.Literals<readonly ["created", "queued", "preparing", "running", "validating", "reviewing", "paused"]>;
+    readonly createdAt: Schema.String;
+}>;
+export type RunSetStatusCommand = typeof RunSetStatusCommand.Type;
+export declare const RuntimeRecordValidationCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.recordValidation">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.optional<Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>>;
+    readonly validationId: Schema.brand<Schema.Trim, "ValidationResultId">;
+    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.optional<Schema.NullOr<Schema.String>>;
+    readonly createdAt: Schema.String;
+}>;
+export type RuntimeRecordValidationCommand = typeof RuntimeRecordValidationCommand.Type;
+export declare const RuntimeRecordReviewCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.recordReview">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.optional<Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>>;
+    readonly reviewId: Schema.brand<Schema.Trim, "ReviewResultId">;
+    readonly provider: Schema.Trim;
+    readonly mode: Schema.Literals<readonly ["off", "advisory", "required"]>;
+    readonly status: Schema.Literals<readonly ["pending", "running", "approved", "rejected", "error"]>;
+    readonly summary: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly output: Schema.Unknown;
+    readonly createdAt: Schema.String;
+    readonly completedAt: Schema.optional<Schema.NullOr<Schema.String>>;
+}>;
+export type RuntimeRecordReviewCommand = typeof RuntimeRecordReviewCommand.Type;
+export declare const RuntimeRegisterArtifactCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.registerArtifact">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.optional<Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>>;
+    readonly artifactId: Schema.brand<Schema.Trim, "ArtifactId">;
+    readonly kind: Schema.Trim;
+    readonly label: Schema.Trim;
+    readonly path: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly url: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly createdAt: Schema.String;
+}>;
+export type RuntimeRegisterArtifactCommand = typeof RuntimeRegisterArtifactCommand.Type;
+export declare const RemoteRegisterEndpointCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.registerEndpoint">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpoint: Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+        readonly alias: Schema.Trim;
+        readonly host: Schema.Trim;
+        readonly port: Schema.Int;
+        readonly token: Schema.String;
+        readonly tokenConfigured: Schema.optional<Schema.Boolean>;
+        readonly autoConnect: Schema.optional<Schema.Boolean>;
+        readonly addedAt: Schema.String;
+        readonly lastConnectedAt: Schema.NullOr<Schema.String>;
+    }>;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteRegisterEndpointCommand = typeof RemoteRegisterEndpointCommand.Type;
+export declare const RemoteRemoveEndpointCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.removeEndpoint">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteRemoveEndpointCommand = typeof RemoteRemoveEndpointCommand.Type;
+export declare const RemoteUpdateEndpointCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.updateEndpoint">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly updates: Schema.Unknown;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteUpdateEndpointCommand = typeof RemoteUpdateEndpointCommand.Type;
+export declare const RemoteConnectCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.connect">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteConnectCommand = typeof RemoteConnectCommand.Type;
+export declare const RemoteDisconnectCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.disconnect">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteDisconnectCommand = typeof RemoteDisconnectCommand.Type;
+export declare const RemotePauseCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.pause">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly createdAt: Schema.String;
+}>;
+export type RemotePauseCommand = typeof RemotePauseCommand.Type;
+export declare const RemoteResumeCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.resume">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteResumeCommand = typeof RemoteResumeCommand.Type;
+export declare const RemoteStopCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.stop">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteStopCommand = typeof RemoteStopCommand.Type;
+export declare const RemoteContinueCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.continue">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteContinueCommand = typeof RemoteContinueCommand.Type;
+export declare const RemoteCreateRunForTaskCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.createRunForTask">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly taskId: Schema.Trim;
+    readonly runId: Schema.Trim;
+    readonly workspaceId: Schema.Trim;
+    readonly runtimeMode: Schema.optional<Schema.String>;
+    readonly interactionMode: Schema.optional<Schema.String>;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteCreateRunForTaskCommand = typeof RemoteCreateRunForTaskCommand.Type;
+export declare const RemoteRefreshTasksCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.refreshTasks">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteRefreshTasksCommand = typeof RemoteRefreshTasksCommand.Type;
+export declare const RemoteAddIterationsCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.addIterations">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly count: Schema.Int;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteAddIterationsCommand = typeof RemoteAddIterationsCommand.Type;
+export declare const RemoteRemoveIterationsCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.removeIterations">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly count: Schema.Int;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteRemoveIterationsCommand = typeof RemoteRemoveIterationsCommand.Type;
+export declare const RemoteOrchestrateStartCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.orchestrate.start">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly maxWorkers: Schema.optional<Schema.Int>;
+    readonly maxIterations: Schema.optional<Schema.Int>;
+    readonly directMerge: Schema.optional<Schema.Boolean>;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteOrchestrateStartCommand = typeof RemoteOrchestrateStartCommand.Type;
+export declare const RemoteOrchestratePauseCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.orchestrate.pause">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly orchestrationId: Schema.Trim;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteOrchestratePauseCommand = typeof RemoteOrchestratePauseCommand.Type;
+export declare const RemoteOrchestrateResumeCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.orchestrate.resume">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly orchestrationId: Schema.Trim;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteOrchestrateResumeCommand = typeof RemoteOrchestrateResumeCommand.Type;
+export declare const RemoteOrchestrateStopCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.orchestrate.stop">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly orchestrationId: Schema.Trim;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteOrchestrateStopCommand = typeof RemoteOrchestrateStopCommand.Type;
+export declare const RemoteGetPromptPreviewCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.getPromptPreview">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly taskId: Schema.Trim;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteGetPromptPreviewCommand = typeof RemoteGetPromptPreviewCommand.Type;
+export declare const RemoteGetIterationOutputCommand: Schema.Struct<{
+    readonly type: Schema.Literal<"remote.getIterationOutput">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly taskId: Schema.Trim;
+    readonly createdAt: Schema.String;
+}>;
+export type RemoteGetIterationOutputCommand = typeof RemoteGetIterationOutputCommand.Type;
+export declare const EngineCommand: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"workspace.register">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly title: Schema.Trim;
+    readonly rootPath: Schema.Trim;
+    readonly defaultModel: Schema.optional<Schema.Trim>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"workspace.importRig">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly rootPath: Schema.Trim;
+    readonly title: Schema.optional<Schema.Trim>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"workspace.hydrateImportedState">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly rootPath: Schema.optional<Schema.String>;
+    readonly graph: Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "GraphId">;
+        readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+        readonly title: Schema.Trim;
+        readonly description: Schema.NullOr<Schema.String>;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+    }>;
+    readonly tasks: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "TaskId">;
+        readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+        readonly graphId: Schema.NullOr<Schema.brand<Schema.Trim, "GraphId">>;
+        readonly externalId: Schema.NullOr<Schema.Trim>;
+        readonly title: Schema.Trim;
+        readonly description: Schema.String;
+        readonly status: Schema.Literals<readonly ["draft", "open", "ready", "queued", "running", "in_progress", "under_review", "blocked", "unknown", "completed", "failed", "cancelled", "closed"]>;
+        readonly priority: Schema.NullOr<Schema.Int>;
+        readonly role: Schema.NullOr<Schema.Trim>;
+        readonly scope: Schema.$Array<Schema.Trim>;
+        readonly validationKeys: Schema.$Array<Schema.Trim>;
+        readonly sourceIssueId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+        readonly dependencies: Schema.optional<Schema.$Array<Schema.Trim>>;
+        readonly parentChildDeps: Schema.optional<Schema.$Array<Schema.Trim>>;
+        readonly metadata: Schema.Unknown;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+    }>>;
+    readonly runs: Schema.$Array<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>;
+    }>>;
+    readonly runtimes: Schema.$Array<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>;
+    }>>;
+    readonly actions: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "ActionId">;
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly messageId: Schema.NullOr<Schema.brand<Schema.Trim, "MessageId">>;
+        readonly actionType: Schema.Trim;
+        readonly title: Schema.Trim;
+        readonly detail: Schema.NullOr<Schema.String>;
+        readonly state: Schema.Trim;
+        readonly payload: Schema.Unknown;
+        readonly startedAt: Schema.String;
+        readonly completedAt: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly logs: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly title: Schema.Trim;
+        readonly detail: Schema.NullOr<Schema.String>;
+        readonly tone: Schema.Literals<readonly ["thinking", "tool", "info", "error"]>;
+        readonly status: Schema.NullOr<Schema.Trim>;
+        readonly payload: Schema.Unknown;
+        readonly createdAt: Schema.String;
+    }>>>;
+    readonly validations: Schema.$Array<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>;
+    }>>;
+    readonly reviews: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "ReviewResultId">;
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+        readonly provider: Schema.Trim;
+        readonly mode: Schema.Literals<readonly ["off", "advisory", "required"]>;
+        readonly status: Schema.Literals<readonly ["pending", "running", "approved", "rejected", "error"]>;
+        readonly summary: Schema.NullOr<Schema.String>;
+        readonly output: Schema.Unknown;
+        readonly createdAt: Schema.String;
+        readonly completedAt: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly artifacts: Schema.$Array<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;
+    }>>;
+    readonly policyDecisions: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly actionId: Schema.NullOr<Schema.brand<Schema.Trim, "ActionId">>;
+        readonly decision: Schema.Literals<readonly ["allow", "warn", "block"]>;
+        readonly mode: Schema.Literals<readonly ["off", "observe", "enforce"]>;
+        readonly matchedRules: Schema.$Array<Schema.Trim>;
+        readonly reason: Schema.String;
+        readonly createdAt: Schema.String;
+    }>>;
+    readonly queue: Schema.$Array<Schema.Struct<{
+        readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+        readonly score: Schema.Int;
+        readonly unblockCount: Schema.Int;
+        readonly position: Schema.Int;
+    }>>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"workspace.compileTopology">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly rootPath: Schema.Trim;
+    readonly topology: 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 createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"workspace.syncRemoteFleet">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly rootPath: Schema.Trim;
+    readonly remoteFleet: 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 createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"workspace.syncServiceFabric">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly rootPath: Schema.Trim;
+    readonly serviceFabric: 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;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"workspace.registerRemoteHost">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly host: 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 createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"workspace.updateRemoteHostStatus">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly hostId: Schema.Trim;
+    readonly status: Schema.Literals<readonly ["registering", "ready", "busy", "degraded", "draining", "offline", "quarantined"]>;
+    readonly currentLeaseCount: Schema.optional<Schema.Number>;
+    readonly lastHeartbeatAt: Schema.optional<Schema.String>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"run.claimRemoteLease">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly hostId: Schema.Trim;
+    readonly leaseId: Schema.Trim;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"run.releaseRemoteLease">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly leaseId: Schema.Trim;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"run.createAdhoc">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly title: Schema.Trim;
+    readonly runtimeAdapter: Schema.optional<Schema.Literals<readonly ["codex", "claude-code", "pi"]>>;
+    readonly model: Schema.optional<Schema.Trim>;
+    readonly executionTarget: Schema.optional<Schema.Literals<readonly ["local", "remote"]>>;
+    readonly remoteHostId: Schema.optional<Schema.Trim>;
+    readonly runtimeMode: Schema.withDecodingDefault<Schema.Literals<readonly ["approval-required", "full-access"]>>;
+    readonly interactionMode: Schema.withDecodingDefault<Schema.Literals<readonly ["default", "plan"]>>;
+    readonly initialPrompt: Schema.optional<Schema.String>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"run.createForTask">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly runtimeAdapter: Schema.optional<Schema.Literals<readonly ["codex", "claude-code", "pi"]>>;
+    readonly model: Schema.optional<Schema.Trim>;
+    readonly executionTarget: Schema.optional<Schema.Literals<readonly ["local", "remote"]>>;
+    readonly remoteHostId: Schema.optional<Schema.Trim>;
+    readonly runtimeMode: Schema.withDecodingDefault<Schema.Literals<readonly ["approval-required", "full-access"]>>;
+    readonly interactionMode: Schema.withDecodingDefault<Schema.Literals<readonly ["default", "plan"]>>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"run.markCompleted">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"run.markFailed">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly errorText: Schema.optional<Schema.String>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"run.setStatus">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly status: Schema.Literals<readonly ["created", "queued", "preparing", "running", "validating", "reviewing", "paused"]>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"run.submitUserMessage">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly messageId: Schema.brand<Schema.Trim, "MessageId">;
+    readonly text: Schema.String;
+    readonly attachments: Schema.optional<Schema.$Array<Schema.Unknown>>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"run.interrupt">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"run.stop">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"run.setRuntimeMode">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly runtimeMode: Schema.Literals<readonly ["approval-required", "full-access"]>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"run.setInteractionMode">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly interactionMode: Schema.Literals<readonly ["default", "plan"]>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"run.respondApproval">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+    readonly decision: Schema.Literals<readonly ["accept", "acceptForSession", "decline", "cancel"]>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"run.respondUserInput">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+    readonly answers: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.prepare">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly adapter: Schema.Literals<readonly ["codex", "claude-code", "pi"]>;
+    readonly executionTarget: Schema.optional<Schema.Literals<readonly ["local", "remote"]>>;
+    readonly remoteHostId: Schema.optional<Schema.Trim>;
+    readonly model: Schema.optional<Schema.Trim>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.attach">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly runtimeId: Schema.brand<Schema.Trim, "EngineRuntimeId">;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.detach">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly reason: Schema.Trim;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.recordMessage">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly messageId: Schema.brand<Schema.Trim, "MessageId">;
+    readonly role: Schema.Literals<readonly ["user", "assistant", "system"]>;
+    readonly text: Schema.String;
+    readonly state: Schema.Literals<readonly ["streaming", "completed", "interrupted", "errored"]>;
+    readonly attachments: Schema.optional<Schema.$Array<Schema.Unknown>>;
+    readonly createdAt: Schema.String;
+    readonly completedAt: Schema.optional<Schema.String>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.startAction">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly actionId: Schema.brand<Schema.Trim, "ActionId">;
+    readonly messageId: Schema.optional<Schema.brand<Schema.Trim, "MessageId">>;
+    readonly actionType: Schema.Trim;
+    readonly title: Schema.Trim;
+    readonly detail: Schema.optional<Schema.String>;
+    readonly payload: Schema.Unknown;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.completeAction">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly actionId: Schema.brand<Schema.Trim, "ActionId">;
+    readonly state: Schema.Trim;
+    readonly detail: Schema.optional<Schema.String>;
+    readonly payload: Schema.Unknown;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.recordLog">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly logId: Schema.Trim;
+    readonly title: Schema.Trim;
+    readonly detail: Schema.optional<Schema.String>;
+    readonly tone: Schema.Literals<readonly ["thinking", "tool", "info", "error"]>;
+    readonly status: Schema.optional<Schema.Trim>;
+    readonly payload: Schema.optional<Schema.Unknown>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.updateMetadata">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly runtimeId: Schema.brand<Schema.Trim, "EngineRuntimeId">;
+    readonly sandboxMode: Schema.optional<Schema.Literals<readonly ["read-only", "workspace-write", "danger-full-access"]>>;
+    readonly isolationMode: Schema.optional<Schema.Literals<readonly ["none", "env", "worktree"]>>;
+    readonly workspaceDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly homeDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly tmpDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly cacheDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly logsDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly stateDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly sessionDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly sessionLogPath: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly pid: Schema.optional<Schema.Int>;
+    readonly worktreePath: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly branch: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.requestApproval">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+    readonly requestKind: Schema.Trim;
+    readonly actionId: Schema.optional<Schema.brand<Schema.Trim, "ActionId">>;
+    readonly payload: Schema.Unknown;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.requestUserInput">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+    readonly payload: Schema.Unknown;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.recordValidation">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.optional<Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>>;
+    readonly validationId: Schema.brand<Schema.Trim, "ValidationResultId">;
+    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.optional<Schema.NullOr<Schema.String>>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.recordReview">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.optional<Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>>;
+    readonly reviewId: Schema.brand<Schema.Trim, "ReviewResultId">;
+    readonly provider: Schema.Trim;
+    readonly mode: Schema.Literals<readonly ["off", "advisory", "required"]>;
+    readonly status: Schema.Literals<readonly ["pending", "running", "approved", "rejected", "error"]>;
+    readonly summary: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly output: Schema.Unknown;
+    readonly createdAt: Schema.String;
+    readonly completedAt: Schema.optional<Schema.NullOr<Schema.String>>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.registerArtifact">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.optional<Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>>;
+    readonly artifactId: Schema.brand<Schema.Trim, "ArtifactId">;
+    readonly kind: Schema.Trim;
+    readonly label: Schema.Trim;
+    readonly path: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly url: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"graph.updateTaskStatus">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly status: Schema.Literals<readonly ["draft", "open", "ready", "queued", "running", "in_progress", "under_review", "blocked", "unknown", "completed", "failed", "cancelled", "closed"]>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"task.enqueue">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly score: Schema.Int;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.registerEndpoint">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpoint: Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+        readonly alias: Schema.Trim;
+        readonly host: Schema.Trim;
+        readonly port: Schema.Int;
+        readonly token: Schema.String;
+        readonly tokenConfigured: Schema.optional<Schema.Boolean>;
+        readonly autoConnect: Schema.optional<Schema.Boolean>;
+        readonly addedAt: Schema.String;
+        readonly lastConnectedAt: Schema.NullOr<Schema.String>;
+    }>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.removeEndpoint">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.updateEndpoint">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly updates: Schema.Unknown;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.connect">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.disconnect">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.pause">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.resume">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.stop">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.continue">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.createRunForTask">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly taskId: Schema.Trim;
+    readonly runId: Schema.Trim;
+    readonly workspaceId: Schema.Trim;
+    readonly runtimeMode: Schema.optional<Schema.String>;
+    readonly interactionMode: Schema.optional<Schema.String>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.refreshTasks">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.addIterations">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly count: Schema.Int;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.removeIterations">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly count: Schema.Int;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.orchestrate.start">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly maxWorkers: Schema.optional<Schema.Int>;
+    readonly maxIterations: Schema.optional<Schema.Int>;
+    readonly directMerge: Schema.optional<Schema.Boolean>;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.orchestrate.pause">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly orchestrationId: Schema.Trim;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.orchestrate.resume">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly orchestrationId: Schema.Trim;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.orchestrate.stop">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly orchestrationId: Schema.Trim;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.getPromptPreview">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly taskId: Schema.Trim;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remote.getIterationOutput">;
+    readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+    readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+    readonly taskId: Schema.Trim;
+    readonly createdAt: Schema.String;
+}>]>;
+export type EngineCommand = typeof EngineCommand.Type;
+export declare const EngineDispatchResult: Schema.Struct<{
+    readonly sequence: Schema.Int;
+}>;
+export type EngineDispatchResult = typeof EngineDispatchResult.Type;
+export declare const EngineGetSnapshotInput: Schema.Struct<{}>;
+export type EngineGetSnapshotInput = typeof EngineGetSnapshotInput.Type;
+export declare const EngineReplayEventsInput: Schema.Struct<{
+    readonly fromSequenceExclusive: Schema.Int;
+}>;
+export type EngineReplayEventsInput = typeof EngineReplayEventsInput.Type;
+export declare const EngineReplayEventsResult: Schema.$Array<Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "EventId">;
+    readonly sequence: Schema.Int;
+    readonly createdAt: Schema.String;
+    readonly type: Schema.Trim;
+    readonly aggregateId: Schema.Trim;
+    readonly payload: Schema.Unknown;
+}>>;
+export type EngineReplayEventsResult = typeof EngineReplayEventsResult.Type;
+export declare const EngineGetTaskArtifactsInput: Schema.Struct<{
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+}>;
+export type EngineGetTaskArtifactsInput = typeof EngineGetTaskArtifactsInput.Type;
+export declare const EngineGetTaskArtifactsResult: Schema.$Array<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 EngineGetTaskArtifactsResult = typeof EngineGetTaskArtifactsResult.Type;
+export declare const EngineRpcSchemas: {
+    readonly getSnapshot: {
+        readonly input: Schema.Struct<{}>;
+        readonly output: Schema.Struct<{
+            readonly snapshotSequence: Schema.Int;
+            readonly workspaces: Schema.$Array<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;
+            }>>;
+            readonly graphs: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.brand<Schema.Trim, "GraphId">;
+                readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+                readonly title: Schema.Trim;
+                readonly description: Schema.NullOr<Schema.String>;
+                readonly createdAt: Schema.String;
+                readonly updatedAt: Schema.String;
+            }>>;
+            readonly tasks: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.brand<Schema.Trim, "TaskId">;
+                readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+                readonly graphId: Schema.NullOr<Schema.brand<Schema.Trim, "GraphId">>;
+                readonly externalId: Schema.NullOr<Schema.Trim>;
+                readonly title: Schema.Trim;
+                readonly description: Schema.String;
+                readonly status: Schema.Literals<readonly ["draft", "open", "ready", "queued", "running", "in_progress", "under_review", "blocked", "unknown", "completed", "failed", "cancelled", "closed"]>;
+                readonly priority: Schema.NullOr<Schema.Int>;
+                readonly role: Schema.NullOr<Schema.Trim>;
+                readonly scope: Schema.$Array<Schema.Trim>;
+                readonly validationKeys: Schema.$Array<Schema.Trim>;
+                readonly sourceIssueId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+                readonly dependencies: Schema.optional<Schema.$Array<Schema.Trim>>;
+                readonly parentChildDeps: Schema.optional<Schema.$Array<Schema.Trim>>;
+                readonly metadata: Schema.Unknown;
+                readonly createdAt: Schema.String;
+                readonly updatedAt: Schema.String;
+            }>>;
+            readonly runs: Schema.$Array<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>;
+            }>>;
+            readonly runtimes: Schema.$Array<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>;
+            }>>;
+            readonly conversations: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.brand<Schema.Trim, "ConversationId">;
+                readonly runId: Schema.brand<Schema.Trim, "RunId">;
+                readonly title: Schema.Trim;
+                readonly createdAt: Schema.String;
+                readonly updatedAt: Schema.String;
+            }>>;
+            readonly messages: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.brand<Schema.Trim, "MessageId">;
+                readonly conversationId: Schema.brand<Schema.Trim, "ConversationId">;
+                readonly role: Schema.Literals<readonly ["user", "assistant", "system"]>;
+                readonly text: Schema.String;
+                readonly attachments: Schema.$Array<Schema.Unknown>;
+                readonly state: Schema.Literals<readonly ["streaming", "completed", "interrupted", "errored"]>;
+                readonly createdAt: Schema.String;
+                readonly completedAt: Schema.NullOr<Schema.String>;
+            }>>;
+            readonly actions: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.brand<Schema.Trim, "ActionId">;
+                readonly runId: Schema.brand<Schema.Trim, "RunId">;
+                readonly messageId: Schema.NullOr<Schema.brand<Schema.Trim, "MessageId">>;
+                readonly actionType: Schema.Trim;
+                readonly title: Schema.Trim;
+                readonly detail: Schema.NullOr<Schema.String>;
+                readonly state: Schema.Trim;
+                readonly payload: Schema.Unknown;
+                readonly startedAt: Schema.String;
+                readonly completedAt: Schema.NullOr<Schema.String>;
+            }>>;
+            readonly logs: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.Trim;
+                readonly runId: Schema.brand<Schema.Trim, "RunId">;
+                readonly title: Schema.Trim;
+                readonly detail: Schema.NullOr<Schema.String>;
+                readonly tone: Schema.Literals<readonly ["thinking", "tool", "info", "error"]>;
+                readonly status: Schema.NullOr<Schema.Trim>;
+                readonly payload: Schema.Unknown;
+                readonly createdAt: Schema.String;
+            }>>;
+            readonly approvals: Schema.$Array<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>;
+            }>>;
+            readonly userInputs: Schema.optional<Schema.$Array<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>;
+            }>>>;
+            readonly validations: Schema.$Array<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>;
+            }>>;
+            readonly reviews: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.brand<Schema.Trim, "ReviewResultId">;
+                readonly runId: Schema.brand<Schema.Trim, "RunId">;
+                readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+                readonly provider: Schema.Trim;
+                readonly mode: Schema.Literals<readonly ["off", "advisory", "required"]>;
+                readonly status: Schema.Literals<readonly ["pending", "running", "approved", "rejected", "error"]>;
+                readonly summary: Schema.NullOr<Schema.String>;
+                readonly output: Schema.Unknown;
+                readonly createdAt: Schema.String;
+                readonly completedAt: Schema.NullOr<Schema.String>;
+            }>>;
+            readonly artifacts: Schema.$Array<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;
+            }>>;
+            readonly policyDecisions: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.Trim;
+                readonly runId: Schema.brand<Schema.Trim, "RunId">;
+                readonly actionId: Schema.NullOr<Schema.brand<Schema.Trim, "ActionId">>;
+                readonly decision: Schema.Literals<readonly ["allow", "warn", "block"]>;
+                readonly mode: Schema.Literals<readonly ["off", "observe", "enforce"]>;
+                readonly matchedRules: Schema.$Array<Schema.Trim>;
+                readonly reason: Schema.String;
+                readonly createdAt: Schema.String;
+            }>>;
+            readonly queue: Schema.$Array<Schema.Struct<{
+                readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+                readonly score: Schema.Int;
+                readonly unblockCount: Schema.Int;
+                readonly position: Schema.Int;
+            }>>;
+            readonly worktrees: Schema.$Array<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>;
+            }>>;
+            readonly remoteEndpoints: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+                readonly alias: Schema.Trim;
+                readonly host: Schema.Trim;
+                readonly port: Schema.Int;
+                readonly token: Schema.String;
+                readonly tokenConfigured: Schema.optional<Schema.Boolean>;
+                readonly autoConnect: Schema.optional<Schema.Boolean>;
+                readonly addedAt: Schema.String;
+                readonly lastConnectedAt: Schema.NullOr<Schema.String>;
+            }>>;
+            readonly remoteConnections: Schema.$Array<Schema.Struct<{
+                readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+                readonly status: Schema.Literals<readonly ["disconnected", "connecting", "authenticating", "connected", "reconnecting", "error"]>;
+                readonly error: Schema.NullOr<Schema.String>;
+                readonly connectedAt: Schema.NullOr<Schema.String>;
+                readonly tokenExpiresAt: Schema.NullOr<Schema.String>;
+                readonly latencyMs: Schema.NullOr<Schema.Number>;
+                readonly subscribedEvents: Schema.$Array<Schema.String>;
+            }>>;
+            readonly remoteOrchestrations: Schema.$Array<Schema.Struct<{
+                readonly orchestrationId: Schema.Trim;
+                readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+                readonly status: Schema.Literals<readonly ["running", "paused", "stopped", "completed"]>;
+                readonly totalTasks: Schema.Int;
+                readonly totalGroups: Schema.Int;
+                readonly maxParallelism: Schema.Int;
+                readonly startedAt: Schema.String;
+            }>>;
+            readonly updatedAt: Schema.String;
+        }>;
+    };
+    readonly dispatch: {
+        readonly input: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"workspace.register">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+            readonly title: Schema.Trim;
+            readonly rootPath: Schema.Trim;
+            readonly defaultModel: Schema.optional<Schema.Trim>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"workspace.importRig">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+            readonly rootPath: Schema.Trim;
+            readonly title: Schema.optional<Schema.Trim>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"workspace.hydrateImportedState">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+            readonly rootPath: Schema.optional<Schema.String>;
+            readonly graph: Schema.Struct<{
+                readonly id: Schema.brand<Schema.Trim, "GraphId">;
+                readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+                readonly title: Schema.Trim;
+                readonly description: Schema.NullOr<Schema.String>;
+                readonly createdAt: Schema.String;
+                readonly updatedAt: Schema.String;
+            }>;
+            readonly tasks: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.brand<Schema.Trim, "TaskId">;
+                readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+                readonly graphId: Schema.NullOr<Schema.brand<Schema.Trim, "GraphId">>;
+                readonly externalId: Schema.NullOr<Schema.Trim>;
+                readonly title: Schema.Trim;
+                readonly description: Schema.String;
+                readonly status: Schema.Literals<readonly ["draft", "open", "ready", "queued", "running", "in_progress", "under_review", "blocked", "unknown", "completed", "failed", "cancelled", "closed"]>;
+                readonly priority: Schema.NullOr<Schema.Int>;
+                readonly role: Schema.NullOr<Schema.Trim>;
+                readonly scope: Schema.$Array<Schema.Trim>;
+                readonly validationKeys: Schema.$Array<Schema.Trim>;
+                readonly sourceIssueId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+                readonly dependencies: Schema.optional<Schema.$Array<Schema.Trim>>;
+                readonly parentChildDeps: Schema.optional<Schema.$Array<Schema.Trim>>;
+                readonly metadata: Schema.Unknown;
+                readonly createdAt: Schema.String;
+                readonly updatedAt: Schema.String;
+            }>>;
+            readonly runs: Schema.$Array<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>;
+            }>>;
+            readonly runtimes: Schema.$Array<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>;
+            }>>;
+            readonly actions: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.brand<Schema.Trim, "ActionId">;
+                readonly runId: Schema.brand<Schema.Trim, "RunId">;
+                readonly messageId: Schema.NullOr<Schema.brand<Schema.Trim, "MessageId">>;
+                readonly actionType: Schema.Trim;
+                readonly title: Schema.Trim;
+                readonly detail: Schema.NullOr<Schema.String>;
+                readonly state: Schema.Trim;
+                readonly payload: Schema.Unknown;
+                readonly startedAt: Schema.String;
+                readonly completedAt: Schema.NullOr<Schema.String>;
+            }>>;
+            readonly logs: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly id: Schema.Trim;
+                readonly runId: Schema.brand<Schema.Trim, "RunId">;
+                readonly title: Schema.Trim;
+                readonly detail: Schema.NullOr<Schema.String>;
+                readonly tone: Schema.Literals<readonly ["thinking", "tool", "info", "error"]>;
+                readonly status: Schema.NullOr<Schema.Trim>;
+                readonly payload: Schema.Unknown;
+                readonly createdAt: Schema.String;
+            }>>>;
+            readonly validations: Schema.$Array<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>;
+            }>>;
+            readonly reviews: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.brand<Schema.Trim, "ReviewResultId">;
+                readonly runId: Schema.brand<Schema.Trim, "RunId">;
+                readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+                readonly provider: Schema.Trim;
+                readonly mode: Schema.Literals<readonly ["off", "advisory", "required"]>;
+                readonly status: Schema.Literals<readonly ["pending", "running", "approved", "rejected", "error"]>;
+                readonly summary: Schema.NullOr<Schema.String>;
+                readonly output: Schema.Unknown;
+                readonly createdAt: Schema.String;
+                readonly completedAt: Schema.NullOr<Schema.String>;
+            }>>;
+            readonly artifacts: Schema.$Array<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;
+            }>>;
+            readonly policyDecisions: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.Trim;
+                readonly runId: Schema.brand<Schema.Trim, "RunId">;
+                readonly actionId: Schema.NullOr<Schema.brand<Schema.Trim, "ActionId">>;
+                readonly decision: Schema.Literals<readonly ["allow", "warn", "block"]>;
+                readonly mode: Schema.Literals<readonly ["off", "observe", "enforce"]>;
+                readonly matchedRules: Schema.$Array<Schema.Trim>;
+                readonly reason: Schema.String;
+                readonly createdAt: Schema.String;
+            }>>;
+            readonly queue: Schema.$Array<Schema.Struct<{
+                readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+                readonly score: Schema.Int;
+                readonly unblockCount: Schema.Int;
+                readonly position: Schema.Int;
+            }>>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"workspace.compileTopology">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+            readonly rootPath: Schema.Trim;
+            readonly topology: 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 createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"workspace.syncRemoteFleet">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+            readonly rootPath: Schema.Trim;
+            readonly remoteFleet: 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 createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"workspace.syncServiceFabric">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+            readonly rootPath: Schema.Trim;
+            readonly serviceFabric: 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;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"workspace.registerRemoteHost">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+            readonly host: 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 createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"workspace.updateRemoteHostStatus">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+            readonly hostId: Schema.Trim;
+            readonly status: Schema.Literals<readonly ["registering", "ready", "busy", "degraded", "draining", "offline", "quarantined"]>;
+            readonly currentLeaseCount: Schema.optional<Schema.Number>;
+            readonly lastHeartbeatAt: Schema.optional<Schema.String>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"run.claimRemoteLease">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly hostId: Schema.Trim;
+            readonly leaseId: Schema.Trim;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"run.releaseRemoteLease">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly leaseId: Schema.Trim;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"run.createAdhoc">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+            readonly title: Schema.Trim;
+            readonly runtimeAdapter: Schema.optional<Schema.Literals<readonly ["codex", "claude-code", "pi"]>>;
+            readonly model: Schema.optional<Schema.Trim>;
+            readonly executionTarget: Schema.optional<Schema.Literals<readonly ["local", "remote"]>>;
+            readonly remoteHostId: Schema.optional<Schema.Trim>;
+            readonly runtimeMode: Schema.withDecodingDefault<Schema.Literals<readonly ["approval-required", "full-access"]>>;
+            readonly interactionMode: Schema.withDecodingDefault<Schema.Literals<readonly ["default", "plan"]>>;
+            readonly initialPrompt: Schema.optional<Schema.String>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"run.createForTask">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+            readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+            readonly runtimeAdapter: Schema.optional<Schema.Literals<readonly ["codex", "claude-code", "pi"]>>;
+            readonly model: Schema.optional<Schema.Trim>;
+            readonly executionTarget: Schema.optional<Schema.Literals<readonly ["local", "remote"]>>;
+            readonly remoteHostId: Schema.optional<Schema.Trim>;
+            readonly runtimeMode: Schema.withDecodingDefault<Schema.Literals<readonly ["approval-required", "full-access"]>>;
+            readonly interactionMode: Schema.withDecodingDefault<Schema.Literals<readonly ["default", "plan"]>>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"run.markCompleted">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"run.markFailed">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly errorText: Schema.optional<Schema.String>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"run.setStatus">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly status: Schema.Literals<readonly ["created", "queued", "preparing", "running", "validating", "reviewing", "paused"]>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"run.submitUserMessage">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly messageId: Schema.brand<Schema.Trim, "MessageId">;
+            readonly text: Schema.String;
+            readonly attachments: Schema.optional<Schema.$Array<Schema.Unknown>>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"run.interrupt">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"run.stop">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"run.setRuntimeMode">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly runtimeMode: Schema.Literals<readonly ["approval-required", "full-access"]>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"run.setInteractionMode">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly interactionMode: Schema.Literals<readonly ["default", "plan"]>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"run.respondApproval">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+            readonly decision: Schema.Literals<readonly ["accept", "acceptForSession", "decline", "cancel"]>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"run.respondUserInput">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+            readonly answers: Schema.$Record<Schema.String, Schema.Unknown>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.prepare">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+            readonly adapter: Schema.Literals<readonly ["codex", "claude-code", "pi"]>;
+            readonly executionTarget: Schema.optional<Schema.Literals<readonly ["local", "remote"]>>;
+            readonly remoteHostId: Schema.optional<Schema.Trim>;
+            readonly model: Schema.optional<Schema.Trim>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.attach">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly runtimeId: Schema.brand<Schema.Trim, "EngineRuntimeId">;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.detach">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly reason: Schema.Trim;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.recordMessage">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly messageId: Schema.brand<Schema.Trim, "MessageId">;
+            readonly role: Schema.Literals<readonly ["user", "assistant", "system"]>;
+            readonly text: Schema.String;
+            readonly state: Schema.Literals<readonly ["streaming", "completed", "interrupted", "errored"]>;
+            readonly attachments: Schema.optional<Schema.$Array<Schema.Unknown>>;
+            readonly createdAt: Schema.String;
+            readonly completedAt: Schema.optional<Schema.String>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.startAction">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly actionId: Schema.brand<Schema.Trim, "ActionId">;
+            readonly messageId: Schema.optional<Schema.brand<Schema.Trim, "MessageId">>;
+            readonly actionType: Schema.Trim;
+            readonly title: Schema.Trim;
+            readonly detail: Schema.optional<Schema.String>;
+            readonly payload: Schema.Unknown;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.completeAction">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly actionId: Schema.brand<Schema.Trim, "ActionId">;
+            readonly state: Schema.Trim;
+            readonly detail: Schema.optional<Schema.String>;
+            readonly payload: Schema.Unknown;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.recordLog">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly logId: Schema.Trim;
+            readonly title: Schema.Trim;
+            readonly detail: Schema.optional<Schema.String>;
+            readonly tone: Schema.Literals<readonly ["thinking", "tool", "info", "error"]>;
+            readonly status: Schema.optional<Schema.Trim>;
+            readonly payload: Schema.optional<Schema.Unknown>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.updateMetadata">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly runtimeId: Schema.brand<Schema.Trim, "EngineRuntimeId">;
+            readonly sandboxMode: Schema.optional<Schema.Literals<readonly ["read-only", "workspace-write", "danger-full-access"]>>;
+            readonly isolationMode: Schema.optional<Schema.Literals<readonly ["none", "env", "worktree"]>>;
+            readonly workspaceDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+            readonly homeDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+            readonly tmpDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+            readonly cacheDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+            readonly logsDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+            readonly stateDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+            readonly sessionDir: Schema.optional<Schema.NullOr<Schema.Trim>>;
+            readonly sessionLogPath: Schema.optional<Schema.NullOr<Schema.Trim>>;
+            readonly pid: Schema.optional<Schema.Int>;
+            readonly worktreePath: Schema.optional<Schema.NullOr<Schema.Trim>>;
+            readonly branch: Schema.optional<Schema.NullOr<Schema.Trim>>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.requestApproval">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+            readonly requestKind: Schema.Trim;
+            readonly actionId: Schema.optional<Schema.brand<Schema.Trim, "ActionId">>;
+            readonly payload: Schema.Unknown;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.requestUserInput">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+            readonly payload: Schema.Unknown;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.recordValidation">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly taskId: Schema.optional<Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>>;
+            readonly validationId: Schema.brand<Schema.Trim, "ValidationResultId">;
+            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.optional<Schema.NullOr<Schema.String>>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.recordReview">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly taskId: Schema.optional<Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>>;
+            readonly reviewId: Schema.brand<Schema.Trim, "ReviewResultId">;
+            readonly provider: Schema.Trim;
+            readonly mode: Schema.Literals<readonly ["off", "advisory", "required"]>;
+            readonly status: Schema.Literals<readonly ["pending", "running", "approved", "rejected", "error"]>;
+            readonly summary: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly output: Schema.Unknown;
+            readonly createdAt: Schema.String;
+            readonly completedAt: Schema.optional<Schema.NullOr<Schema.String>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"runtime.registerArtifact">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly taskId: Schema.optional<Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>>;
+            readonly artifactId: Schema.brand<Schema.Trim, "ArtifactId">;
+            readonly kind: Schema.Trim;
+            readonly label: Schema.Trim;
+            readonly path: Schema.optional<Schema.NullOr<Schema.Trim>>;
+            readonly url: Schema.optional<Schema.NullOr<Schema.Trim>>;
+            readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"graph.updateTaskStatus">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+            readonly status: Schema.Literals<readonly ["draft", "open", "ready", "queued", "running", "in_progress", "under_review", "blocked", "unknown", "completed", "failed", "cancelled", "closed"]>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"task.enqueue">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+            readonly score: Schema.Int;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.registerEndpoint">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpoint: Schema.Struct<{
+                readonly id: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+                readonly alias: Schema.Trim;
+                readonly host: Schema.Trim;
+                readonly port: Schema.Int;
+                readonly token: Schema.String;
+                readonly tokenConfigured: Schema.optional<Schema.Boolean>;
+                readonly autoConnect: Schema.optional<Schema.Boolean>;
+                readonly addedAt: Schema.String;
+                readonly lastConnectedAt: Schema.NullOr<Schema.String>;
+            }>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.removeEndpoint">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.updateEndpoint">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly updates: Schema.Unknown;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.connect">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.disconnect">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.pause">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.resume">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.stop">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.continue">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.createRunForTask">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly taskId: Schema.Trim;
+            readonly runId: Schema.Trim;
+            readonly workspaceId: Schema.Trim;
+            readonly runtimeMode: Schema.optional<Schema.String>;
+            readonly interactionMode: Schema.optional<Schema.String>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.refreshTasks">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.addIterations">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly count: Schema.Int;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.removeIterations">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly count: Schema.Int;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.orchestrate.start">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly maxWorkers: Schema.optional<Schema.Int>;
+            readonly maxIterations: Schema.optional<Schema.Int>;
+            readonly directMerge: Schema.optional<Schema.Boolean>;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.orchestrate.pause">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly orchestrationId: Schema.Trim;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.orchestrate.resume">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly orchestrationId: Schema.Trim;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.orchestrate.stop">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly orchestrationId: Schema.Trim;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.getPromptPreview">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly taskId: Schema.Trim;
+            readonly createdAt: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"remote.getIterationOutput">;
+            readonly commandId: Schema.brand<Schema.Trim, "CommandId">;
+            readonly endpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+            readonly taskId: Schema.Trim;
+            readonly createdAt: Schema.String;
+        }>]>;
+        readonly output: Schema.Struct<{
+            readonly sequence: Schema.Int;
+        }>;
+    };
+    readonly replayEvents: {
+        readonly input: Schema.Struct<{
+            readonly fromSequenceExclusive: Schema.Int;
+        }>;
+        readonly output: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.brand<Schema.Trim, "EventId">;
+            readonly sequence: Schema.Int;
+            readonly createdAt: Schema.String;
+            readonly type: Schema.Trim;
+            readonly aggregateId: Schema.Trim;
+            readonly payload: Schema.Unknown;
+        }>>;
+    };
+    readonly getTaskArtifacts: {
+        readonly input: Schema.Struct<{
+            readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+        }>;
+        readonly output: Schema.$Array<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 declare const EngineRuntimeDefaults: Schema.Struct<{
+    readonly runtimeAdapter: Schema.Trim;
+    readonly runMode: Schema.Literals<readonly ["interactive", "autonomous", "supervised"]>;
+    readonly sandboxMode: Schema.Literals<readonly ["read-only", "workspace-write", "danger-full-access"]>;
+    readonly isolationMode: Schema.Literals<readonly ["none", "env", "worktree"]>;
+}>;
+export type EngineRuntimeDefaults = typeof EngineRuntimeDefaults.Type;