@xemahq/ui-kernel 0.1.4

package/src/lib/system-bus/system-bus-builder.ts

@@ -0,0 +1,157 @@
+import { PaletteEntrySource } from './enums';
+import {
+  parseDeeplink,
+  type DeeplinkBus,
+  type ParsedDeeplink,
+} from './deeplink';
+import {
+  type CapabilityInvoker,
+  type DeeplinkResolver,
+  type PaletteSource,
+  type WindowManager,
+} from './host-ports';
+import { IntentRegistry } from './intent-registry';
+import {
+  type IntentPaletteEntry,
+  type PaletteBus,
+  type PaletteEntry,
+  type PaletteQuery,
+} from './palette';
+import type { SystemBus } from './system-bus';
+
+/**
+ * Host-supplied ports needed to build a real {@link SystemBus}. The kernel
+ * ships the framework-agnostic pieces (`IntentRegistry`, `parseDeeplink`);
+ * the host supplies the concrete backend + shell behind these ports. NONE
+ * are optional — a missing port is a wiring bug and `buildSystemBus` fails
+ * fast.
+ */
+export interface SystemBusPorts {
+  /** Relays `capability.invoke` to the backend capability-router. */
+  readonly capability: CapabilityInvoker;
+  /** Sources the capability half of the palette from the registry. */
+  readonly palette: PaletteSource;
+  /** Realises the window plane (open / focus / close / arrange). */
+  readonly windows: WindowManager;
+  /** Navigates the running shell to a parsed deeplink target. */
+  readonly deeplink: DeeplinkResolver;
+}
+
+function assertPort<T>(value: T | undefined, name: string): T {
+  if (value === undefined || value === null) {
+    throw new Error(
+      `[xema-ui-kernel] SystemBus port "${name}" was not supplied. ` +
+        'The host MUST provide every SystemBus port (capability / palette / ' +
+        'windows / deeplink) — there is no silent no-op fallback.',
+    );
+  }
+  return value;
+}
+
+/**
+ * Build the palette bus by unioning the host's capability source with the
+ * SystemBus intent registry. The capability half is already actor-scoped
+ * server-side; the intent half is flattened from every registration's
+ * provided actions. The host's `PaletteSource.queryCapabilities` applies
+ * its own ranking to the capability rows; intent rows are filtered here by
+ * a case-insensitive label/biome substring match (the contract leaves the
+ * ranker to the host — substring is the deterministic floor).
+ *
+ * Pure orchestration: no authorization. Selecting a capability entry
+ * routes through `capability.invoke` where the backend decides allow/deny.
+ */
+function buildPaletteBus(
+  capabilitySource: PaletteSource,
+  intents: IntentRegistry,
+): PaletteBus {
+  function intentEntries(query: PaletteQuery): IntentPaletteEntry[] {
+    if (query.sources && !query.sources.includes(PaletteEntrySource.Intent)) {
+      return [];
+    }
+    const needle = query.text.trim().toLowerCase();
+    const out: IntentPaletteEntry[] = [];
+    // The IntentRegistry exposes registrations only through `resolve(kind)`;
+    // for a palette we want every provided action regardless of kind, so we
+    // read the public snapshot the registry exposes via `snapshot()`.
+    for (const registration of intents.snapshot()) {
+      for (const action of registration.provides) {
+        if (
+          needle.length > 0 &&
+          !action.label.toLowerCase().includes(needle) &&
+          !registration.biomeId.toLowerCase().includes(needle)
+        ) {
+          continue;
+        }
+        out.push({
+          source: PaletteEntrySource.Intent,
+          id: `${registration.biomeId}:${action.id}`,
+          label: action.label,
+          biomeId: registration.biomeId,
+        });
+      }
+    }
+    return out;
+  }
+
+  return {
+    async query(query: PaletteQuery): Promise<readonly PaletteEntry[]> {
+      const wantsCapabilities =
+        !query.sources || query.sources.includes(PaletteEntrySource.Capability);
+      const capabilityEntries = wantsCapabilities
+        ? await capabilitySource.queryCapabilities(query)
+        : [];
+      return [...capabilityEntries, ...intentEntries(query)];
+    },
+    subscribe(listener: () => void): () => void {
+      const offCapabilities = capabilitySource.subscribe(listener);
+      const offIntents = intents.subscribe(listener);
+      return () => {
+        offCapabilities();
+        offIntents();
+      };
+    },
+  };
+}
+
+function buildDeeplinkBus(resolver: DeeplinkResolver): DeeplinkBus {
+  return {
+    parse(raw: string): ParsedDeeplink {
+      return parseDeeplink(raw);
+    },
+    async resolve(target: string | ParsedDeeplink): Promise<void> {
+      // Parse-first so a malformed deeplink fails fast in the kernel parser
+      // before the host navigation ever runs.
+      const parsed = typeof target === 'string' ? parseDeeplink(target) : target;
+      await resolver.resolve(parsed);
+    },
+  };
+}
+
+/**
+ * Construct the real {@link SystemBus} from the host's ports plus the
+ * kernel's framework-agnostic runtime (`IntentRegistry` + `parseDeeplink`).
+ * The `intents` registry is owned by the bus instance so biome
+ * registrations and palette intent rows share one source of truth.
+ *
+ * Fail-fast: every port is required. No port may be silently stubbed. This
+ * is the framework-agnostic builder — any host adapter (Next.js, React-
+ * Router, …) wires its concrete ports and calls this.
+ */
+export function buildSystemBus(ports: SystemBusPorts): SystemBus {
+  const capability = assertPort(ports.capability, 'capability');
+  const paletteSource = assertPort(ports.palette, 'palette');
+  const windows = assertPort(ports.windows, 'windows');
+  const deeplinkResolver = assertPort(ports.deeplink, 'deeplink');
+
+  // Concrete type (not the `IntentBus` interface): the palette builder
+  // reads `intents.snapshot()`, which is an `IntentRegistry` affordance.
+  const intents: IntentRegistry = new IntentRegistry();
+
+  return {
+    capability,
+    intents,
+    palette: buildPaletteBus(paletteSource, intents),
+    deeplink: buildDeeplinkBus(deeplinkResolver),
+    windows,
+  };
+}

package/src/lib/system-bus/system-bus.ts

@@ -0,0 +1,37 @@
+import type { CapabilityBus } from './capability-invoke';
+import type { DeeplinkBus } from './deeplink';
+import type { IntentBus } from './intents';
+import type { PaletteBus } from './palette';
+import type { WindowBus } from './windows';
+
+/**
+ * `SystemBus` — the framework-agnostic OS-orchestration plane every
+ * frontend biome reaches through its {@link HostBridge}.
+ *
+ * **Pure orchestration. Zero policy.** The SystemBus routes intent,
+ * navigation, capability invocation, palette, and windowing. It NEVER
+ * authorizes, denies, or duplicates policy. Every `capability.invoke`
+ * routes through the backend capability-router, which is the single
+ * authority on auth / tenancy / policy / audit. The SystemBus's job is to
+ * carry orchestration metadata faithfully and relay the router's outcome —
+ * a denial surfaces as an observable result (`output === undefined` +
+ * `auditId`), never a silent swallow.
+ *
+ * The contract is framework-agnostic on purpose: it imports no Vite, no
+ * Next.js, no React-Router, and no generated transport client. A concrete
+ * host (Vite SPA today, Next.js tomorrow) implements each sub-bus against
+ * its router, its capability-router client, and its window manager. Biome
+ * code is identical across hosts.
+ */
+export interface SystemBus {
+  /** Capability invocation → backend router (backend enforces; bus adds none). */
+  readonly capability: CapabilityBus;
+  /** Cross-biome "Open with… / Send to…" intent registry. */
+  readonly intents: IntentBus;
+  /** Command palette = capabilities ∪ registered intents. */
+  readonly palette: PaletteBus;
+  /** Typed `xema://` deeplink parse + resolve. */
+  readonly deeplink: DeeplinkBus;
+  /** Host window manager (open / focus / close / arrange). */
+  readonly windows: WindowBus;
+}

package/src/lib/system-bus/windows.ts

@@ -0,0 +1,51 @@
+import { WindowArrangement, WindowOp } from './enums';
+
+/**
+ * Window-management plane of the SystemBus.
+ *
+ * A "window" is a host-managed surface hosting a biome route or object.
+ * The contract is framework-agnostic: the host (desktop shell, tiling WM,
+ * tabbed SPA) decides how a window is physically realised, but every host
+ * exposes the same closed {@link WindowOp} verb set. The SystemBus carries
+ * no authorization here — windowing is pure shell orchestration.
+ */
+
+/** Identifier of an open window, minted by the host on `open`. */
+export type WindowId = string;
+
+/** A request to open a new window onto a deeplink target. */
+export interface OpenWindowRequest {
+  /** The `xema://` deeplink the new window should display. */
+  readonly target: string;
+  /** Optional human title; the host falls back to the target's own title. */
+  readonly title?: string;
+}
+
+/** Snapshot of an open window. */
+export interface WindowState {
+  readonly id: WindowId;
+  readonly target: string;
+  readonly title: string;
+  readonly focused: boolean;
+}
+
+/**
+ * The `windows` surface of the SystemBus. Each method maps to a closed
+ * {@link WindowOp}. Operations a host cannot honour reject fail-fast
+ * rather than silently no-op, so callers never assume a window exists
+ * when it does not.
+ */
+export interface WindowBus {
+  /** {@link WindowOp.Open} — open a new window; resolves with its id. */
+  open(request: OpenWindowRequest): Promise<WindowId>;
+  /** {@link WindowOp.Focus} — bring a window to the foreground. Rejects on unknown id. */
+  focus(id: WindowId): Promise<void>;
+  /** {@link WindowOp.Close} — close a window. Rejects on unknown id. */
+  close(id: WindowId): Promise<void>;
+  /** {@link WindowOp.Arrange} — apply a layout to all open windows. */
+  arrange(arrangement: WindowArrangement): Promise<void>;
+  /** Current snapshot of open windows (for a window-list UI). */
+  list(): readonly WindowState[];
+  /** Subscribe to window-set changes; returns an unsubscribe fn. */
+  subscribe(listener: () => void): () => void;
+}

package/src/org-db/components/DbResultTable.tsx

@@ -0,0 +1,143 @@
+import { useMemo } from 'react';
+
+export interface DbResultTableProps {
+  columns: Array<{ name: string; type?: string }>;
+  rows: unknown[][];
+  rowCount: number;
+  truncated: boolean;
+  durationMs?: number;
+  statement?: string;
+}
+
+function toDisplayValue(value: unknown): string {
+  if (value === null || value === undefined) return '';
+  if (typeof value === 'string') return value;
+  if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+    return String(value);
+  }
+  if (value instanceof Date) return value.toISOString();
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+function escapeCsvValue(value: string): string {
+  if (value.includes('"') || value.includes(',') || value.includes('\n')) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+
+export function DbResultTable(props: DbResultTableProps) {
+  const { columns, rows, rowCount, truncated, durationMs, statement } = props;
+
+  const csvContent = useMemo(() => {
+    const header = columns.map((column) => escapeCsvValue(column.name)).join(',');
+    const dataLines = rows.map((row) =>
+      row
+        .map((cell) => {
+          const printable = cell === null || cell === undefined ? '' : toDisplayValue(cell);
+          return escapeCsvValue(printable);
+        })
+        .join(','),
+    );
+    return [header, ...dataLines].join('\n');
+  }, [columns, rows]);
+
+  const displayedCount = rows.length;
+
+  const handleDownloadCsv = () => {
+    const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement('a');
+    link.href = url;
+    link.download = 'query-results.csv';
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+  };
+
+  return (
+    <section className="rounded-lg border border-border bg-card text-card-foreground">
+      {statement ? (
+        <details className="border-b border-border px-4 py-3">
+          <summary className="cursor-pointer text-sm font-medium text-foreground">SQL statement</summary>
+          <pre className="mt-3 overflow-x-auto rounded-md bg-muted p-3 text-xs leading-6 text-muted-foreground">
+            <code>{statement}</code>
+          </pre>
+        </details>
+      ) : null}
+
+      {truncated ? (
+        <div className="border-b border-amber-300/60 bg-amber-100/60 px-4 py-3 text-sm text-amber-900">
+          Showing first {displayedCount} rows of {rowCount} total - download CSV for full results.
+        </div>
+      ) : null}
+
+      <div className="flex items-center justify-between gap-3 border-b border-border px-4 py-3">
+        <div className="text-sm text-muted-foreground">
+          {rowCount === 0 ? 'No rows returned' : `${displayedCount} row${displayedCount === 1 ? '' : 's'} shown`}
+        </div>
+        <button
+          type="button"
+          className="inline-flex items-center rounded-md border border-input bg-background px-3 py-1.5 text-xs font-medium text-foreground hover:bg-accent"
+          onClick={handleDownloadCsv}
+        >
+          Download CSV
+        </button>
+      </div>
+
+      {rowCount === 0 ? (
+        <div className="px-4 py-8 text-center text-sm text-muted-foreground">No rows returned</div>
+      ) : (
+        <div className="overflow-x-auto">
+          <table className="min-w-full border-collapse text-sm">
+            <thead>
+              <tr className="border-b border-border bg-muted/40">
+                {columns.map((column) => (
+                  <th key={column.name} className="px-4 py-3 text-left font-medium text-foreground">
+                    <div className="flex flex-wrap items-center gap-2">
+                      <span>{column.name}</span>
+                      {column.type ? (
+                        <span className="rounded-full border border-border bg-background px-2 py-0.5 text-[11px] font-normal uppercase tracking-wide text-muted-foreground">
+                          {column.type}
+                        </span>
+                      ) : null}
+                    </div>
+                  </th>
+                ))}
+              </tr>
+            </thead>
+            <tbody>
+              {rows.map((row, rowIndex) => (
+                <tr key={`row-${rowIndex}`} className="border-b border-border/70 align-top">
+                  {columns.map((column, colIndex) => {
+                    const cell = row[colIndex];
+                    return (
+                      <td key={`${column.name}-${rowIndex}`} className="px-4 py-2 text-muted-foreground">
+                        {cell === null || cell === undefined ? (
+                          <span className="italic text-muted-foreground">null</span>
+                        ) : (
+                          <span className="break-all text-foreground">{toDisplayValue(cell)}</span>
+                        )}
+                      </td>
+                    );
+                  })}
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        </div>
+      )}
+
+      {typeof durationMs === 'number' ? (
+        <footer className="border-t border-border px-4 py-2 text-xs text-muted-foreground">
+          Query ran in {Math.max(0, Math.round(durationMs))} ms
+        </footer>
+      ) : null}
+    </section>
+  );
+}

package/src/org-db/index.ts

@@ -0,0 +1 @@
+export { DbResultTable, type DbResultTableProps } from './components/DbResultTable';

package/src/registry/index.ts

@@ -0,0 +1,8 @@
+export * from './lib/extension-points';
+export * from './lib/composition-validation-host';
+export * from './lib/biome-slot';
+export * from './lib/biomes-enabled-context';
+export * from './lib/session-selectors';
+export * from './lib/session-context-builder';
+export * from './lib/session-context-provider';
+export * from './lib/primitives';

package/src/registry/lib/biome-slot.tsx

@@ -0,0 +1,47 @@
+import { Fragment, type ReactElement } from 'react';
+
+import { biomeRegistry, useBiomeRegistryRevision } from '../../index';
+
+import { useBiomesEnabled } from './biomes-enabled-context';
+
+export interface BiomeSlotProps {
+  /** Slot name biomes target via `PanelContribution.slot`. */
+  readonly name: string;
+  /** Optional fallback rendered when no biome contributes to this slot. */
+  readonly fallback?: ReactElement | null;
+}
+
+/**
+ * Renders every biome-contributed panel registered for `name`, sorted
+ * by `weight`. When no biome contributes, renders `fallback` (or null).
+ *
+ * Reactive: subscribes to the biome registry's revision counter via
+ * `useBiomeRegistryRevision()`, so the slot re-renders automatically
+ * when a biome registers or unregisters (i.e. when `bootstrapBiomes()`
+ * finishes after the host shell has already painted, or when the admin
+ * UI disables a biome at runtime).
+ *
+ * Master-disable: if the surrounding host wraps the tree in
+ * `<BiomeHostProvider biomes="disabled">`, this slot short-circuits
+ * to its fallback regardless of registry state.
+ *
+ * Bridge access: biome panels reach host services via `useHostBridge()`,
+ * which reads from `HostBridgeContext`. The host shell mounts the
+ * provider above the route tree once; `<BiomeSlot>` does not own the
+ * provider so a host can place slots anywhere without nesting providers.
+ */
+export function BiomeSlot(props: BiomeSlotProps): ReactElement | null {
+  // Subscribe so this slot re-renders when biomes register/change.
+  useBiomeRegistryRevision();
+  const enabled = useBiomesEnabled();
+  if (!enabled) return props.fallback ?? null;
+  const panels = biomeRegistry.panelsForSlot(props.name);
+  if (panels.length === 0) return props.fallback ?? null;
+  return (
+    <Fragment>
+      {panels.map((panel) => (
+        <Fragment key={panel.id}>{panel.render()}</Fragment>
+      ))}
+    </Fragment>
+  );
+}

package/src/registry/lib/biomes-enabled-context.ts

@@ -0,0 +1,20 @@
+import { createContext, useContext } from 'react';
+
+/**
+ * React-side mirror of `biomeRegistry.isEnabled()`. Hosts that embed
+ * `@xemahq/ui-kernel/registry` without participating in Xema's biome
+ * ecosystem flip this to `false` via
+ * `<BiomeHostProvider biomes="disabled">`. `BiomeSlot` and
+ * `useBiomeRoutes` consult this context for cheap render-time
+ * short-circuit; the singleton registry's `isEnabled()` flag covers the
+ * imperative paths (`bootstrapBiomes`, `register`, `unregister`).
+ *
+ * Default is `true` — a host that mounts no provider gets the standard
+ * biome-enabled surface. Embedding hosts opt out explicitly.
+ */
+export const BiomesEnabledContext = createContext<boolean>(true);
+BiomesEnabledContext.displayName = 'BiomesEnabledContext';
+
+export function useBiomesEnabled(): boolean {
+  return useContext(BiomesEnabledContext);
+}

package/src/registry/lib/composition-validation-host.ts

@@ -0,0 +1,37 @@
+/**
+ * Host-slot-aware composition validation.
+ *
+ * The kernel's `validateBiomeComposition` is host-agnostic: it takes the
+ * set of known slot ids as input. This thin wrapper binds it to the host
+ * shell's actual slot catalog (`HostExtensionSlots`) so callers don't have
+ * to assemble the set themselves. It is the function the host bootstrap
+ * calls after every enabled biome has registered.
+ */
+
+import {
+  type CompositionDiagnostic,
+  type FrontendBiome,
+  validateBiomeComposition,
+} from '../../index';
+
+import { HostExtensionSlots } from './extension-points';
+
+/**
+ * Every slot id the host shell renders a `<BiomeSlot>` for. A panel
+ * targeting anything outside this set (and not a `<owner>/<name>`
+ * biome-owned slot) is flagged as unknown.
+ */
+const HOST_SLOT_IDS: ReadonlySet<string> = new Set(
+  Object.values(HostExtensionSlots),
+);
+
+/**
+ * Validate the merged composition of the given biomes against the host
+ * slot catalog. Returns structured diagnostics; never throws, never logs
+ * (the caller owns the fail-fast / surface policy).
+ */
+export function validateHostBiomeComposition(
+  biomes: readonly FrontendBiome[],
+): readonly CompositionDiagnostic[] {
+  return validateBiomeComposition(biomes, { knownSlots: HOST_SLOT_IDS });
+}

package/src/registry/lib/extension-points.ts

@@ -0,0 +1,134 @@
+/**
+ * Catalog of frontend extension points the host shell exposes to biomes.
+ *
+ * The host renders `<BiomeSlot name="…">` boundaries at the call sites
+ * below; biomes register `panels` against the same slot id in their
+ * `FrontendBiome` contribution, and the registry stitches the two
+ * together at runtime. The host itself is biome-agnostic — it knows
+ * nothing about which biome (if any) fills a given slot.
+ *
+ * Routes work the same way: biomes push `RouteContribution`s and the
+ * host calls `useBiomeRoutes()` to mount them. Nav items merge into
+ * `getNavSections()` likewise.
+ *
+ * ── Adding a new host extension point ────────────────────────────────
+ *   1. Add a new entry to `HostExtensionSlots` below with a JSDoc that
+ *      describes WHERE the slot is rendered, WHAT biomes should put in
+ *      it, and any in-scope CONTEXT (e.g., "run-detail page — runId is
+ *      readable via the host bridge's location").
+ *   2. Mount `<BiomeSlot name={HostExtensionSlots.X} />` in the host
+ *      page.
+ *   3. Document the slot in `data/docs/public/biomes/04-frontend-extensions.md`.
+ *
+ * Removing a host slot is a breaking change — bump the kernel package
+ * major version.
+ *
+ * ── Biome-owned extension points (cross-biome extension) ────────────
+ * Biomes can ALSO expose their own slots so OTHER biomes can extend
+ * THEM. The convention is to namespace biome-owned slot ids as
+ * `<biome-id>/<slot-name>` (e.g., `software-dev/page-actions`)
+ * and to publish the typed catalog from the biome's own package
+ * alongside its `FrontendBiomeFactory`. Other biomes import the
+ * exported constants directly. Result: the host doesn't see biome
+ * internals, biomes don't import each other's source — they meet at
+ * the slot-id strings, which are typed by the publishing biome.
+ *
+ * Slot-name collisions are caught at runtime by the registry's
+ * fail-fast duplicate-key guard, so two biomes can't shadow each
+ * other accidentally.
+ */
+export const HostExtensionSlots = {
+  // ── Org-level shell ────────────────────────────────────────────────
+  /**
+   * Top-bar actions to the right of the org switcher. Visible on every
+   * authenticated page. Use for org-wide quick actions or status
+   * indicators (e.g., catalog instance health, Slack-notifier badge).
+   */
+  OrgHeaderActions: 'org-header-actions',
+
+  /**
+   * Cards on the public Biomes-overview page. Use for biome authors
+   * to advertise capabilities outside the authenticated app shell.
+   * (Reserved — host wiring may land later; safe to register today.)
+   */
+  BiomesOverviewCards: 'biomes-overview-cards',
+
+  // ── Project home ───────────────────────────────────────────────────
+  /**
+   * Cards on the project home dashboard, between the SetupChecklist
+   * and the ActivityTimeline. Use for biome-shipped status cards or
+   * quick-launch tiles. `bridge.auth.getProjectId()` is in scope.
+   */
+  ProjectOverviewCards: 'project-overview-cards',
+
+  /**
+   * Secondary cards on the project home, rendered below the activity
+   * timeline. Use for less prominent biome surfaces (recent runs,
+   * insights, recommendations).
+   */
+  ProjectOverviewSecondary: 'project-overview-secondary',
+
+  /**
+   * CTAs rendered into the dashboard's empty-state row when the project
+   * has no recent activity. Biomes can suggest "first run" actions.
+   */
+  DashboardEmptyState: 'dashboard-empty-state',
+
+  // ── Run detail ─────────────────────────────────────────────────────
+  /**
+   * Header chip row on the workflow run-detail page, alongside the
+   * status badge. Use for biome-shipped meta-actions (open in
+   * external system, copy entity ref, …).
+   */
+  RunDetailActions: 'run-detail-actions',
+
+  /**
+   * Side-panel cards on the workflow run-detail page, under the
+   * `ActivitySidebar`. Use for run-context biome surfaces (extracted
+   * entity refs, diff stats, biome-side telemetry). The current
+   * `runId` is readable from `bridge.navigation.useLocation()`.
+   */
+  RunDetailSidePanel: 'run-detail-side-panel',
+
+  // ── Interactive sessions ───────────────────────────────────────────
+  /**
+   * Action chips in the session detail page, alongside session controls.
+   * Use for biome shortcuts that are meaningful inside a session
+   * (open repo, open catalog entity, post to Slack, …).
+   */
+  SessionActions: 'session-actions',
+
+  /**
+   * Side-panel cards on the session detail page. Use for biome-driven
+   * context (related catalog entities, recent commits, …).
+   */
+  SessionSidePanel: 'session-side-panel',
+
+  /**
+   * Right-pane header strip in the session workspace (sessions +
+   * design-system-builder sessions). Sits to the LEFT of the host's hardcoded
+   * KB · Attachments · More · ActionsMenu icons. Use for compact
+   * icon-button actions tied to the preview surface — e.g.
+   * software-dev-web's Git commit/push/PR icons, a Slack "share
+   * preview" button, a catalog "open entity" link.
+   */
+  SessionRightHeader: 'session-right-header',
+
+  // ── Settings ───────────────────────────────────────────────────────
+  /**
+   * Tabs on the project Settings page. Each biome that contributes a
+   * panel here is rendered as a tab section under "Biomes". Use for
+   * per-project biome configuration (catalog instance URL +
+   * credentials ref, Slack channel mapping, …).
+   */
+  SettingsTabs: 'settings-tabs',
+} as const;
+
+/**
+ * Union of every host-defined slot id. Biome authors can use this in
+ * their `panels[].slot` field for compile-time spell-checking — but
+ * the runtime accepts any string, so biome-owned slots (`<biome-id>/x`)
+ * stay valid without modifying this catalog.
+ */
+export type HostExtensionSlot =
+  (typeof HostExtensionSlots)[keyof typeof HostExtensionSlots];