@h-rig/contracts 0.0.6-alpha.155 → 0.0.6-alpha.157

package/dist/index.mjs

@@ -2517,6 +2517,19 @@ function latestTimelineEntriesFromCustomEntries(entries, limit) {
   timeline.reverse();
   return timeline;
 }
+// packages/contracts/src/run-record.ts
+function latestRunByTaskId(runs) {
+  const byTask = new Map;
+  const stamp = (run) => Date.parse(run.updatedAt ?? run.startedAt ?? "") || 0;
+  for (const run of runs) {
+    if (!run.taskId)
+      continue;
+    const current = byTask.get(run.taskId);
+    if (!current || stamp(run) >= stamp(current))
+      byTask.set(run.taskId, run);
+  }
+  return byTask;
+}
 // packages/contracts/src/run-status.ts
 var OPERATOR_INACTIVE_RUN_STATUSES = new Set([
   "completed",
@@ -2622,19 +2635,6 @@ var CapabilityReplacementSpec = Schema10.Union([
   CapabilityReplacement,
   TrimmedNonEmptyString
 ]);
-var PluginMeta = Schema10.Struct({
-  id: TrimmedNonEmptyString,
-  version: TrimmedNonEmptyString,
-  provides: Schema10.Array(CapabilityTag),
-  requires: Schema10.optional(Schema10.Array(CapabilityTag)),
-  replaces: Schema10.optional(Schema10.Array(CapabilityReplacementSpec))
-});
-var LoadedPluginDescriptor = Schema10.Struct({
-  meta: PluginMeta,
-  provides: Schema10.Array(CapabilityTag),
-  contributes: Schema10.Unknown,
-  runtime: Schema10.Unknown
-});
 var KernelReplacementGrant = Schema10.Struct({
   pluginId: TrimmedNonEmptyString,
   grantedBy: Schema10.optional(TrimmedNonEmptyString),
@@ -2800,6 +2800,10 @@ var BlockerClassifierRegistration = Schema11.Struct({
   description: Schema11.optional(Schema11.String),
   priority: Schema11.optional(Schema11.Number)
 });
+var SessionExtensionRegistration = Schema11.Struct({
+  id: Schema11.String,
+  description: Schema11.optional(Schema11.String)
+});
 var PluginContributes = Schema11.Struct({
   validators: Schema11.optional(Schema11.Array(ValidatorRegistration)),
   hooks: Schema11.optional(Schema11.Array(HookRegistration)),
@@ -2813,7 +2817,8 @@ var PluginContributes = Schema11.Struct({
   stageMutations: Schema11.optional(Schema11.Array(StageMutation)),
   capabilities: Schema11.optional(Schema11.Array(ProductCapabilityRegistration)),
   panels: Schema11.optional(Schema11.Array(PanelRegistration)),
-  blockerClassifiers: Schema11.optional(Schema11.Array(BlockerClassifierRegistration))
+  blockerClassifiers: Schema11.optional(Schema11.Array(BlockerClassifierRegistration)),
+  sessionExtensions: Schema11.optional(Schema11.Array(SessionExtensionRegistration))
 });
 var RigPlugin = Schema11.Struct({
   name: Schema11.String,
@@ -2961,79 +2966,6 @@ var SupervisorProjection = Schema13.Struct({
   closures: Schema13.Array(TaskClosureSummary),
   anomalies: Schema13.Array(Schema13.String)
 });
-function reduceSupervisorJournal(events) {
-  let processed = 0;
-  let succeeded = 0;
-  let failed = 0;
-  let skipped = 0;
-  let current = null;
-  let idleReason = null;
-  let stopReason = null;
-  let status = "running";
-  let plannedOrder = [];
-  let selectionPolicy = null;
-  const concurrency = null;
-  const closures = [];
-  const anomalies = [];
-  for (const event of events) {
-    switch (event.kind) {
-      case "supervisor.started":
-        status = "running";
-        break;
-      case "supervisor.selection-planned":
-        plannedOrder = [...event.taskIds];
-        selectionPolicy = event.policy;
-        break;
-      case "supervisor.dispatch-started":
-        break;
-      case "supervisor.dispatch-confirmed":
-        current = { taskId: event.taskId, runId: event.runId };
-        break;
-      case "supervisor.dispatch":
-        current = { taskId: event.taskId, runId: event.runId };
-        break;
-      case "supervisor.outcome":
-        processed += 1;
-        if (event.failed) {
-          failed += 1;
-        } else {
-          succeeded += 1;
-        }
-        if (event.closure) {
-          closures.push(event.closure);
-        }
-        if (current?.runId === event.runId) {
-          current = null;
-        } else if (current !== null) {
-          anomalies.push(`outcome for ${event.runId} did not match current ${current.runId}`);
-        }
-        break;
-      case "supervisor.skipped":
-        processed += 1;
-        skipped += 1;
-        break;
-      case "supervisor.idle":
-        status = "idle";
-        idleReason = event.reason;
-        break;
-      case "supervisor.stopped":
-        status = "stopped";
-        stopReason = event.reason;
-        current = null;
-        break;
-      case "supervisor.finished":
-        status = "finished";
-        processed = event.processed;
-        succeeded = event.succeeded;
-        failed = event.failed;
-        skipped = event.skipped ?? skipped;
-        idleReason = event.idleReason;
-        current = null;
-        break;
-    }
-  }
-  return { status, processed, succeeded, failed, skipped, current, plannedOrder, selectionPolicy, concurrency, idleReason, stopReason, closures, anomalies };
-}
 
 // packages/contracts/src/config.ts
 var WorkspaceIsolation = Schema14.Literals([
@@ -6342,7 +6274,7 @@ var PRIMARY_GROUPS = [
     name: "graph",
     summary: "Workspace dependency graph.",
     usage: ["rig graph [--json|--dot]"],
-    commands: [{ command: "[--json|--dot]", description: "Build the dependency graph through @rig/client and print summary, JSON, or DOT.", primary: true }],
+    commands: [{ command: "[--json|--dot]", description: "Build the workspace dependency graph and print summary, JSON, or DOT.", primary: true }],
     examples: ["rig graph", "rig graph --json", "rig graph --dot"]
   },
   {
@@ -6763,11 +6695,374 @@ var WorkspaceRollups = Schema35.Struct({
   assignees: Schema35.Array(AssigneeRollup),
   generatedAt: IsoDateTime
 });
+// packages/contracts/src/panel-protocol.ts
+var RIG_RUN_STOP_PANEL_ACTION = "rig-run:stop";
+var RIG_CAPABILITY_PANEL_SLOT = "capability";
+var RIG_SUPERVISOR_PANEL_ID = "supervisor";
+// packages/contracts/src/control-plane-types.ts
+function strictMergeHeadShaFromGate(result, prUrl, requireGreptile = true) {
+  if (!result.approved) {
+    throw new Error(`Refusing to merge ${prUrl}: strict merge gate is not approved.`);
+  }
+  if (result.evidence.prUrl !== prUrl) {
+    throw new Error(`Refusing to merge ${prUrl}: strict merge gate evidence belongs to ${result.evidence.prUrl}.`);
+  }
+  const headSha = result.evidence.headSha?.trim();
+  if (!headSha) {
+    throw new Error(`Refusing to merge ${prUrl}: strict merge gate did not provide a current head SHA.`);
+  }
+  if (!/^[0-9a-f]{40}$/i.test(headSha)) {
+    throw new Error(`Refusing to merge ${prUrl}: strict merge gate head is not a raw 40-character commit SHA.`);
+  }
+  if (requireGreptile) {
+    if (!result.evidence.greptile.fresh || result.evidence.greptile.currentHeadSha !== headSha) {
+      throw new Error(`Refusing to merge ${prUrl}: strict merge gate approval is not tied to head ${headSha}.`);
+    }
+    if (result.evidence.greptile.mapping !== "score-5-of-5" && result.evidence.greptile.mapping !== "explicit-approved") {
+      throw new Error(`Refusing to merge ${prUrl}: strict merge gate mapping is ${result.evidence.greptile.mapping}.`);
+    }
+  }
+  return headSha;
+}
+// packages/contracts/src/lifecycle-capabilities.ts
+var TASK_VERIFY_CAPABILITY_ID = "default-lifecycle.task-verify";
+var COMPLETION_VERIFICATION_CAPABILITY_ID = "default-lifecycle.completion-verification";
+// packages/contracts/src/browser.ts
+var BROWSER_CONTRACT_SERVICE_CAPABILITY_ID = "browser.contract";
+// packages/contracts/src/memory.ts
+var MEMORY_SERVICE_CAPABILITY_ID = "memory.service";
+var NO_MATCH_RETRIEVAL_CANONICAL_KEY = "__memory_recall__:none";
+// packages/contracts/src/provider-instructions.ts
+var RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID = "provider.runtime-instructions";
+// packages/contracts/src/isolation.ts
+var ISOLATION_BACKEND_CAPABILITY_ID = "isolation.backend";
+// packages/contracts/src/managed-repos.ts
+var MANAGED_REPO_SERVICE_CAPABILITY_ID = "managed-repos.service";
+// packages/contracts/src/task-graph-primitives.ts
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readStringList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
+}
+function unique(values) {
+  return Array.from(new Set(values));
+}
+function readTaskMetadataStringList(task, key) {
+  const taskRecord = task;
+  const topLevel = readStringList(taskRecord[key]);
+  if (topLevel.length > 0)
+    return topLevel;
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  const metadataList = readStringList(metadata?.[key]);
+  if (metadataList.length > 0)
+    return metadataList;
+  if (key === "dependencies") {
+    return readStringList(metadata?.deps);
+  }
+  return [];
+}
+function readTaskBlockingDependencyRefs(task) {
+  return readTaskMetadataStringList(task, "dependencies");
+}
+function readTaskDependencyRefs(task) {
+  return unique([
+    ...readTaskMetadataStringList(task, "dependencies"),
+    ...readTaskMetadataStringList(task, "parentChildDeps")
+  ]);
+}
+function readTaskSourceIssueId(task) {
+  if (typeof task.sourceIssueId === "string" && task.sourceIssueId.length > 0) {
+    return task.sourceIssueId;
+  }
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  if (typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0) {
+    return metadata.sourceIssueId;
+  }
+  const rigMetadata = isObjectRecord(metadata?._rig) ? metadata._rig : null;
+  return typeof rigMetadata?.sourceIssueId === "string" && rigMetadata.sourceIssueId.length > 0 ? rigMetadata.sourceIssueId : null;
+}
+function readTaskScope(task) {
+  const taskRecord = task;
+  const topLevel = readStringList(taskRecord.scope);
+  if (topLevel.length > 0)
+    return unique(topLevel.map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  const metadataScope = readStringList(metadata?.scope);
+  if (metadataScope.length > 0)
+    return unique(metadataScope.map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+  return unique([
+    ...readStringList(metadata?.files),
+    ...readStringList(metadata?.paths)
+  ].map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+}
+function isScopeList(input) {
+  return Array.isArray(input);
+}
+function normalizeScopeInput(input) {
+  return isScopeList(input) ? unique(input.map((entry) => entry.trim()).filter((entry) => entry.length > 0)) : readTaskScope(input);
+}
+function disjointScope(left, right) {
+  const leftScope = new Set(normalizeScopeInput(left));
+  if (leftScope.size === 0)
+    return true;
+  return normalizeScopeInput(right).every((entry) => !leftScope.has(entry));
+}
+function resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId) {
+  if (tasksById.has(ref))
+    return ref;
+  return taskIdBySourceIssueId.get(ref) ?? taskIdByExternalRef.get(ref) ?? null;
+}
+function buildTaskReferenceIndex(tasks) {
+  return {
+    tasksById: new Map(tasks.map((task) => [task.id, task])),
+    taskIdByExternalRef: new Map(tasks.flatMap((task) => task.externalId ? [[task.externalId, task.id]] : [])),
+    taskIdBySourceIssueId: new Map(tasks.flatMap((task) => {
+      const sourceIssueId = readTaskSourceIssueId(task);
+      return sourceIssueId ? [[sourceIssueId, task.id]] : [];
+    }))
+  };
+}
+function computeTaskBlockingDepths(tasks) {
+  const { tasksById, taskIdByExternalRef, taskIdBySourceIssueId } = buildTaskReferenceIndex(tasks);
+  const memo = new Map;
+  const visit = (taskId, stack) => {
+    const cached = memo.get(taskId);
+    if (cached !== undefined)
+      return cached;
+    if (stack.has(taskId))
+      return 0;
+    const task = tasksById.get(taskId);
+    if (!task)
+      return 0;
+    stack.add(taskId);
+    const blockers = readTaskBlockingDependencyRefs(task).map((ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId)).filter((ref) => ref !== null && ref !== taskId);
+    const depth = blockers.length === 0 ? 0 : Math.max(...blockers.map((blockerId) => visit(blockerId, stack) + 1));
+    stack.delete(taskId);
+    memo.set(taskId, depth);
+    return depth;
+  };
+  for (const task of tasks) {
+    visit(task.id, new Set);
+  }
+  return memo;
+}
+function isTaskTerminalStatus(status) {
+  switch (status) {
+    case "closed":
+    case "completed":
+    case "done":
+    case "cancelled":
+    case "canceled":
+      return true;
+    default:
+      return false;
+  }
+}
+function isTaskBlockedStatus(status) {
+  return status === "blocked";
+}
+function isTaskRunnableStatus(status) {
+  if (status === null || status === undefined || status === "")
+    return true;
+  if (isTaskTerminalStatus(status) || isTaskBlockedStatus(status))
+    return false;
+  switch (status) {
+    case "ready":
+    case "open":
+    case "failed":
+      return true;
+    default:
+      return false;
+  }
+}
+function computeTaskDependencyBadges(tasks) {
+  const index = buildTaskReferenceIndex(tasks);
+  const blockingDepths = computeTaskBlockingDepths(tasks);
+  const dependencyIdsByTask = new Map;
+  const unresolvedRefsByTask = new Map;
+  const blocksByTask = new Map;
+  for (const task of tasks) {
+    const dependencyIds = [];
+    const unresolvedRefs = [];
+    for (const ref of readTaskBlockingDependencyRefs(task)) {
+      const dependencyId = resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+      if (dependencyId && dependencyId !== task.id) {
+        dependencyIds.push(dependencyId);
+        const blocks = blocksByTask.get(dependencyId);
+        if (blocks) {
+          blocks.push(task.id);
+        } else {
+          blocksByTask.set(dependencyId, [task.id]);
+        }
+      } else {
+        unresolvedRefs.push(ref);
+      }
+    }
+    dependencyIdsByTask.set(task.id, unique(dependencyIds));
+    unresolvedRefsByTask.set(task.id, unique(unresolvedRefs));
+  }
+  const summaries = new Map;
+  for (const task of tasks) {
+    const dependencyIds = dependencyIdsByTask.get(task.id) ?? [];
+    const unresolvedDependencyRefs = unresolvedRefsByTask.get(task.id) ?? [];
+    const blockedBy = dependencyIds.filter((dependencyId) => {
+      const dependency = index.tasksById.get(dependencyId);
+      return dependency ? !isTaskTerminalStatus(dependency.status) : false;
+    });
+    const blocks = unique(blocksByTask.get(task.id) ?? []);
+    const blocked = isTaskBlockedStatus(task.status) || blockedBy.length > 0;
+    const ready = isTaskRunnableStatus(task.status) && !blocked;
+    const badges = [];
+    if (blocked) {
+      badges.push({
+        kind: "blocked",
+        label: blockedBy.length > 0 ? `blocked \xD7${blockedBy.length}` : "blocked",
+        description: blockedBy.length > 0 ? `Waiting on ${blockedBy.join(", ")}.` : "Task source marks this task blocked.",
+        ...blockedBy.length > 0 ? { count: blockedBy.length } : {},
+        taskIds: blockedBy
+      });
+    } else if (ready) {
+      badges.push({
+        kind: "ready",
+        label: "ready",
+        description: "No open dependencies block this task."
+      });
+    }
+    if (dependencyIds.length > 0 || blocks.length > 0 || unresolvedDependencyRefs.length > 0) {
+      badges.push({
+        kind: "dependency",
+        label: `deps ${dependencyIds.length}/${blocks.length}`,
+        description: [
+          dependencyIds.length > 0 ? `Depends on ${dependencyIds.join(", ")}.` : null,
+          blocks.length > 0 ? `Blocks ${blocks.join(", ")}.` : null,
+          unresolvedDependencyRefs.length > 0 ? `Unresolved refs: ${unresolvedDependencyRefs.join(", ")}.` : null
+        ].filter((part) => part !== null).join(" "),
+        count: dependencyIds.length + blocks.length,
+        taskIds: unique([...dependencyIds, ...blocks])
+      });
+    }
+    summaries.set(task.id, {
+      taskId: task.id,
+      blockingDepth: blockingDepths.get(task.id) ?? 0,
+      dependencyIds,
+      unresolvedDependencyRefs,
+      blockedBy,
+      blocks,
+      blocked,
+      ready,
+      dependencyCount: dependencyIds.length,
+      dependentCount: blocks.length,
+      badges
+    });
+  }
+  return summaries;
+}
+var TASK_STATUSES = new Set([
+  "draft",
+  "open",
+  "ready",
+  "queued",
+  "running",
+  "in_progress",
+  "under_review",
+  "blocked",
+  "unknown",
+  "completed",
+  "failed",
+  "cancelled",
+  "closed"
+]);
+function stringValue(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => entry.trim()) : [];
+}
+function numberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
+}
+function metadataOf(task) {
+  return isObjectRecord(task.metadata) ? task.metadata : {};
+}
+function normalizeTaskStatus(status) {
+  const token = typeof status === "string" ? status.trim().toLowerCase() : "";
+  if (token === "done")
+    return "completed";
+  if (token === "canceled")
+    return "cancelled";
+  return TASK_STATUSES.has(token) ? token : "unknown";
+}
+function toTaskDependencyProjection(task) {
+  const metadata = metadataOf(task);
+  return {
+    id: String(task.id),
+    title: stringValue(task.title),
+    status: normalizeTaskStatus(task.status),
+    priority: numberOrNull(task.priority),
+    metadata,
+    externalId: stringValue(task.externalId),
+    sourceIssueId: stringValue(task.sourceIssueId),
+    dependencies: stringArray(task.dependencies),
+    parentChildDeps: stringArray(task.parentChildDeps),
+    createdAt: stringValue(task.createdAt) ?? "",
+    updatedAt: stringValue(task.updatedAt) ?? "",
+    role: stringValue(task.role),
+    scope: stringArray(task.scope),
+    validationKeys: stringArray(task.validationKeys),
+    labels: stringArray(task.labels),
+    assignees: task.assignees,
+    assignedTo: task.assignedTo
+  };
+}
+function toTaskSummary(task, defaults = {}) {
+  const projection = toTaskDependencyProjection(task);
+  const metadata = metadataOf(task);
+  const createdAt = stringValue(task.createdAt) ?? "1970-01-01T00:00:00.000Z";
+  const updatedAt = stringValue(task.updatedAt) ?? createdAt;
+  return {
+    id: projection.id,
+    workspaceId: stringValue(task.workspaceId) ?? defaults.workspaceId ?? "workspace",
+    graphId: stringValue(task.graphId) ?? defaults.graphId ?? null,
+    externalId: projection.externalId,
+    title: projection.title ?? projection.id,
+    description: stringValue(task.description) ?? stringValue(task.body) ?? "",
+    status: projection.status,
+    priority: numberOrNull(task.priority),
+    role: projection.role,
+    scope: [...projection.scope ?? []],
+    validationKeys: [...projection.validationKeys ?? []],
+    ...projection.sourceIssueId ? { sourceIssueId: projection.sourceIssueId } : {},
+    dependencies: [...projection.dependencies ?? []],
+    parentChildDeps: [...projection.parentChildDeps ?? []],
+    metadata,
+    createdAt,
+    updatedAt
+  };
+}
+// packages/contracts/src/github.ts
+var GITHUB_PROVIDER_CAPABILITY_ID = "github.provider";
+// packages/contracts/src/doctor.ts
+var DOCTOR_RUNNER_CAPABILITY_ID = "doctor.runner";
+function doctorLevelToStatus(level) {
+  return level === "ok" ? "pass" : level;
+}
+function countDoctorFailures(checks) {
+  return checks.filter((entry) => (entry.status ?? doctorLevelToStatus(entry.level ?? "warn")) === "fail").length;
+}
 export {
+  toTaskSummary,
+  toTaskDependencyProjection,
   timelineEntriesFromCustomEntries,
+  strictMergeHeadShaFromGate,
   sessionIdFromSessionFile,
-  reduceSupervisorJournal,
+  resolveTaskReference,
   reduceRunJournal,
+  readTaskSourceIssueId,
+  readTaskScope,
+  readTaskMetadataStringList,
+  readTaskDependencyRefs,
+  readTaskBlockingDependencyRefs,
   projectWorkflowEntries,
   projectCollabWorkflowMarker,
   parseWorkflowTaskSelected,
@@ -6781,14 +7076,19 @@ export {
   parseResumeSentinel,
   parsePauseSentinel,
   parseInboxResolutionSentinel,
+  normalizeTaskStatus,
   normalizeRunStatusToken,
   latestTimelineEntriesFromCustomEntries,
+  latestRunByTaskId,
   isTerminalRunStatus,
+  isTaskTerminalStatus,
   isRunSessionCustomType,
   isOperatorActiveRunStatus,
   isActiveRunStatus,
   helpCatalog,
   foldRunSessionEntries,
+  doctorLevelToStatus,
+  disjointScope,
   decodeRunJournalEvent,
   createWorkflowTaskSelected,
   createWorkflowTargetSelected,
@@ -6797,9 +7097,13 @@ export {
   createWorkflowOperatorNote,
   createWorkflowInboxResolved,
   createWorkflowInboxRequested,
+  countDoctorFailures,
+  computeTaskDependencyBadges,
+  computeTaskBlockingDepths,
   collectResolvedInboxRequests,
   collectPendingInboxRequests,
   canTransitionRunStatus,
+  buildTaskReferenceIndex,
   buildStopSentinel,
   buildResumeSentinel,
   buildPauseSentinel,
@@ -6899,6 +7203,7 @@ export {
   TYPE_FOR_CUSTOM,
   TOP_LEVEL_SECTIONS,
   TERMINAL_RUN_STATUSES,
+  TASK_VERIFY_CAPABILITY_ID,
   SupervisorStoppedEvent,
   SupervisorStopReason,
   SupervisorStatus,
@@ -6928,6 +7233,7 @@ export {
   StageAllowResult,
   Stage,
   SkillRegistration,
+  SessionExtensionRegistration,
   ServiceFabricWorkspaceInput,
   ServiceFabricUpResult,
   ServiceFabricUpInput,
@@ -7128,6 +7434,7 @@ export {
   RemoteConnectCommand,
   RemoteAddIterationsCommand,
   RUN_STATUS_TRANSITIONS,
+  RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID,
   RIG_WS_METHODS,
   RIG_WS_CHANNELS,
   RIG_WORKFLOW_TASK_SELECTED,
@@ -7137,9 +7444,11 @@ export {
   RIG_WORKFLOW_OPERATOR_NOTE,
   RIG_WORKFLOW_INBOX_RESOLVED,
   RIG_WORKFLOW_INBOX_REQUESTED,
+  RIG_SUPERVISOR_PANEL_ID,
   RIG_STOP_SENTINEL_END,
   RIG_STOP_SENTINEL,
   RIG_RUN_TIMELINE_ENTRY,
+  RIG_RUN_STOP_PANEL_ACTION,
   RIG_RUN_STEERING,
   RIG_RUN_STATUS_CHANGED,
   RIG_RUN_STALL_DETECTED,
@@ -7158,6 +7467,7 @@ export {
   RIG_PAUSE_SENTINEL,
   RIG_INBOX_RESOLUTION_SENTINEL,
   RIG_CONTROL_SENTINEL_END,
+  RIG_CAPABILITY_PANEL_SLOT,
   REASONING_EFFORT_OPTIONS_BY_PROVIDER,
   QueueEntry,
   PullRequestConfig,
@@ -7209,7 +7519,6 @@ export {
   PolicyMode,
   PolicyDecisionSummary,
   PolicyDecision,
-  PluginMeta,
   PluginContributes,
   PlanningConfig,
   PlanTask,
@@ -7259,16 +7568,18 @@ export {
   ORCHESTRATION_WS_CHANNELS,
   OPERATOR_INACTIVE_RUN_STATUSES,
   NonNegativeInt,
+  NO_MATCH_RETRIEVAL_CANONICAL_KEY,
   MissingCapability,
   MessageId,
   MergeConfig,
   MODEL_SLUG_ALIASES_BY_PROVIDER,
   MODEL_OPTIONS_BY_PROVIDER,
+  MEMORY_SERVICE_CAPABILITY_ID,
   MAX_WHEN_EXPRESSION_DEPTH,
   MAX_SCRIPT_ID_LENGTH,
   MAX_KEYBINDING_VALUE_LENGTH,
   MAX_KEYBINDINGS_COUNT,
-  LoadedPluginDescriptor,
+  MANAGED_REPO_SERVICE_CAPABILITY_ID,
   KeybindingsConfig,
   KeybindingWhenNode,
   KeybindingShortcut,
@@ -7285,6 +7596,7 @@ export {
   IsolationMode,
   IsoDateTime,
   InsertStageMutation,
+  ISOLATION_BACKEND_CAPABILITY_ID,
   HookToolInput,
   HookResult,
   HookRegistration,
@@ -7315,6 +7627,7 @@ export {
   GitCreateBranchInput,
   GitCheckoutInput,
   GitBranch,
+  GITHUB_PROVIDER_CAPABILITY_ID,
   FunctionalRequirement,
   EventId,
   EpicRollup,
@@ -7351,6 +7664,7 @@ export {
   DependencyGraphModel,
   DependencyEdgeType,
   DependencyEdge,
+  DOCTOR_RUNNER_CAPABILITY_ID,
   DEFAULT_TERMINAL_ID,
   DEFAULT_RUNTIME_MODE,
   DEFAULT_REASONING_EFFORT_BY_PROVIDER,
@@ -7387,6 +7701,7 @@ export {
   CanonicalRequestType,
   CanonicalItemType,
   CUSTOM_TYPE_FOR,
+  COMPLETION_VERIFICATION_CAPABILITY_ID,
   CODEX_REASONING_EFFORT_OPTIONS,
   CLI_OUTPUT_VERSION,
   BootResultDescriptor,
@@ -7394,6 +7709,7 @@ export {
   BlockerClassifierRegistration,
   BlockerClassification,
   BlockerClass,
+  BROWSER_CONTRACT_SERVICE_CAPABILITY_ID,
   AutomationConfig,
   AssistantDeliveryMode,
   AssigneeRollup,