@dxos/plugin-assistant 0.8.4-main.422d1c7879 → 0.8.4-main.4668b7de9b

package/src/containers/TracePanel/TracePanel.tsx

@@ -4,110 +4,210 @@
 
 import { Atom } from '@effect-atom/atom';
 import { useAtomValue } from '@effect-atom/atom-react';
+import * as Data from 'effect/Data';
+import * as Duration from 'effect/Duration';
 import { pipe } from 'effect/Function';
-import React, { useCallback, useMemo } from 'react';
+import React, { useCallback, useDeferredValue, useMemo, useState } from 'react';
 
-import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { Capabilities } from '@dxos/app-framework';
+import { useCapability, useAtomCapability, useOperationInvoker } from '@dxos/app-framework/ui';
 import { LayoutOperation } from '@dxos/app-toolkit';
 import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Process, Trace } from '@dxos/compute';
 import { Filter, Query } from '@dxos/echo';
 import { AtomQuery } from '@dxos/echo-atom';
-import { Trace } from '@dxos/functions';
-import { FeedTraceSink, Process } from '@dxos/functions-runtime';
-import { DXN } from '@dxos/keys';
-import { useComputeRuntimeService } from '@dxos/plugin-automation/hooks';
+import { FeedTraceSink } from '@dxos/functions-runtime';
+import { EID } from '@dxos/keys';
 import { type Space } from '@dxos/react-client/echo';
-import { Panel } from '@dxos/react-ui';
+import { ScrollContainer } from '@dxos/react-ui';
+import { composable, composableProps } from '@dxos/react-ui';
+import { useAttentionAttributes } from '@dxos/react-ui-attention';
 import { Timeline, type Commit } from '@dxos/react-ui-components';
-import { composable, mx } from '@dxos/ui-theme';
-
-import { ProcessTree } from '../../components';
-import { buildExecutionGraph } from './execution-graph';
-
-export type TracePanelProps = AppSurface.SpaceArticleProps;
-
-export const TracePanel = composable<HTMLDivElement, TracePanelProps>(({ space, ...props }, forwardedRef) => {
-  const { invokePromise } = useOperationInvoker();
-  const { branches, commits } = useExecutionGraph(space);
-
-  const handleCommitClick = useCallback(
-    (commit: Commit) => {
-      if (commit.link) {
-        const dxn = DXN.tryParse(commit.link)?.asEchoDXN();
-        if (dxn?.spaceId && dxn.echoId) {
-          // TODO(dmaretskyi): Navigates, but fails to open.
-          void invokePromise(LayoutOperation.Open, {
-            subject: [`${dxn.spaceId}:${dxn.echoId}`],
-          });
+import { Syntax } from '@dxos/react-ui-syntax-highlighter';
+import { mx } from '@dxos/ui-theme';
+
+import { ProcessTree, ProcessTreeProps } from '#components';
+import { buildExecutionGraph, type ExecutionGraph } from '#execution-graph';
+import { AssistantCapabilities } from '#types';
+
+export type TracePanelProps = AppSurface.SpaceArticleProps<Pick<ProcessTreeProps, 'onProcessTerminate'>>;
+
+export const TracePanel = composable<HTMLDivElement, TracePanelProps>(
+  ({ space, attendableId, onProcessTerminate, ...props }, forwardedRef) => {
+    const attentionAttrs = useAttentionAttributes(attendableId);
+    const { invokePromise } = useOperationInvoker();
+    const settings = useAtomCapability(AssistantCapabilities.Settings);
+    const tracePanelDebug = settings.tracePanelDebug ?? false;
+
+    // `useDeferredValue` batches update bursts, works together with `React.memo`.
+    // See the comment in `ProcessTreeContainer` for more details.
+    const { branches, commits, spanTree, details } = useDeferredValue(useExecutionGraph(space));
+
+    const [selectedCommit, setSelectedCommit] = useState<Commit | undefined>();
+    const handleCommitSelect = useCallback(
+      (commit: Commit | undefined) => {
+        setSelectedCommit(commit);
+        if (commit?.link) {
+          const echoUri = EID.tryParse(commit.link);
+          const spaceId = echoUri ? EID.getSpaceId(echoUri) : undefined;
+          const objectId = echoUri ? EID.getEntityId(echoUri) : undefined;
+          if (spaceId && objectId) {
+            // TODO(dmaretskyi): Navigates, but fails to open.
+            void invokePromise(LayoutOperation.Open, {
+              subject: [`${spaceId}:${objectId}`],
+            });
+          }
         }
-      }
-    },
-    [invokePromise],
-  );
+      },
+      [invokePromise, setSelectedCommit],
+    );
 
-  return (
-    <Panel.Root {...props} ref={forwardedRef}>
-      <Panel.Content className='grid grid-rows-[min-content_1fr]'>
-        <ActiveProcessList spaceId={space.id} />
-        <Timeline branches={branches} commits={commits} compact onCommitClick={handleCommitClick} />
-      </Panel.Content>
-    </Panel.Root>
-  );
-});
-
-/**
- * Separated into its own component because useComputeRuntimeService uses React's use() which requires a Suspense boundary.
- */
-const ActiveProcessList = ({ spaceId }: { spaceId: Space['id'] }) => {
-  const runtime = useComputeRuntimeService(Process.ProcessMonitorService, spaceId);
-  const activeProcesses = useAtomValue(runtime?.processTreeAtom ?? atomEmpty);
-  if (activeProcesses.length === 0) {
-    return <div />;
-  }
-
-  return <ProcessTree classNames={mx('max-h-[8lh] px-2 border-b border-separator')} processes={activeProcesses} />;
-};
+    // Select current branch.
+    const [currentBranch, setCurrentBranch] = useState<string | null>(null);
+    const handleProcessSelect = useCallback(
+      (process: Process.Info) => {
+        const branch = branches.find((branch) => branch === process.pid.toString());
+        if (branch) {
+          setCurrentBranch(branch);
+        }
+      },
+      [branches],
+    );
+
+    return (
+      <div
+        {...composableProps(props, {
+          ...attentionAttrs,
+          classNames: mx(
+            'h-full grid divide-y divide-separator',
+            !tracePanelDebug && selectedCommit
+              ? 'grid-rows-[minmax(0,160px)_1fr_minmax(0,206px)]'
+              : 'grid-rows-[minmax(0,160px)_1fr]',
+          ),
+        })}
+        ref={forwardedRef}
+      >
+        <ProcessTreeContainer onProcessSelect={handleProcessSelect} onProcessTerminate={onProcessTerminate} />
+
+        <ScrollContainer.Root pin>
+          <ScrollContainer.Content thin>
+            <ScrollContainer.Fade />
+            <ScrollContainer.Viewport>
+              {tracePanelDebug ? (
+                <Syntax.Root data={spanTree}>
+                  <Syntax.Content>
+                    <Syntax.Viewport>
+                      <Syntax.Code className='text-xs' />
+                    </Syntax.Viewport>
+                  </Syntax.Content>
+                </Syntax.Root>
+              ) : (
+                <Timeline
+                  compact
+                  commits={commits}
+                  branches={branches}
+                  currentBranch={currentBranch}
+                  onSelect={handleCommitSelect}
+                />
+              )}
+            </ScrollContainer.Viewport>
+            <ScrollContainer.ScrollDownButton />
+          </ScrollContainer.Content>
+        </ScrollContainer.Root>
+
+        {!tracePanelDebug && selectedCommit && (
+          <Syntax.Root data={details[selectedCommit.id] ?? selectedCommit}>
+            <Syntax.Content>
+              <Syntax.Viewport>
+                <Syntax.Code className='text-xs' />
+              </Syntax.Viewport>
+            </Syntax.Content>
+          </Syntax.Root>
+        )}
+      </div>
+    );
+  },
+);
 
 // Stable ref.
 const atomEmpty = Atom.make(() => [] as const);
 
-type ExecutionGraph = {
-  branches: string[];
-  commits: Commit[];
-};
-
 type UseExecutionGraphOptions = {
   eventLimit?: number;
 };
 
 const useExecutionGraph = (space: Space, { eventLimit }: UseExecutionGraphOptions = {}): ExecutionGraph => {
-  const atom = useMemo(() => getExecutionGraph(space, { eventLimit }), [space, eventLimit]);
+  const monitor = useCapability(Capabilities.ProcessMonitor);
+  const processesAtom = monitor?.processTreeAtom ?? atomEmpty;
+
+  const atom = useMemo(
+    () => getExecutionGraph(space, processesAtom, { eventLimit }),
+    [space, processesAtom, eventLimit],
+  );
+
   return useAtomValue(atom);
 };
 
 const getExecutionGraph = (
   space: Space,
+  processesAtom: Atom.Atom<readonly Process.Info[]>,
   { eventLimit = 100 }: UseExecutionGraphOptions = {},
 ): Atom.Atom<ExecutionGraph> => {
-  return pipe(
+  const traceMessages = pipe(
     AtomQuery.make(space.db, FeedTraceSink.query),
-    Atom.map((feeds) => {
+    Atom.map((feeds) =>
       // TODO(dmaretskyi): This should be possible in a single query with properly working limit(1) and feed > feed contents traversal.
-      return AtomQuery.make(
+      AtomQuery.make(
         space.db,
         feeds.length > 0
           ? Query.type(Trace.Message).from(feeds[0])
           : (Query.select(Filter.nothing()) as Query.Query<never>),
-      );
-    }),
-    (_) => Atom.make((get) => get(get(_))),
-    (_) =>
-      Atom.make((get) =>
-        buildExecutionGraph({
-          traceMessages: [...get(_)],
-          activeProcesses: [],
-          eventLimit,
-        }),
       ),
+    ),
+    (atom) => Atom.make((get) => get(get(atom))),
+  );
+
+  const activeProcesses = pipe(
+    processesAtom,
+    Atom.debounce(Duration.millis(100)),
+    Atom.map((processes) =>
+      // `Data.array` does structural comparison on the array elements.
+      Data.array(
+        processes
+          .filter((process) => process.state === Process.State.RUNNING || process.state === Process.State.HYBERNATING)
+          .map(Data.struct),
+      ),
+    ),
+  );
+
+  return Atom.make((get) =>
+    buildExecutionGraph({
+      traceMessages: get(traceMessages),
+      activeProcesses: get(activeProcesses),
+      eventLimit,
+    }),
+  );
+};
+TracePanel.displayName = 'TracePanel';
+
+// Isolate `ProcessTree` updates from the rest of the panel.
+// TODO(dmaretskyi): Currently not useful since `useExecutionGraph` also pulls in the updates.
+const ProcessTreeContainer = ({
+  onProcessSelect,
+  onProcessTerminate,
+}: Pick<ProcessTreeProps, 'onProcessSelect' | 'onProcessTerminate'>) => {
+  const monitor = useCapability(Capabilities.ProcessMonitor);
+  const processes = useAtomValue(monitor?.processTreeAtom ?? atomEmpty);
+
+  // `processes` updates in bursts (about 14 updates per navigation).
+  // `useDeferredValue` will debounce update propagation, returning stale value for short periods.
+  // NOTE: `ProcessTree` MUST use `React.memo`, otherwise this will not work.
+  const processesDeferred = useDeferredValue(processes);
+  return (
+    <ProcessTree
+      processes={processesDeferred}
+      onProcessSelect={onProcessSelect}
+      onProcessTerminate={onProcessTerminate}
+    />
   );
 };

package/src/containers/TracePanel/dxn-extractor.test.ts

@@ -6,41 +6,41 @@ import { describe, test } from 'vitest';
 
 import {
   extractDxnsFromObject,
-  extractDxnsFromString,
+  extractDxnFromString,
   extractFirstDxnFromToolInput,
   extractFirstDxnFromToolResult,
 } from './dxn-extractor';
 
 describe('dxn-extractor', () => {
-  describe('extractDxnsFromString', () => {
+  describe('extractDxnFromString', () => {
     test('extracts plain DXN from string', ({ expect }) => {
-      const result = extractDxnsFromString('Found object dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
+      const result = extractDxnFromString('Found object dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
       expect(result).toHaveLength(1);
       expect(result[0].toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
     });
 
     test('extracts @dxn prefixed reference from string', ({ expect }) => {
-      const result = extractDxnsFromString('Reference to @dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4 in text');
+      const result = extractDxnFromString('Reference to @dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4 in text');
       expect(result).toHaveLength(1);
       expect(result[0].toString()).toBe('dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4');
     });
 
     test('extracts multiple DXNs from string', ({ expect }) => {
-      const result = extractDxnsFromString(
+      const result = extractDxnFromString(
         'Objects: dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4 and @dxn:queue:data:SPACE:QUEUE:01KG7R1ZXWFMWQ4DA1Q6TN1DG5',
       );
       expect(result).toHaveLength(2);
     });
 
     test('deduplicates DXNs', ({ expect }) => {
-      const result = extractDxnsFromString(
+      const result = extractDxnFromString(
         'Same object dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4 and dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4',
       );
       expect(result).toHaveLength(1);
     });
 
     test('returns empty array for string without DXNs', ({ expect }) => {
-      const result = extractDxnsFromString('No DXNs here');
+      const result = extractDxnFromString('No DXNs here');
       expect(result).toHaveLength(0);
     });
   });

package/src/containers/TracePanel/dxn-extractor.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { DXN } from '@dxos/keys';
+import { URI } from '@dxos/keys';
 
 /**
  * Patterns for extracting DXN references from tool call params/results.
@@ -28,8 +28,8 @@ const AT_DXN_PATTERN = /@(dxn:[a-zA-Z0-9]+(?::[a-zA-Z0-9@_-]+)+)/g;
 /**
  * Extracts all DXN references from a string.
  */
-export const extractDxnsFromString = (text: string): DXN[] => {
-  const dxns: DXN[] = [];
+export const extractDxnFromString = (text: string): URI.URI[] => {
+  const dxns: URI.URI[] = [];
   const seen = new Set<string>();
 
   // Match @dxn: prefixed references.
@@ -37,11 +37,8 @@ export const extractDxnsFromString = (text: string): DXN[] => {
   while ((match = AT_DXN_PATTERN.exec(text)) !== null) {
     const dxnStr = match[1];
     if (!seen.has(dxnStr)) {
-      const dxn = DXN.tryParse(dxnStr);
-      if (dxn) {
-        dxns.push(dxn);
-        seen.add(dxnStr);
-      }
+      dxns.push(URI.make(dxnStr));
+      seen.add(dxnStr);
     }
   }
 
@@ -49,11 +46,8 @@ export const extractDxnsFromString = (text: string): DXN[] => {
   while ((match = DXN_PATTERN.exec(text)) !== null) {
     const dxnStr = match[0];
     if (!seen.has(dxnStr)) {
-      const dxn = DXN.tryParse(dxnStr);
-      if (dxn) {
-        dxns.push(dxn);
-        seen.add(dxnStr);
-      }
+      dxns.push(URI.make(dxnStr));
+      seen.add(dxnStr);
     }
   }
 
@@ -64,17 +58,14 @@ export const extractDxnsFromString = (text: string): DXN[] => {
  * Extracts DXN references from a JSON object.
  * Handles IPLD-style references `{ "/": "dxn:..." }` and `{ "@dxn": "dxn:..." }`.
  */
-export const extractDxnsFromObject = (obj: unknown): DXN[] => {
-  const dxns: DXN[] = [];
+export const extractDxnsFromObject = (obj: unknown): URI.URI[] => {
+  const dxns: URI.URI[] = [];
   const seen = new Set<string>();
 
   const addDxn = (dxnStr: string) => {
     if (!seen.has(dxnStr)) {
-      const dxn = DXN.tryParse(dxnStr);
-      if (dxn) {
-        dxns.push(dxn);
-        seen.add(dxnStr);
-      }
+      dxns.push(URI.make(dxnStr));
+      seen.add(dxnStr);
     }
   };
 
@@ -91,9 +82,9 @@ export const extractDxnsFromObject = (obj: unknown): DXN[] => {
         addDxn(value.slice(1));
       }
       // Also extract DXNs from within the string.
-      const extracted = extractDxnsFromString(value);
+      const extracted = extractDxnFromString(value);
       for (const dxn of extracted) {
-        addDxn(dxn.toString());
+        addDxn(dxn);
       }
       return;
     }
@@ -116,19 +107,18 @@ export const extractDxnsFromObject = (obj: unknown): DXN[] => {
         }
       }
 
-      // Check for @dxn key: { "@dxn": "dxn:..." }
-      if ('@dxn' in record && typeof record['@dxn'] === 'string') {
-        const dxnStr = record['@dxn'];
-        if (typeof dxnStr === 'string' && dxnStr.startsWith('dxn:')) {
-          addDxn(dxnStr);
-        }
+      // Check for @uri key (new) or @dxn key (legacy): { "@uri": "echo://…" } / { "@dxn": "dxn:…" }
+      const selfUri = (record as any)['@uri'] ?? (record as any)['@dxn'];
+      if (typeof selfUri === 'string' && (selfUri.startsWith('dxn:') || selfUri.startsWith('echo:'))) {
+        addDxn(selfUri);
       }
 
-      // Check for reference blocks: { _tag: 'reference', reference: { dxn: ... } }
+      // Check for reference blocks: { _tag: 'reference', reference: { uri: ... } } (or legacy { dxn: ... })
       if (record._tag === 'reference' && record.reference && typeof record.reference === 'object') {
         const ref = record.reference as Record<string, unknown>;
-        if (ref.dxn && typeof ref.dxn === 'string') {
-          addDxn(ref.dxn);
+        const refUri = ref.uri ?? ref.dxn;
+        if (refUri && typeof refUri === 'string') {
+          addDxn(refUri);
         }
       }
 
@@ -146,14 +136,14 @@ export const extractDxnsFromObject = (obj: unknown): DXN[] => {
 /**
  * Extracts the first DXN from a tool call input string (JSON).
  */
-export const extractFirstDxnFromToolInput = (input: string): DXN | undefined => {
+export const extractFirstDxnFromToolInput = (input: string): URI.URI | undefined => {
   try {
     const parsed = JSON.parse(input);
     const dxns = extractDxnsFromObject(parsed);
     return dxns[0];
   } catch {
     // If JSON parsing fails, try to extract from the raw string.
-    const dxns = extractDxnsFromString(input);
+    const dxns = extractDxnFromString(input);
     return dxns[0];
   }
 };
@@ -161,7 +151,7 @@ export const extractFirstDxnFromToolInput = (input: string): DXN | undefined =>
 /**
  * Extracts the first DXN from a tool result string (JSON).
  */
-export const extractFirstDxnFromToolResult = (result: string | undefined): DXN | undefined => {
+export const extractFirstDxnFromToolResult = (result: string | undefined): URI.URI | undefined => {
   if (!result) {
     return undefined;
   }
@@ -172,7 +162,7 @@ export const extractFirstDxnFromToolResult = (result: string | undefined): DXN |
     return dxns[0];
   } catch {
     // If JSON parsing fails, try to extract from the raw string.
-    const dxns = extractDxnsFromString(result);
+    const dxns = extractDxnFromString(result);
     return dxns[0];
   }
 };

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 { EntityId } 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 = EntityId.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 = EntityId.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

@@ -7,7 +7,7 @@ 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';
+import { StatusBar } from '@dxos/plugin-status-bar/components';
 import { useObject } from '@dxos/react-client/echo';
 import { IconButton, Popover, useTranslation } from '@dxos/react-ui';
 
@@ -80,6 +80,7 @@ export const SpaceStatus = ({ space }: SpaceStatusProps) => {
       <Popover.Trigger asChild>
         <StatusBar.Item>
           <IconButton
+            variant='ghost'
             icon={getIcon(triggerState)}
             iconOnly
             label={t(`trigger-status-${triggerState}.label`)}