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

package/dist/src/tool-registry.js

@@ -0,0 +1,58 @@
+// @bun
+// packages/contracts/src/tool-registry.ts
+var RUNTIME_SHELL_TOOL_NAMES = [
+  "bash",
+  "sh",
+  "zsh",
+  "git",
+  "bun",
+  "node",
+  "python3",
+  "rg",
+  "grep",
+  "sed",
+  "cat",
+  "ls",
+  "find",
+  "tsc",
+  "gh",
+  "mkdir",
+  "rm",
+  "mv",
+  "cp",
+  "touch",
+  "pwd",
+  "head",
+  "tail",
+  "wc",
+  "sort",
+  "uniq",
+  "awk",
+  "xargs",
+  "dirname",
+  "basename",
+  "realpath",
+  "env",
+  "jq",
+  "tee",
+  "which"
+];
+var RUNTIME_FILE_TOOL_NAMES = [
+  "rig-read",
+  "rig-write",
+  "rig-edit",
+  "rig-glob",
+  "rig-grep"
+];
+var RUNTIME_BROWSER_TOOL_NAMES = [
+  "rig-browser-launch",
+  "rig-browser-check",
+  "rig-browser-attach-info",
+  "rig-browser-e2e",
+  "rig-browser-reset-profile"
+];
+export {
+  RUNTIME_SHELL_TOOL_NAMES,
+  RUNTIME_FILE_TOOL_NAMES,
+  RUNTIME_BROWSER_TOOL_NAMES
+};

package/dist/src/toolchain-sources.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Toolchain-source contribution seam.
+ *
+ * @rig/isolation-plugin's runtime toolchain materializes per-run hook binaries
+ * (guard hooks, lifecycle hooks) and standalone helper binaries (controlled-bash)
+ * by compiling SOURCE files owned by OTHER plugins. Hardcoding those sibling
+ * `packages/<plugin>/src/...` paths inside the toolchain couples it to every
+ * owning plugin's file layout (and trips the rule-8b arch invariant).
+ *
+ * Instead, each owning plugin CONTRIBUTES its build sources as DATA through a
+ * typed capability id, and the toolchain RESOLVES them off the project's plugin
+ * host. Each contributor owns a DISTINCT capability id (the plugin host enforces
+ * one-provider-per-id, so the two contributors cannot share a single id) — the
+ * toolchain merges the contributions it finds.
+ *
+ * Pure: types + branded ids, no behaviour.
+ */
+import type { CapabilityId } from "./capability-id";
+/**
+ * One per-run hook binary build spec: the binary NAME (the basename the runtime
+ * dispatches by) and its `source` entrypoint, expressed RELATIVE to the rig
+ * source root (the same string the toolchain feeds to `buildBinary`).
+ */
+export interface ToolchainHookBinarySource {
+    readonly name: string;
+    readonly source: string;
+}
+/**
+ * A plugin's contribution of runtime-toolchain build sources.
+ *
+ * - `hookBinaries` are compiled uniformly into the runtime `hooks/` directory
+ *   with the shared hook defines.
+ * - `namedSources` are standalone source paths the toolchain compiles with its
+ *   own per-binary defines, keyed by a stable build id (e.g. `"controlled-bash"`).
+ *
+ * All paths are RELATIVE to the rig source root (unchanged from the literals the
+ * toolchain previously embedded), so resolution behaviour is identical.
+ */
+export interface ToolchainSourceContribution {
+    readonly hookBinaries?: ReadonlyArray<ToolchainHookBinarySource>;
+    readonly namedSources?: Readonly<Record<string, string>>;
+}
+/** Stable id for @rig/guard-plugin's toolchain-source contribution. */
+export declare const GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID = "rig.toolchain.sources.guard";
+/** Stable id for @rig/bundle-default-lifecycle's toolchain-source contribution. */
+export declare const LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID = "rig.toolchain.sources.lifecycle";
+/**
+ * The guard-plugin toolchain-source capability id. `defineCapability(...)` (the
+ * provider and the isolation-plugin consumer construct it independently from the
+ * shared id) resolves to a `ToolchainSourceContribution`.
+ */
+export declare const GUARD_TOOLCHAIN_SOURCES: CapabilityId<ToolchainSourceContribution>;
+/** The bundle-default-lifecycle toolchain-source capability id. */
+export declare const LIFECYCLE_TOOLCHAIN_SOURCES: CapabilityId<ToolchainSourceContribution>;

package/dist/src/toolchain-sources.js

@@ -0,0 +1,17 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/toolchain-sources.ts
+var GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID = "rig.toolchain.sources.guard";
+var LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID = "rig.toolchain.sources.lifecycle";
+var GUARD_TOOLCHAIN_SOURCES = makeCapabilityId(GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID);
+var LIFECYCLE_TOOLCHAIN_SOURCES = makeCapabilityId(LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID);
+export {
+  LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID,
+  LIFECYCLE_TOOLCHAIN_SOURCES,
+  GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID,
+  GUARD_TOOLCHAIN_SOURCES
+};

package/dist/src/validation.d.ts

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

package/dist/src/validation.js

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

package/dist/src/workflow-journal.d.ts

@@ -0,0 +1,92 @@
+export declare const RIG_WORKFLOW_STARTED: "rig.workflow.started";
+export declare const RIG_WORKFLOW_TARGET_SELECTED: "rig.workflow.target.selected";
+export declare const RIG_WORKFLOW_TASK_SELECTED: "rig.workflow.task.selected";
+export declare const RIG_WORKFLOW_STATUS_CHANGED: "rig.workflow.status.changed";
+export declare const RIG_WORKFLOW_OPERATOR_NOTE: "rig.workflow.operator.note";
+export declare const RIG_WORKFLOW_INBOX_REQUESTED: "rig.workflow.inbox.requested";
+export declare const RIG_WORKFLOW_INBOX_RESOLVED: "rig.workflow.inbox.resolved";
+export type RigWorkflowEntryType = typeof RIG_WORKFLOW_STARTED | typeof RIG_WORKFLOW_TARGET_SELECTED | typeof RIG_WORKFLOW_TASK_SELECTED | typeof RIG_WORKFLOW_STATUS_CHANGED | typeof RIG_WORKFLOW_OPERATOR_NOTE | typeof RIG_WORKFLOW_INBOX_REQUESTED | typeof RIG_WORKFLOW_INBOX_RESOLVED;
+export type RigWorkflowTarget = "local" | "remote";
+export type RigWorkflowOwner = {
+    githubUserId: string;
+    login: string;
+    namespaceKey: string;
+};
+export type RigWorkflowStarted = {
+    schemaVersion: 1;
+    workflowId: string;
+    target: RigWorkflowTarget;
+    selectedRepo: string;
+    owner: RigWorkflowOwner;
+    createdAt: string;
+};
+export type RigWorkflowTargetSelected = {
+    schemaVersion: 1;
+    target: RigWorkflowTarget;
+    reason?: string;
+    selectedAt: string;
+};
+export type RigWorkflowTaskSelected = {
+    schemaVersion: 1;
+    taskId: string;
+    title?: string;
+    selectedAt: string;
+};
+export type RigWorkflowStatus = "starting" | "running" | "waiting-approval" | "waiting-input" | "completed" | "failed" | "stopped";
+export type RigWorkflowStatusChanged = {
+    schemaVersion: 1;
+    status: RigWorkflowStatus;
+    detail?: string;
+    changedAt: string;
+};
+export type RigWorkflowOperatorNote = {
+    schemaVersion: 1;
+    noteId?: string;
+    note: string;
+    notedAt: string;
+};
+export type RigWorkflowInboxRequested = {
+    schemaVersion: 1;
+    requestId: string;
+    kind: "approval" | "input";
+    title: string;
+    body?: string;
+    options?: readonly string[];
+    requestedAt: string;
+};
+export type RigWorkflowInboxResolved = {
+    schemaVersion: 1;
+    requestId: string;
+    decision: "approved" | "rejected" | "answered";
+    answer?: unknown;
+    resolvedAt: string;
+};
+export type RigWorkflowProjection = {
+    started: RigWorkflowStarted | null;
+    target: RigWorkflowTargetSelected | null;
+    task: RigWorkflowTaskSelected | null;
+    status: RigWorkflowStatusChanged | null;
+    notes: readonly RigWorkflowOperatorNote[];
+    inbox: readonly RigWorkflowInboxRequested[];
+    resolvedInbox: readonly RigWorkflowInboxResolved[];
+    updatedAt: string | null;
+};
+export type RigWorkflowCustomEntry = {
+    type: string;
+    customType?: string;
+    data?: unknown;
+};
+export type RigCollabWorkflowMarkerInput = {
+    sessionId: string;
+    sessionPath: string;
+    cwd: string;
+    title: string;
+    joinLink: string;
+    webLink: string;
+    relayUrl?: string;
+    selectedRepo?: string;
+    owner?: Partial<RigWorkflowOwner>;
+    startedAt: string;
+    updatedAt: string;
+    stale: boolean;
+};

package/dist/src/workflow-journal.js

@@ -0,0 +1,18 @@
+// @bun
+// packages/contracts/src/workflow-journal.ts
+var RIG_WORKFLOW_STARTED = "rig.workflow.started";
+var RIG_WORKFLOW_TARGET_SELECTED = "rig.workflow.target.selected";
+var RIG_WORKFLOW_TASK_SELECTED = "rig.workflow.task.selected";
+var RIG_WORKFLOW_STATUS_CHANGED = "rig.workflow.status.changed";
+var RIG_WORKFLOW_OPERATOR_NOTE = "rig.workflow.operator.note";
+var RIG_WORKFLOW_INBOX_REQUESTED = "rig.workflow.inbox.requested";
+var RIG_WORKFLOW_INBOX_RESOLVED = "rig.workflow.inbox.resolved";
+export {
+  RIG_WORKFLOW_TASK_SELECTED,
+  RIG_WORKFLOW_TARGET_SELECTED,
+  RIG_WORKFLOW_STATUS_CHANGED,
+  RIG_WORKFLOW_STARTED,
+  RIG_WORKFLOW_OPERATOR_NOTE,
+  RIG_WORKFLOW_INBOX_RESOLVED,
+  RIG_WORKFLOW_INBOX_REQUESTED
+};

package/dist/src/workspace-config.d.ts

@@ -0,0 +1,18 @@
+import type { CapabilityId } from "./capability-id";
+export type EnsureDeclarativeConfigInput = {
+    readonly projectRoot: string;
+    readonly repoSlug?: string;
+};
+export type EnsureDeclarativeConfigResult = {
+    /** True when this call wrote a new `.rig/rigfig.toml`. */
+    readonly created: boolean;
+    /** The rigfig path when one now exists (created or pre-existing), else null. */
+    readonly path: string | null;
+    /** Why nothing was created (code config present, no plugin produced a config, …). */
+    readonly reason?: string;
+};
+export interface WorkspaceConfigEnsureService {
+    ensureDeclarativeConfig(input: EnsureDeclarativeConfigInput): EnsureDeclarativeConfigResult;
+}
+export declare const WORKSPACE_CONFIG_ENSURE_CAPABILITY_ID = "workspace.config.ensure";
+export declare const WORKSPACE_CONFIG_ENSURE: CapabilityId<WorkspaceConfigEnsureService>;

package/dist/src/workspace-config.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/workspace-config.ts
+var WORKSPACE_CONFIG_ENSURE_CAPABILITY_ID = "workspace.config.ensure";
+var WORKSPACE_CONFIG_ENSURE = makeCapabilityId(WORKSPACE_CONFIG_ENSURE_CAPABILITY_ID);
+export {
+  WORKSPACE_CONFIG_ENSURE_CAPABILITY_ID,
+  WORKSPACE_CONFIG_ENSURE
+};

package/dist/src/workspace.d.ts

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