@xemahq/ui-kernel 0.9.2 → 0.11.0

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

@@ -3,12 +3,10 @@ import {
   type XemaObjectKind,
   type XemaObjectRef,
 } from '@xemahq/kernel-contracts/object';
+
 import { ActionRefKind } from './enums';
-import type {
-  IntentBus,
-  IntentRegistration,
-  ResolvedIntent,
-} from './intents';
+
+import type { IntentBus, IntentRegistration, ResolvedIntent } from './intents';
 
 const VALID_ACTION_KINDS: ReadonlySet<ActionRefKind> = new Set([
   ActionRefKind.Capability,
@@ -58,14 +56,18 @@ export class IntentRegistry implements IntentBus {
 
   unregister(biomeId: string): boolean {
     const removed = this.registrations.delete(biomeId);
-    if (removed) this.notify();
+    if (removed) {
+      this.notify();
+    }
     return removed;
   }
 
   resolve(kind: XemaObjectKind): readonly ResolvedIntent[] {
     const out: ResolvedIntent[] = [];
     for (const registration of this.registrations.values()) {
-      if (!registration.handles.includes(kind)) continue;
+      if (!registration.handles.includes(kind)) {
+        continue;
+      }
       for (const action of registration.provides) {
         out.push({ biomeId: registration.biomeId, action });
       }
@@ -100,6 +102,8 @@ export class IntentRegistry implements IntentBus {
   }
 
   private notify(): void {
-    for (const listener of this.listeners) listener();
+    for (const listener of this.listeners) {
+      listener();
+    }
   }
 }

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

@@ -1,6 +1,10 @@
+import { type ActionRefKind } from './enums';
+
 import type { CapabilityRef } from '@xemahq/kernel-contracts/capability';
-import type { XemaObjectKind, XemaObjectRef } from '@xemahq/kernel-contracts/object';
-import { ActionRefKind } from './enums';
+import type {
+  XemaObjectKind,
+  XemaObjectRef,
+} from '@xemahq/kernel-contracts/object';
 
 /**
  * Cross-biome intent registry — the "Open with… / Send to…" plane.

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

@@ -1,5 +1,6 @@
+import { type PaletteEntrySource } from './enums';
+
 import type { CapabilityRef } from '@xemahq/kernel-contracts/capability';
-import { PaletteEntrySource } from './enums';
 
 /**
  * Command-palette plane of the SystemBus.

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

@@ -1,9 +1,9 @@
-import { PaletteEntrySource } from './enums';
 import {
   parseDeeplink,
   type DeeplinkBus,
   type ParsedDeeplink,
 } from './deeplink';
+import { PaletteEntrySource } from './enums';
 import {
   type CapabilityInvoker,
   type DeeplinkResolver,
@@ -17,6 +17,7 @@ import {
   type PaletteEntry,
   type PaletteQuery,
 } from './palette';
+
 import type { SystemBus } from './system-bus';
 
 /**
@@ -121,7 +122,8 @@ function buildDeeplinkBus(resolver: DeeplinkResolver): DeeplinkBus {
     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;
+      const parsed =
+        typeof target === 'string' ? parseDeeplink(target) : target;
       await resolver.resolve(parsed);
     },
   };

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

@@ -1,4 +1,4 @@
-import { WindowArrangement, WindowOp } from './enums';
+import { type WindowArrangement, WindowOp } from './enums';
 
 /**
  * Window-management plane of the SystemBus.

package/src/offline/outbox.test.ts

@@ -80,7 +80,7 @@ describe('Outbox', () => {
     expect(send).toHaveBeenCalledTimes(1);
     const snap = outbox.getSnapshot();
     expect(snap.failedCount).toBe(1);
-    expect(snap.entries[0].status).toBe(OutboxEntryStatus.Failed);
+    expect(snap.entries[0]?.status).toBe(OutboxEntryStatus.Failed);
   });
 
   it('dead-letters after exhausting retries on persistent 5xx', async () => {
@@ -93,7 +93,9 @@ describe('Outbox', () => {
     await outbox.enqueue(KIND, { a: 1 });
     await outbox.drain();
     expect(calls).toBe(3);
-    expect(outbox.getSnapshot().entries[0].status).toBe(OutboxEntryStatus.Failed);
+    expect(outbox.getSnapshot().entries[0]?.status).toBe(
+      OutboxEntryStatus.Failed,
+    );
   });
 
   it('a network failure never advances the attempt counter or dead-letters', async () => {
@@ -114,6 +116,11 @@ describe('Outbox', () => {
     await outbox.enqueue(KIND, { a: 1 });
     await outbox.drain();
     const parked = outbox.getSnapshot().entries[0];
+    if (!parked) {
+      throw new Error(
+        'the offline entry was dropped from the outbox instead of parked',
+      );
+    }
     expect(parked.status).toBe(OutboxEntryStatus.Pending);
     expect(parked.attempts).toBe(0); // offline is not the payload's fault
     expect(outbox.getSnapshot().failedCount).toBe(0);
@@ -157,7 +164,9 @@ describe('Outbox', () => {
     online.reportOffline(); // keep it queued so we can observe the recovery
     const outbox = new Outbox({ storage, online, scheduler: (fn) => fn() });
     await outbox.start();
-    expect(outbox.getSnapshot().entries[0].status).toBe(OutboxEntryStatus.Pending);
+    expect(outbox.getSnapshot().entries[0]?.status).toBe(
+      OutboxEntryStatus.Pending,
+    );
     outbox.stop();
   });
 });

package/src/offline/outbox.ts

@@ -231,13 +231,17 @@ export class Outbox {
       do {
         this.drainRequested = false;
         await this.drainOnce();
-      } while (this.drainRequested && this.online.isOnline());
+      } while (this.shouldContinueDrain());
     } finally {
       this.draining = false;
       this.notify();
     }
   }
 
+  private shouldContinueDrain(): boolean {
+    return this.drainRequested && this.online.isOnline();
+  }
+
   // ── internals ──────────────────────────────────────────────────────────────
 
   private async hydrate(): Promise<void> {

package/src/offline/react-hooks.ts

@@ -1,6 +1,6 @@
 import { createContext, useContext, useSyncExternalStore } from 'react';
 
-import { Outbox } from './outbox';
+import { type Outbox } from './outbox';
 
 import type { OutboxSnapshot } from './types';
 
@@ -14,7 +14,10 @@ export function useOutbox(): Outbox {
   return ctx;
 }
 
-function resolveOutbox(explicit: Outbox | undefined, ctx: Outbox | null): Outbox {
+function resolveOutbox(
+  explicit: Outbox | undefined,
+  ctx: Outbox | null,
+): Outbox {
   const instance = explicit ?? ctx;
   if (!instance) {
     throw new Error('An <OutboxProvider> or an explicit outbox is required.');

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

@@ -10,12 +10,22 @@ export interface DbResultTableProps {
 }
 
 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') {
+  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();
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
   try {
     return JSON.stringify(value);
   } catch {
@@ -34,11 +44,14 @@ 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 header = columns
+      .map((column) => escapeCsvValue(column.name))
+      .join(',');
     const dataLines = rows.map((row) =>
       row
         .map((cell) => {
-          const printable = cell === null || cell === undefined ? '' : toDisplayValue(cell);
+          const printable =
+            cell === null || cell === undefined ? '' : toDisplayValue(cell);
           return escapeCsvValue(printable);
         })
         .join(','),
@@ -64,7 +77,9 @@ export function DbResultTable(props: DbResultTableProps) {
     <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>
+          <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>
@@ -73,13 +88,16 @@ export function DbResultTable(props: DbResultTableProps) {
 
       {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.
+          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`}
+          {rowCount === 0
+            ? 'No rows returned'
+            : `${displayedCount} row${displayedCount === 1 ? '' : 's'} shown`}
         </div>
         <button
           type="button"
@@ -91,14 +109,19 @@ export function DbResultTable(props: DbResultTableProps) {
       </div>
 
       {rowCount === 0 ? (
-        <div className="px-4 py-8 text-center text-sm text-muted-foreground">No rows returned</div>
+        <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">
+                  <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 ? (
@@ -113,15 +136,25 @@ export function DbResultTable(props: DbResultTableProps) {
             </thead>
             <tbody>
               {rows.map((row, rowIndex) => (
-                <tr key={`row-${rowIndex}`} className="border-b border-border/70 align-top">
+                <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">
+                      <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="italic text-muted-foreground">
+                            null
+                          </span>
                         ) : (
-                          <span className="break-all text-foreground">{toDisplayValue(cell)}</span>
+                          <span className="break-all text-foreground">
+                            {toDisplayValue(cell)}
+                          </span>
                         )}
                       </td>
                     );

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

@@ -8,14 +8,13 @@
  * calls after every enabled biome has registered.
  */
 
+import { HostExtensionSlots } from './extension-points';
 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>`

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

@@ -1,8 +1,7 @@
 import { Fragment, type ReactElement } from 'react';
 
-import { biomeRegistry, useBiomeRegistryRevision } from '../../index';
-
 import { useBiomesEnabled } from './biomes-enabled-context';
+import { biomeRegistry, useBiomeRegistryRevision } from '../../index';
 
 export interface BiomeSlotProps {
   /** Slot name biomes target via `PanelContribution.slot`. */
@@ -34,9 +33,13 @@ 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;
+  if (!enabled) {
+    return props.fallback ?? null;
+  }
   const panels = biomeRegistry.panelsForSlot(props.name);
-  if (panels.length === 0) return props.fallback ?? null;
+  if (panels.length === 0) {
+    return props.fallback ?? null;
+  }
   return (
     <Fragment>
       {panels.map((panel) => (

package/src/registry/lib/primitives/SessionEventCard.tsx

@@ -22,7 +22,12 @@
  */
 import { type CSSProperties, type ReactNode, type ReactElement } from 'react';
 
-export type SessionEventCardTone = 'default' | 'pending' | 'success' | 'error' | 'info';
+export type SessionEventCardTone =
+  | 'default'
+  | 'pending'
+  | 'success'
+  | 'error'
+  | 'info';
 
 const TONE_DOT: Record<SessionEventCardTone, string> = {
   default: 'hsl(var(--ink-4, 228 6% 58%))',
@@ -55,7 +60,9 @@ export interface SessionEventCardProps {
 
 function formatTime(iso: string): string {
   const date = new Date(iso);
-  if (Number.isNaN(date.getTime())) return '—';
+  if (Number.isNaN(date.getTime())) {
+    return '—';
+  }
   return date.toLocaleTimeString([], {
     hour: '2-digit',
     minute: '2-digit',
@@ -121,12 +128,29 @@ export function SessionEventCard({
         )}
       </div>
       <div style={{ minWidth: 0, flex: 1 }}>
-        <div style={{ display: 'flex', gap: 6, alignItems: 'baseline', flexWrap: 'wrap' }}>
-          <span style={{ color: 'hsl(var(--ink, 228 14% 11%))', wordBreak: 'break-word' }}>
+        <div
+          style={{
+            display: 'flex',
+            gap: 6,
+            alignItems: 'baseline',
+            flexWrap: 'wrap',
+          }}
+        >
+          <span
+            style={{
+              color: 'hsl(var(--ink, 228 14% 11%))',
+              wordBreak: 'break-word',
+            }}
+          >
             {title}
           </span>
           {detail !== null && detail !== undefined && (
-            <span style={{ color: 'hsl(var(--ink-3, 228 6% 40%))', wordBreak: 'break-word' }}>
+            <span
+              style={{
+                color: 'hsl(var(--ink-3, 228 6% 40%))',
+                wordBreak: 'break-word',
+              }}
+            >
               {detail}
             </span>
           )}

package/src/registry/lib/primitives/SessionEventTimeline.tsx

@@ -51,7 +51,9 @@ export function SessionEventTimeline<TItem>({
 
   useEffect(() => {
     const node = scrollRef.current;
-    if (!node) return;
+    if (!node) {
+      return;
+    }
     const handler = () => {
       const distanceFromBottom =
         node.scrollHeight - node.scrollTop - node.clientHeight;
@@ -62,9 +64,13 @@ export function SessionEventTimeline<TItem>({
   }, [stickThreshold]);
 
   useLayoutEffect(() => {
-    if (!stuckToBottom) return;
+    if (!stuckToBottom) {
+      return;
+    }
     const node = scrollRef.current;
-    if (!node) return;
+    if (!node) {
+      return;
+    }
     node.scrollTop = node.scrollHeight;
   }, [items, stuckToBottom]);
 

package/src/registry/lib/primitives/SessionTabbedDrawer.tsx

@@ -57,19 +57,29 @@ export function SessionTabbedDrawer({
 
   const select = useMemo(() => {
     return (id: string) => {
-      if (activeTabId === undefined) setInternalActive(id);
+      if (activeTabId === undefined) {
+        setInternalActive(id);
+      }
       onActiveTabChange?.(id);
     };
   }, [activeTabId, onActiveTabChange]);
 
   useEffect(() => {
-    if (!enableKeyboardShortcuts) return;
+    if (!enableKeyboardShortcuts) {
+      return;
+    }
     const handler = (event: KeyboardEvent) => {
-      if (!(event.metaKey || event.ctrlKey)) return;
+      if (!(event.metaKey || event.ctrlKey)) {
+        return;
+      }
       const idx = Number.parseInt(event.key, 10);
-      if (Number.isNaN(idx) || idx < 1 || idx > tabs.length) return;
+      if (Number.isNaN(idx) || idx < 1 || idx > tabs.length) {
+        return;
+      }
       const target = tabs[idx - 1];
-      if (!target) return;
+      if (!target) {
+        return;
+      }
       event.preventDefault();
       select(target.id);
     };

package/src/registry/lib/session-context-builder.ts

@@ -2,11 +2,9 @@
  * Single helper hook the host's session shell calls once per render to
  * build the `SessionContext` it passes into every contribution selector.
  *
- * Inputs are the loose, host-shaped session fields (any DTO with these
- * keys); the helper resolves the profile descriptor through the biome
- * registry, frozes a capabilities set, and returns a stable
- * `SessionContext`. Memoised by the underlying selectors — callers can
- * pass the result as a dep without worrying about identity churn.
+ * Inputs are the host's session fields plus the resolved Agent projection.
+ * The helper freezes capability refs and returns a stable `SessionContext`.
+ * It never fabricates a profile or capability fallback.
  *
  * Keeping this helper in the SDK (rather than the host) is what lets
  * biomes also build a context — e.g. from inside a slash command
@@ -14,17 +12,23 @@
  */
 import { useMemo } from 'react';
 
-import {
-  type SessionContext,
-  useSessionProfileDescriptor,
-} from '../../index';
+import type { SessionContext } from '../../index';
+
+export interface SessionResolvedAgentInput {
+  readonly ref: string;
+  readonly requiredCapabilities: readonly string[];
+  readonly mayEditRepositories: boolean;
+  readonly mayWriteKnowledgeBase: boolean;
+  readonly hasOutputSurface: boolean;
+}
 
 export interface BuildSessionContextInput {
   readonly sessionId: string;
   readonly orgId: string;
   readonly projectId: string;
   readonly biomeId?: string;
-  readonly profileKey?: string;
+  readonly repositoryId?: string;
+  readonly agent?: SessionResolvedAgentInput;
   readonly status: string;
   readonly isActive: boolean;
 }
@@ -41,17 +45,29 @@ export function isStatusActive(status: string): boolean {
   return !TERMINAL_STATUSES.has(status);
 }
 
-export function useSessionContext(input: BuildSessionContextInput): SessionContext {
-  const descriptor = useSessionProfileDescriptor(input.biomeId, input.profileKey);
+export function useSessionContext(
+  input: BuildSessionContextInput,
+): SessionContext {
   return useMemo<SessionContext>(
     () => ({
       sessionId: input.sessionId,
       orgId: input.orgId,
       projectId: input.projectId,
-      biomeId: input.biomeId ?? descriptor.biomeId,
-      profileKey: input.profileKey ?? descriptor.key,
+      ...(input.biomeId !== undefined ? { biomeId: input.biomeId } : {}),
+      ...(input.repositoryId !== undefined
+        ? { repositoryId: input.repositoryId }
+        : {}),
+      ...(input.agent !== undefined
+        ? {
+            agent: {
+              ...input.agent,
+              requiredCapabilities: Object.freeze(
+                new Set(input.agent.requiredCapabilities),
+              ),
+            },
+          }
+        : {}),
       status: input.status,
-      capabilities: Object.freeze(new Set(descriptor.capabilities)),
       isActive: input.isActive,
     }),
     [
@@ -59,10 +75,10 @@ export function useSessionContext(input: BuildSessionContextInput): SessionConte
       input.orgId,
       input.projectId,
       input.biomeId,
-      input.profileKey,
+      input.repositoryId,
+      input.agent,
       input.status,
       input.isActive,
-      descriptor,
     ],
   );
 }

package/src/registry/lib/session-context-provider.tsx

@@ -10,11 +10,11 @@
  * stable, importable hook — `import { useCurrentSessionContext } from
  * '@xemahq/ui-kernel/registry'`.
  */
-import type { ReactElement, ReactNode } from 'react';
 
 import { SessionContextValue } from './session-context';
 
 import type { SessionContext } from '../../index';
+import type { ReactElement, ReactNode } from 'react';
 
 export interface SessionContextProviderProps {
   readonly value: SessionContext;