@dxos/plugin-assistant 0.8.4-main.ae835ea → 0.8.4-main.bc2380dfbc

package/src/containers/TracePanel/span-tree.test.ts

@@ -0,0 +1,166 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { AgentRequestBegin, AgentRequestEnd } from '@dxos/assistant';
+import { Trace } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
+
+import { ROOT_SPAN_ID, buildSpanTree, flattenSpanTree } from './span-tree';
+
+const makeMessage = (
+  meta: Trace.Meta,
+  events: Array<{ type: string; timestamp: number; data?: unknown }>,
+  isEphemeral = false,
+): Trace.Message =>
+  Obj.make(Trace.Message, {
+    meta,
+    isEphemeral,
+    events: events.map((event) => ({
+      type: event.type,
+      timestamp: event.timestamp,
+      data: event.data ?? {},
+    })),
+  });
+
+const opStart = (key: string, name?: string) => ({
+  type: Trace.OperationStart.key,
+  data: { key, name },
+});
+const opEnd = (key: string, name?: string, outcome: 'success' | 'failure' = 'success') => ({
+  type: Trace.OperationEnd.key,
+  data: { key, name, outcome },
+});
+const agentBegin = () => ({ type: AgentRequestBegin.key, data: {} });
+const agentEnd = () => ({ type: AgentRequestEnd.key, data: {} });
+
+describe('buildSpanTree', () => {
+  test('returns a root span for empty input', ({ expect }) => {
+    const tree = buildSpanTree([]);
+    expect(tree.id).toBe(ROOT_SPAN_ID);
+    expect(tree.children).toEqual([]);
+    expect(tree.events).toEqual([]);
+  });
+
+  test('events without pid attach to root span', ({ expect }) => {
+    const tree = buildSpanTree([makeMessage({}, [{ type: 'foo', timestamp: 1 }])]);
+    expect(tree.children).toEqual([]);
+    expect(tree.events).toHaveLength(1);
+    expect(tree.events[0].type).toBe('foo');
+  });
+
+  test('a single operation start/end pair produces one span under root', ({ expect }) => {
+    const tree = buildSpanTree([
+      makeMessage({ pid: 'op-1' }, [{ ...opStart('reply', 'Reply'), timestamp: 1 }]),
+      makeMessage({ pid: 'op-1' }, [{ ...opEnd('reply', 'Reply'), timestamp: 2 }]),
+    ]);
+    expect(tree.children).toHaveLength(1);
+    expect(tree.children[0].meta.pid).toBe('op-1');
+    expect(tree.children[0].events).toHaveLength(2);
+    expect(tree.children[0].children).toEqual([]);
+  });
+
+  test('a nested operation attaches to its open parent', ({ expect }) => {
+    const tree = buildSpanTree([
+      makeMessage({ pid: 'agent-1' }, [{ ...agentBegin(), timestamp: 1 }]),
+      makeMessage({ pid: 'op-1', parentPid: 'agent-1' }, [{ ...opStart('lookup', 'Lookup'), timestamp: 2 }]),
+      makeMessage({ pid: 'op-1', parentPid: 'agent-1' }, [{ ...opEnd('lookup', 'Lookup'), timestamp: 3 }]),
+      makeMessage({ pid: 'agent-1' }, [{ ...agentEnd(), timestamp: 4 }]),
+    ]);
+    expect(tree.children).toHaveLength(1);
+    const agentSpan = tree.children[0];
+    expect(agentSpan.meta.pid).toBe('agent-1');
+    expect(agentSpan.children).toHaveLength(1);
+    expect(agentSpan.children[0].meta.pid).toBe('op-1');
+    expect(agentSpan.children[0].events).toHaveLength(2);
+  });
+
+  test('sequential agent requests in one process become sibling spans', ({ expect }) => {
+    const tree = buildSpanTree([
+      makeMessage({ pid: 'agent-1' }, [{ ...agentBegin(), timestamp: 1 }]),
+      makeMessage({ pid: 'agent-1' }, [{ ...agentEnd(), timestamp: 2 }]),
+      makeMessage({ pid: 'agent-1' }, [{ ...agentBegin(), timestamp: 3 }]),
+      makeMessage({ pid: 'agent-1' }, [{ ...agentEnd(), timestamp: 4 }]),
+    ]);
+    expect(tree.children).toHaveLength(2);
+    expect(tree.children.every((child) => child.meta.pid === 'agent-1')).toBe(true);
+    // Span ids are distinct even though pids are shared.
+    expect(tree.children[0].id).not.toBe(tree.children[1].id);
+  });
+
+  test('non-boundary events attach to the currently-open span', ({ expect }) => {
+    const tree = buildSpanTree([
+      makeMessage({ pid: 'agent-1' }, [{ ...agentBegin(), timestamp: 1 }]),
+      makeMessage({ pid: 'agent-1' }, [{ type: 'note', timestamp: 2 }]),
+      makeMessage({ pid: 'agent-1' }, [{ ...agentEnd(), timestamp: 3 }]),
+    ]);
+    expect(tree.children[0].events).toHaveLength(3);
+    expect(tree.children[0].events.map((event) => event.type)).toEqual([
+      AgentRequestBegin.key,
+      'note',
+      AgentRequestEnd.key,
+    ]);
+  });
+
+  test('non-boundary event without an open span lands on root', ({ expect }) => {
+    const tree = buildSpanTree([makeMessage({ pid: 'orphan-pid' }, [{ type: 'note', timestamp: 1 }])]);
+    expect(tree.children).toEqual([]);
+    expect(tree.events).toHaveLength(1);
+    expect(tree.events[0].type).toBe('note');
+  });
+
+  test('end event without a matching begin attaches to root', ({ expect }) => {
+    const tree = buildSpanTree([makeMessage({ pid: 'op-1' }, [{ ...opEnd('reply', 'Reply'), timestamp: 1 }])]);
+    expect(tree.children).toEqual([]);
+    expect(tree.events).toHaveLength(1);
+  });
+
+  test('sorts sibling spans chronologically by their first event', ({ expect }) => {
+    const tree = buildSpanTree([
+      makeMessage({ pid: 'op-late' }, [
+        { ...opStart('b'), timestamp: 10 },
+        { ...opEnd('b'), timestamp: 11 },
+      ]),
+      makeMessage({ pid: 'op-early' }, [
+        { ...opStart('a'), timestamp: 1 },
+        { ...opEnd('a'), timestamp: 2 },
+      ]),
+    ]);
+    expect(tree.children.map((child) => child.meta.pid)).toEqual(['op-early', 'op-late']);
+  });
+
+  test('respects eventLimit by dropping oldest events', ({ expect }) => {
+    const tree = buildSpanTree(
+      [
+        makeMessage({ pid: 'op-old' }, [
+          { ...opStart('a'), timestamp: 1 },
+          { ...opEnd('a'), timestamp: 2 },
+        ]),
+        makeMessage({ pid: 'op-new' }, [
+          { ...opStart('b'), timestamp: 3 },
+          { ...opEnd('b'), timestamp: 4 },
+        ]),
+      ],
+      { eventLimit: 2 },
+    );
+    expect(tree.children.map((child) => child.meta.pid)).toEqual(['op-new']);
+  });
+
+  test('flattenSpanTree returns root + all descendants in depth-first order', ({ expect }) => {
+    const tree = buildSpanTree([
+      makeMessage({ pid: 'agent-1' }, [{ ...agentBegin(), timestamp: 1 }]),
+      makeMessage({ pid: 'op-1', parentPid: 'agent-1' }, [
+        { ...opStart('a'), timestamp: 2 },
+        { ...opEnd('a'), timestamp: 3 },
+      ]),
+      makeMessage({ pid: 'agent-1' }, [{ ...agentEnd(), timestamp: 4 }]),
+    ]);
+    const order = flattenSpanTree(tree);
+    expect(order[0].id).toBe(ROOT_SPAN_ID);
+    expect(order[1].meta.pid).toBe('agent-1');
+    expect(order[2].meta.pid).toBe('op-1');
+    expect(order).toHaveLength(3);
+  });
+});

package/src/containers/TracePanel/span-tree.ts

@@ -0,0 +1,214 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { AgentRequestBegin, AgentRequestEnd } from '@dxos/assistant';
+import { Trace } from '@dxos/compute';
+
+/**
+ * Synthetic id assigned to the root span.
+ * The root is a virtual container for top-level spans (those without a parent in the captured trace).
+ */
+export const ROOT_SPAN_ID = '<main>';
+
+/**
+ * Computed metadata for a span.
+ * Derived from the meta of the begin event that opened the span.
+ */
+export interface SpanMeta {
+  readonly pid?: string;
+  readonly parentPid?: string;
+  readonly processName?: string;
+  readonly conversationId?: string;
+  readonly triggerId?: string;
+  readonly toolCallId?: string;
+  readonly runtimeName?: string;
+}
+
+/**
+ * A span in the trace hierarchy.
+ *
+ * Each span represents a single bounded unit of work — an operation invocation or an
+ * agent request. Spans are opened by `OperationStart` / `AgentRequestBegin` events and
+ * closed by their matching `OperationEnd` / `AgentRequestEnd` events. A single process
+ * (pid) may produce multiple sequential spans (for example, an agent session that serves
+ * three prompts produces three sibling spans sharing the agent's pid).
+ *
+ * `events` contains the bounded events for this span only — child spans' events are not
+ * duplicated here. `children` contains sub-spans that opened while this span was active.
+ */
+export interface Span {
+  readonly id: string;
+  readonly meta: SpanMeta;
+  readonly events: Trace.FlatEvent[];
+  readonly children: Span[];
+}
+
+export const BEGIN_EVENT_TYPES = new Set<string>([Trace.OperationStart.key, AgentRequestBegin.key]);
+export const END_EVENT_TYPES = new Set<string>([Trace.OperationEnd.key, AgentRequestEnd.key]);
+
+export const isSpanBeginEvent = (event: Trace.FlatEvent): boolean => BEGIN_EVENT_TYPES.has(event.type);
+export const isSpanEndEvent = (event: Trace.FlatEvent): boolean => END_EVENT_TYPES.has(event.type);
+
+const computeMeta = (rawMeta: Trace.Meta): SpanMeta => ({
+  pid: rawMeta.pid,
+  parentPid: rawMeta.parentPid,
+  processName: rawMeta.processName,
+  conversationId: rawMeta.conversationId,
+  triggerId: rawMeta.triggerId,
+  toolCallId: rawMeta.toolCallId,
+  runtimeName: rawMeta.runtimeName,
+});
+
+interface MutableSpan {
+  id: string;
+  meta: SpanMeta;
+  events: Trace.FlatEvent[];
+  children: MutableSpan[];
+  firstTimestamp: number;
+}
+
+const makeMutableSpan = (id: string, meta: SpanMeta): MutableSpan => ({
+  id,
+  meta,
+  events: [],
+  children: [],
+  firstTimestamp: Number.POSITIVE_INFINITY,
+});
+
+const freezeSpan = (span: MutableSpan): Span => ({
+  id: span.id,
+  meta: span.meta,
+  events: span.events,
+  children: span.children.map(freezeSpan),
+});
+
+export interface BuildSpanTreeOptions {
+  /**
+   * If provided, only the last `eventLimit` flat events (after flattening and chronological sort)
+   * are placed into the tree. Spans with no remaining events are dropped from the result.
+   */
+  eventLimit?: number;
+}
+
+/**
+ * Builds a hierarchical span tree from a list of trace messages.
+ *
+ * Algorithm:
+ *   1. Flatten messages into events and sort them chronologically.
+ *   2. For each event:
+ *      - Begin events (`OperationStart`, `AgentRequestBegin`) open a new span whose parent
+ *        is the currently-open span of the event's `meta.parentPid`, or the root if there is
+ *        none. The begin event itself becomes the first event of the new span.
+ *      - End events (`OperationEnd`, `AgentRequestEnd`) close the currently-open span for
+ *        the event's `meta.pid` and become its last event.
+ *      - Other events attach to the currently-open span for their `meta.pid`, or to the
+ *        root span if no span is currently open for that pid (or the event has no pid).
+ *   3. Sort each span's children by their earliest event timestamp.
+ */
+export const buildSpanTree = (messages: Trace.Message[], options: BuildSpanTreeOptions = {}): Span => {
+  const allEvents = messages.flatMap((message) => Trace.flatten(message));
+  allEvents.sort((a, b) => a.timestamp - b.timestamp);
+
+  const events =
+    options.eventLimit !== undefined && allEvents.length > options.eventLimit
+      ? allEvents.slice(-options.eventLimit)
+      : allEvents;
+
+  const root = makeMutableSpan(ROOT_SPAN_ID, {});
+
+  // Currently-open span for each pid.
+  // A process may host multiple sequential spans (e.g. successive agent requests), so we
+  // track the active one and start a new span on the next begin event.
+  const openSpans = new Map<string, MutableSpan>();
+
+  let spanCounter = 0;
+  const allocSpanId = (pid: string): string => {
+    const id = `${pid}#${spanCounter}`;
+    spanCounter += 1;
+    return id;
+  };
+
+  const noteTimestamp = (span: MutableSpan, timestamp: number): void => {
+    if (timestamp < span.firstTimestamp) {
+      span.firstTimestamp = timestamp;
+    }
+  };
+
+  for (const event of events) {
+    const pid = event.meta.pid;
+
+    if (!pid) {
+      // Events without a pid attach to the root.
+      root.events.push(event);
+      noteTimestamp(root, event.timestamp);
+      continue;
+    }
+
+    if (BEGIN_EVENT_TYPES.has(event.type)) {
+      const parentPid = event.meta.parentPid;
+      const parent = (parentPid && openSpans.get(parentPid)) || root;
+      const span = makeMutableSpan(allocSpanId(pid), computeMeta(event.meta));
+      span.events.push(event);
+      noteTimestamp(span, event.timestamp);
+      parent.children.push(span);
+      // The new span supersedes any previously-open span for this pid.
+      openSpans.set(pid, span);
+      continue;
+    }
+
+    if (END_EVENT_TYPES.has(event.type)) {
+      const span = openSpans.get(pid);
+      if (span) {
+        span.events.push(event);
+        noteTimestamp(span, event.timestamp);
+        openSpans.delete(pid);
+      } else {
+        // End event without a matching begin — attach to root so the event isn't lost.
+        root.events.push(event);
+        noteTimestamp(root, event.timestamp);
+      }
+      continue;
+    }
+
+    // Non-boundary event: attach to the currently-open span for this pid if any.
+    const open = openSpans.get(pid);
+    if (open) {
+      open.events.push(event);
+      noteTimestamp(open, event.timestamp);
+    } else {
+      root.events.push(event);
+      noteTimestamp(root, event.timestamp);
+    }
+  }
+
+  // Sort children chronologically for deterministic output.
+  const sortChildren = (span: MutableSpan): void => {
+    span.children.sort((a, b) => a.firstTimestamp - b.firstTimestamp);
+    for (const child of span.children) {
+      sortChildren(child);
+    }
+  };
+  sortChildren(root);
+
+  return freezeSpan(root);
+};
+
+/**
+ * Walks the span tree in depth-first pre-order, invoking `visit` for each span (root included).
+ */
+export const walkSpanTree = (root: Span, visit: (span: Span, depth: number) => void, depth = 0): void => {
+  visit(root, depth);
+  for (const child of root.children) {
+    walkSpanTree(child, visit, depth + 1);
+  }
+};
+
+/**
+ * Returns all spans in the tree in depth-first pre-order, root first.
+ */
+export const flattenSpanTree = (root: Span): Span[] => {
+  const result: Span[] = [];
+  walkSpanTree(root, (span) => result.push(span));
+  return result;
+};

package/src/containers/TracePanel/testing/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './simulated-agent';
+export * from './snapshot-playback';

package/src/containers/TracePanel/testing/simulated-agent.ts

@@ -0,0 +1,114 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { AgentRequestBegin, AgentRequestEnd, CompleteBlock } from '@dxos/assistant';
+import { Process, Trace } from '@dxos/compute';
+import { ObjectId } from '@dxos/keys';
+
+export interface AgentScenario {
+  readonly prompt: string;
+  readonly tools: readonly string[];
+}
+
+/** Probability that any given run aborts with a simulated tool failure. */
+const FAILURE_PROBABILITY = 0.1;
+
+export const agentScenarios: readonly AgentScenario[] = [
+  {
+    prompt: 'Create an organization called "Cyberdyne Systems"',
+    tools: ['list-schemas', 'create-object'],
+  },
+  {
+    prompt: 'Search for all organizations and persons',
+    tools: ['list-schemas', 'query', 'query'],
+  },
+  {
+    prompt: 'Create a person named "John Connor"',
+    tools: ['create-object'],
+  },
+];
+
+const delay = (ms: number) => Effect.promise(() => new Promise<void>((resolve) => setTimeout(resolve, ms)));
+
+/**
+ * Write a trace event and yield to the event loop so FeedTraceSink flushes it to ECHO before continuing.
+ */
+const writeAndFlush = <T>(eventType: Trace.EventType<T>, payload: T) =>
+  Effect.gen(function* () {
+    yield* Trace.write(eventType, payload);
+    yield* Effect.promise(() => new Promise((resolve) => setTimeout(resolve, 100)));
+  });
+
+/**
+ * Storybook fixture: a {@link Process} that emits a deterministic stream of agent trace events
+ * (request begin/end, user message, sequential tool calls with simulated latency).
+ *
+ * Input is a scenario index into {@link agentScenarios} (modulo the array length).
+ */
+export const SimulatedAgent = Process.make(
+  {
+    key: 'org.dxos.testing.process.agent',
+    input: Schema.Number,
+    output: Schema.Void,
+    services: [Trace.TraceService],
+  },
+  (ctx) =>
+    Effect.succeed({
+      onInput: (index: number) =>
+        Effect.gen(function* () {
+          const messageId = ObjectId.random();
+          const scenario = agentScenarios[index % agentScenarios.length];
+
+          // Decide upfront whether this run will fail (and at which tool) so the trace shows a partial sequence.
+          const failAtToolIndex =
+            Math.random() < FAILURE_PROBABILITY ? Math.floor(Math.random() * scenario.tools.length) : -1;
+
+          // Agent begins processing.
+          yield* writeAndFlush(AgentRequestBegin, {});
+
+          // User message.
+          yield* writeAndFlush(CompleteBlock, {
+            messageId,
+            role: 'user',
+            block: { _tag: 'text', text: scenario.prompt },
+          });
+
+          // Simulate tool calls sequentially with delays.
+          for (const [index, toolName] of scenario.tools.entries()) {
+            const toolCallId = ObjectId.random();
+
+            // Tool call event.
+            yield* writeAndFlush(CompleteBlock, {
+              messageId,
+              role: 'assistant',
+              block: { _tag: 'toolCall', toolCallId, name: toolName, input: '{}', providerExecuted: false },
+            });
+
+            // Simulate tool execution time.
+            yield* delay(1_000 + Math.random() * 3_000);
+
+            if (index === failAtToolIndex) {
+              ctx.fail(new Error(`Simulated failure in tool '${toolName}'`));
+              return;
+            }
+
+            // Tool result event.
+            yield* writeAndFlush(CompleteBlock, {
+              messageId,
+              role: 'assistant',
+              block: { _tag: 'toolResult', toolCallId, name: toolName, providerExecuted: false },
+            });
+          }
+
+          // Agent completes.
+          yield* writeAndFlush(AgentRequestEnd, {});
+          ctx.succeed();
+        }).pipe(Effect.orDie),
+      onAlarm: () => Effect.void,
+      onChildEvent: () => Effect.void,
+    }),
+);

package/src/containers/TracePanel/testing/snapshot-playback.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Dispatch, type SetStateAction, useEffect, useRef, useState } from 'react';
+
+/**
+ * Interval (ms) between auto-played trace messages in the snapshot playback story.
+ */
+export const PLAYBACK_INTERVAL_MS = 250;
+
+export const STEP_STORAGE_KEY = 'plugin-assistant.trace-panel.snapshot.step';
+
+/**
+ * `useState<number>` that hydrates from and persists to `localStorage`.
+ * The third tuple member is `true` iff a valid value was loaded on first render.
+ */
+export const useLocalStorageNumber = (
+  key: string,
+  initial: number,
+): [number, Dispatch<SetStateAction<number>>, boolean] => {
+  const initRef = useRef<{ value: number; hydrated: boolean } | null>(null);
+  if (initRef.current === null) {
+    let value = initial;
+    let hydrated = false;
+    if (typeof window !== 'undefined') {
+      const stored = window.localStorage.getItem(key);
+      const parsed = stored === null ? Number.NaN : Number(stored);
+      if (Number.isInteger(parsed) && parsed >= 0) {
+        value = parsed;
+        hydrated = true;
+      }
+    }
+    initRef.current = { value, hydrated };
+  }
+
+  const [value, setValue] = useState(initRef.current.value);
+  useEffect(() => {
+    if (typeof window !== 'undefined') {
+      window.localStorage.setItem(key, String(value));
+    }
+  }, [key, value]);
+
+  return [value, setValue, initRef.current.hydrated];
+};

package/src/containers/TriggerStatus/TriggerStatus.tsx

@@ -0,0 +1,129 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useMemo } from 'react';
+
+import { AppSurface } from '@dxos/app-toolkit/ui';
+import { type InvocationsState } from '@dxos/functions-runtime';
+import { useTriggerRuntimeControls } from '@dxos/plugin-automation/hooks';
+import { StatusBar } from '@dxos/plugin-status-bar/components';
+import { useObject } from '@dxos/react-client/echo';
+import { IconButton, Popover, useTranslation } from '@dxos/react-ui';
+
+import { meta } from '#meta';
+
+type TriggerStatusState = 'disabled' | 'idle' | 'running' | 'edge' | 'error';
+
+const getIcon = (state: TriggerStatusState): string => {
+  switch (state) {
+    case 'disabled':
+      return 'ph--lightning-slash--regular';
+    case 'idle':
+      return 'ph--lightning--regular';
+    case 'edge':
+      return 'ph--lightning--regular';
+    case 'running':
+      return 'ph--lightning--fill';
+    case 'error':
+      return 'ph--warning--regular';
+  }
+};
+
+const getIconClassNames = (state: TriggerStatusState): string | undefined => {
+  switch (state) {
+    case 'running':
+      return 'animate-pulse text-accent-text';
+    case 'error':
+      return 'text-error-text';
+    default:
+      return undefined;
+  }
+};
+
+export type SpaceStatusProps = AppSurface.SpaceArticleProps;
+
+export const SpaceStatus = ({ space }: SpaceStatusProps) => {
+  const { t } = useTranslation(meta.id);
+  const { state } = useTriggerRuntimeControls(space.db);
+  const isEnabled = state?.enabled ?? false;
+  const [properties] = useObject(space.properties);
+  const computeEnvironment = properties.computeEnvironment ?? 'local';
+
+  // Determine the current trigger status state.
+  const triggerState: TriggerStatusState = useMemo(() => {
+    if (computeEnvironment === 'edge') {
+      return 'edge';
+    }
+
+    if (!isEnabled) {
+      return 'disabled';
+    }
+
+    // Check if there's any pending invocation.
+    const hasPending = state?.invocations.some((invocation) => invocation.result === null);
+    if (hasPending) {
+      return 'running';
+    }
+
+    // Check if the last invocation failed.
+    const lastInvocation = state?.invocations.at(-1);
+    if (lastInvocation?.result?._tag === 'Failure') {
+      return 'error';
+    }
+
+    return 'idle';
+  }, [computeEnvironment, isEnabled, state?.invocations]);
+
+  return (
+    <Popover.Root>
+      <Popover.Trigger asChild>
+        <StatusBar.Item>
+          <IconButton
+            icon={getIcon(triggerState)}
+            iconOnly
+            label={t(`trigger-status-${triggerState}.label`)}
+            classNames={getIconClassNames(triggerState)}
+          />
+        </StatusBar.Item>
+      </Popover.Trigger>
+      <Popover.Portal>
+        <Popover.Content side='left'>
+          <TriggerStatusPopover
+            state={triggerState}
+            currentFunctionName={
+              state?.invocations.at(-1)?.function?.meta.name ?? state?.invocations.at(-1)?.function?.meta.key
+            }
+            lastInvocation={state?.invocations.at(-1)}
+          />
+          <Popover.Arrow />
+        </Popover.Content>
+      </Popover.Portal>
+    </Popover.Root>
+  );
+};
+
+type TriggerStatusPopoverProps = {
+  state: TriggerStatusState;
+  currentFunctionName?: string;
+  lastInvocation?: InvocationsState;
+};
+
+const TriggerStatusPopover = ({
+  state,
+  currentFunctionName,
+  lastInvocation, // TODO(burdon): Show.
+}: TriggerStatusPopoverProps) => {
+  const { t } = useTranslation(meta.id);
+
+  return (
+    <div className='flex flex-col gap-2 p-2 w-[240px]'>
+      <div className='flex flex-col gap-1'>
+        <div className='text-sm'>{t(`trigger-status-${state}.label`)}</div>
+        {currentFunctionName && state === 'running' && (
+          <div className='text-xs text-description'>{currentFunctionName}</div>
+        )}
+      </div>
+    </div>
+  );
+};

package/src/containers/TriggerStatus/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { SpaceStatus, SpaceStatus as default } from './TriggerStatus';