@h-rig/contracts 0.0.6-alpha.15 → 0.0.6-alpha.151

package/dist/src/workflow-journal.js

@@ -0,0 +1,389 @@
+// @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";
+var EMPTY_PROJECTION = {
+  started: null,
+  target: null,
+  task: null,
+  status: null,
+  notes: [],
+  inbox: [],
+  resolvedInbox: [],
+  updatedAt: null
+};
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function optionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function requiredString(value) {
+  const text = optionalString(value);
+  return text ?? null;
+}
+function timestamp(value) {
+  const text = requiredString(value);
+  if (!text)
+    return null;
+  const millis = Date.parse(text);
+  return Number.isFinite(millis) ? text : null;
+}
+function newer(left, right) {
+  if (!right)
+    return false;
+  if (!left)
+    return true;
+  return Date.parse(right) >= Date.parse(left);
+}
+function isWorkflowTarget(value) {
+  return value === "local" || value === "remote";
+}
+function isWorkflowStatus(value) {
+  return value === "starting" || value === "running" || value === "waiting-approval" || value === "waiting-input" || value === "completed" || value === "failed" || value === "stopped";
+}
+function isInboxKind(value) {
+  return value === "approval" || value === "input";
+}
+function isInboxDecision(value) {
+  return value === "approved" || value === "rejected" || value === "answered";
+}
+function parseOwner(value) {
+  const record = asRecord(value);
+  if (!record)
+    return null;
+  const githubUserId = requiredString(record.githubUserId);
+  const login = requiredString(record.login);
+  const namespaceKey = requiredString(record.namespaceKey);
+  return githubUserId && login && namespaceKey ? { githubUserId, login, namespaceKey } : null;
+}
+function parseStringArray(value) {
+  if (!Array.isArray(value))
+    return;
+  const options = value.map(optionalString).filter((option) => option !== undefined);
+  return options.length > 0 ? options : undefined;
+}
+function hasOwn(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+function entryUpdatedAt(entry) {
+  if ("createdAt" in entry)
+    return entry.createdAt;
+  if ("selectedAt" in entry)
+    return entry.selectedAt;
+  if ("changedAt" in entry)
+    return entry.changedAt;
+  if ("notedAt" in entry)
+    return entry.notedAt;
+  if ("requestedAt" in entry)
+    return entry.requestedAt;
+  return entry.resolvedAt;
+}
+function createWorkflowStarted(input) {
+  return {
+    schemaVersion: 1,
+    workflowId: input.workflowId,
+    target: input.target,
+    selectedRepo: input.selectedRepo,
+    owner: input.owner,
+    createdAt: input.createdAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowTargetSelected(input) {
+  return {
+    schemaVersion: 1,
+    target: input.target,
+    ...input.reason ? { reason: input.reason } : {},
+    selectedAt: input.selectedAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowTaskSelected(input) {
+  return {
+    schemaVersion: 1,
+    taskId: input.taskId,
+    ...input.title ? { title: input.title } : {},
+    selectedAt: input.selectedAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowStatusChanged(input) {
+  return {
+    schemaVersion: 1,
+    status: input.status,
+    ...input.detail ? { detail: input.detail } : {},
+    changedAt: input.changedAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowOperatorNote(input) {
+  return {
+    schemaVersion: 1,
+    ...input.noteId ? { noteId: input.noteId } : {},
+    note: input.note,
+    notedAt: input.notedAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowInboxRequested(input) {
+  return {
+    schemaVersion: 1,
+    requestId: input.requestId,
+    kind: input.kind,
+    title: input.title,
+    ...input.body ? { body: input.body } : {},
+    ...input.options && input.options.length > 0 ? { options: input.options } : {},
+    requestedAt: input.requestedAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowInboxResolved(input) {
+  const base = {
+    schemaVersion: 1,
+    requestId: input.requestId,
+    decision: input.decision,
+    resolvedAt: input.resolvedAt ?? new Date().toISOString()
+  };
+  return hasOwn(input, "answer") ? { ...base, answer: input.answer } : base;
+}
+function parseWorkflowStarted(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const workflowId = requiredString(record.workflowId);
+  const target = optionalString(record.target);
+  const selectedRepo = requiredString(record.selectedRepo);
+  const owner = parseOwner(record.owner);
+  const createdAt = timestamp(record.createdAt);
+  if (!workflowId || !isWorkflowTarget(target) || !selectedRepo || !owner || !createdAt)
+    return null;
+  return {
+    schemaVersion: 1,
+    workflowId,
+    target,
+    selectedRepo,
+    owner,
+    createdAt
+  };
+}
+function parseWorkflowTargetSelected(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const target = optionalString(record.target);
+  const selectedAt = timestamp(record.selectedAt);
+  if (!isWorkflowTarget(target) || !selectedAt)
+    return null;
+  const reason = optionalString(record.reason);
+  return {
+    schemaVersion: 1,
+    target,
+    ...reason ? { reason } : {},
+    selectedAt
+  };
+}
+function parseWorkflowTaskSelected(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const taskId = requiredString(record.taskId);
+  const selectedAt = timestamp(record.selectedAt);
+  if (!taskId || !selectedAt)
+    return null;
+  const title = optionalString(record.title);
+  return { schemaVersion: 1, taskId, ...title ? { title } : {}, selectedAt };
+}
+function parseWorkflowStatusChanged(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const status = optionalString(record.status);
+  const changedAt = timestamp(record.changedAt);
+  if (!changedAt || !isWorkflowStatus(status))
+    return null;
+  const detail = optionalString(record.detail);
+  return { schemaVersion: 1, status, ...detail ? { detail } : {}, changedAt };
+}
+function parseWorkflowOperatorNote(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const note = requiredString(record.note);
+  const notedAt = timestamp(record.notedAt);
+  if (!note || !notedAt)
+    return null;
+  const noteId = optionalString(record.noteId);
+  return { schemaVersion: 1, ...noteId ? { noteId } : {}, note, notedAt };
+}
+function parseWorkflowInboxRequested(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const requestId = requiredString(record.requestId);
+  const kind = optionalString(record.kind);
+  const title = requiredString(record.title);
+  const requestedAt = timestamp(record.requestedAt);
+  if (!requestId || !isInboxKind(kind) || !title || !requestedAt)
+    return null;
+  const body = optionalString(record.body);
+  const options = parseStringArray(record.options);
+  return {
+    schemaVersion: 1,
+    requestId,
+    kind,
+    title,
+    ...body ? { body } : {},
+    ...options ? { options } : {},
+    requestedAt
+  };
+}
+function parseWorkflowInboxResolved(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const requestId = requiredString(record.requestId);
+  const decision = optionalString(record.decision);
+  const resolvedAt = timestamp(record.resolvedAt);
+  if (!requestId || !isInboxDecision(decision) || !resolvedAt)
+    return null;
+  const base = { schemaVersion: 1, requestId, decision, resolvedAt };
+  return hasOwn(record, "answer") ? { ...base, answer: record.answer } : base;
+}
+function collectPendingInboxRequests(entries) {
+  const requested = new Map;
+  const resolved = new Map;
+  for (const entry of entries) {
+    if (entry.type !== "custom")
+      continue;
+    if (entry.customType === RIG_WORKFLOW_INBOX_REQUESTED) {
+      const request = parseWorkflowInboxRequested(entry.data);
+      if (request && newer(requested.get(request.requestId)?.requestedAt, request.requestedAt))
+        requested.set(request.requestId, request);
+    } else if (entry.customType === RIG_WORKFLOW_INBOX_RESOLVED) {
+      const resolution = parseWorkflowInboxResolved(entry.data);
+      if (resolution && newer(resolved.get(resolution.requestId), resolution.resolvedAt))
+        resolved.set(resolution.requestId, resolution.resolvedAt);
+    }
+  }
+  for (const [requestId, request] of requested) {
+    const resolvedAt = resolved.get(requestId);
+    if (resolvedAt && Date.parse(resolvedAt) >= Date.parse(request.requestedAt))
+      requested.delete(requestId);
+  }
+  return Array.from(requested.values()).sort((a, b) => Date.parse(b.requestedAt) - Date.parse(a.requestedAt));
+}
+function collectResolvedInboxRequests(entries) {
+  const requested = new Map;
+  const resolved = new Map;
+  for (const entry of entries) {
+    if (entry.type !== "custom")
+      continue;
+    if (entry.customType === RIG_WORKFLOW_INBOX_REQUESTED) {
+      const request = parseWorkflowInboxRequested(entry.data);
+      if (request && newer(requested.get(request.requestId), request.requestedAt))
+        requested.set(request.requestId, request.requestedAt);
+    } else if (entry.customType === RIG_WORKFLOW_INBOX_RESOLVED) {
+      const resolution = parseWorkflowInboxResolved(entry.data);
+      if (resolution && newer(resolved.get(resolution.requestId)?.resolvedAt, resolution.resolvedAt)) {
+        resolved.set(resolution.requestId, resolution);
+      }
+    }
+  }
+  for (const [requestId, resolution] of resolved) {
+    const requestedAt = requested.get(requestId);
+    if (requestedAt && Date.parse(requestedAt) > Date.parse(resolution.resolvedAt))
+      resolved.delete(requestId);
+  }
+  return Array.from(resolved.values()).sort((a, b) => Date.parse(b.resolvedAt) - Date.parse(a.resolvedAt));
+}
+function projectCollabWorkflowMarker(collab) {
+  const status = createWorkflowStatusChanged({
+    status: collab.stale ? "stopped" : "running",
+    detail: collab.stale ? "Stale OMP collab session discovered from the sanctioned collab registry." : "Live OMP collab session discovered from the sanctioned collab registry.",
+    changedAt: collab.updatedAt
+  });
+  return {
+    started: null,
+    target: null,
+    task: null,
+    status,
+    notes: [],
+    inbox: [],
+    resolvedInbox: [],
+    updatedAt: newer(collab.startedAt, collab.updatedAt) ? collab.updatedAt : collab.startedAt
+  };
+}
+function projectWorkflowEntries(entries) {
+  let started = null;
+  let target = null;
+  let task = null;
+  let status = null;
+  const notes = [];
+  let updatedAt = null;
+  for (const entry of entries) {
+    if (entry.type !== "custom")
+      continue;
+    if (entry.customType === RIG_WORKFLOW_STARTED) {
+      const parsed = parseWorkflowStarted(entry.data);
+      if (parsed && newer(started?.createdAt, parsed.createdAt))
+        started = parsed;
+    } else if (entry.customType === RIG_WORKFLOW_TARGET_SELECTED) {
+      const parsed = parseWorkflowTargetSelected(entry.data);
+      if (parsed && newer(target?.selectedAt, parsed.selectedAt))
+        target = parsed;
+    } else if (entry.customType === RIG_WORKFLOW_TASK_SELECTED) {
+      const parsed = parseWorkflowTaskSelected(entry.data);
+      if (parsed && newer(task?.selectedAt, parsed.selectedAt))
+        task = parsed;
+    } else if (entry.customType === RIG_WORKFLOW_STATUS_CHANGED) {
+      const parsed = parseWorkflowStatusChanged(entry.data);
+      if (parsed && newer(status?.changedAt, parsed.changedAt))
+        status = parsed;
+    } else if (entry.customType === RIG_WORKFLOW_OPERATOR_NOTE) {
+      const parsed = parseWorkflowOperatorNote(entry.data);
+      if (parsed)
+        notes.push(parsed);
+    }
+  }
+  notes.sort((a, b) => Date.parse(b.notedAt) - Date.parse(a.notedAt));
+  for (const value of [started, target, task, status, ...notes].map((entry) => entry ? entryUpdatedAt(entry) : null)) {
+    if (newer(updatedAt, value))
+      updatedAt = value;
+  }
+  const inbox = collectPendingInboxRequests(entries);
+  const resolvedInbox = collectResolvedInboxRequests(entries);
+  for (const entry of [...inbox, ...resolvedInbox]) {
+    if (newer(updatedAt, entryUpdatedAt(entry)))
+      updatedAt = entryUpdatedAt(entry);
+  }
+  if (!started && !target && !task && !status && notes.length === 0 && inbox.length === 0 && resolvedInbox.length === 0 && !updatedAt)
+    return EMPTY_PROJECTION;
+  return { started, target, task, status, notes, inbox, resolvedInbox, updatedAt };
+}
+export {
+  projectWorkflowEntries,
+  projectCollabWorkflowMarker,
+  parseWorkflowTaskSelected,
+  parseWorkflowTargetSelected,
+  parseWorkflowStatusChanged,
+  parseWorkflowStarted,
+  parseWorkflowOperatorNote,
+  parseWorkflowInboxResolved,
+  parseWorkflowInboxRequested,
+  createWorkflowTaskSelected,
+  createWorkflowTargetSelected,
+  createWorkflowStatusChanged,
+  createWorkflowStarted,
+  createWorkflowOperatorNote,
+  createWorkflowInboxResolved,
+  createWorkflowInboxRequested,
+  collectResolvedInboxRequests,
+  collectPendingInboxRequests,
+  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.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;

package/dist/src/workspace.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");
@@ -964,7 +967,7 @@ var WorkspaceRemoteHostSummary = Schema4.Struct({
   region: Schema4.NullOr(TrimmedNonEmptyString),
   labels: Schema4.Array(TrimmedNonEmptyString),
   capabilities: Schema4.Array(TrimmedNonEmptyString),
-  runtimeAdapters: Schema4.Array(TrimmedNonEmptyString),
+  runtimeAdapters: Schema4.Array(Schema4.Literal("pi")),
   status: WorkspaceRemoteHostStatus,
   currentLeaseCount: Schema4.Number,
   lastHeartbeatAt: Schema4.NullOr(IsoDateTime),
@@ -1005,7 +1008,7 @@ var WorkspaceSummary = Schema4.Struct({
   title: TrimmedNonEmptyString,
   rootPath: TrimmedNonEmptyString,
   sourceKind: WorkspaceSourceKind,
-  defaultRuntimeAdapter: Schema4.optional(TrimmedNonEmptyString),
+  defaultRuntimeAdapter: Schema4.optional(Schema4.Literal("pi")),
   defaultProvider: Schema4.optional(ProviderKind),
   defaultModel: Schema4.NullOr(TrimmedNonEmptyString),
   topology: Schema4.optional(WorkspaceTopologySummary),