@dxos/plugin-assistant 0.9.0 → 0.9.1-main.c7dcc2e112

package/src/containers/TracePanel/TracePanel.tsx

@@ -13,9 +13,7 @@ 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 { FeedTraceSink } from '@dxos/functions-runtime';
+import { Process } from '@dxos/compute';
 import { EID } from '@dxos/keys';
 import { type Space } from '@dxos/react-client/echo';
 import { ScrollContainer } from '@dxos/react-ui';
@@ -27,6 +25,7 @@ import { mx } from '@dxos/ui-theme';
 
 import { ProcessTree, ProcessTreeProps } from '#components';
 import { buildExecutionGraph, type ExecutionGraph } from '#execution-graph';
+import { useTraceMessages, getTraceMessagesAtom } from '#hooks';
 import { AssistantCapabilities } from '#types';
 
 export type TracePanelProps = AppSurface.SpaceArticleProps<Pick<ProcessTreeProps, 'onProcessTerminate'>>;
@@ -175,33 +174,6 @@ const useExecutionGraph = (space: Space, { eventLimit }: UseExecutionGraphOption
   return useAtomValue(atom);
 };
 
-/**
- * Atom of the raw trace messages for a space — the exact `Trace.Message[]` fed into
- * `buildExecutionGraph`. Shared by the execution graph and the debug trace export.
- */
-const getTraceMessagesAtom = (space: Space): Atom.Atom<readonly Trace.Message[]> =>
-  pipe(
-    space.db.query(FeedTraceSink.query).atom,
-    Atom.map(
-      (feeds) =>
-        // TODO(dmaretskyi): This should be possible in a single query with properly working limit(1) and feed > feed contents traversal.
-        space.db.query(
-          feeds.length > 0
-            ? Query.type(Trace.Message).from(feeds[0])
-            : (Query.select(Filter.nothing()) as Query.Query<never>),
-        ).atom,
-    ),
-    (atom) => Atom.make((get) => get(get(atom))),
-  );
-
-/**
- * Returns the raw trace messages for a space (used by the debug trace export).
- */
-const useTraceMessages = (space: Space): readonly Trace.Message[] => {
-  const atom = useMemo(() => getTraceMessagesAtom(space), [space]);
-  return useAtomValue(atom);
-};
-
 const getExecutionGraph = (
   space: Space,
   processesAtom: Atom.Atom<readonly Process.Info[]>,
@@ -250,6 +222,7 @@ const ProcessTreeContainer = ({
   return (
     <ProcessTree
       processes={processesDeferred}
+      depth={3}
       onProcessSelect={onProcessSelect}
       onProcessTerminate={onProcessTerminate}
     />

package/src/containers/TriggerStatus/TriggerStatus.tsx

@@ -44,7 +44,7 @@ const getIconClassNames = (state: TriggerStatusState): string | undefined => {
 export type SpaceStatusProps = AppSurface.SpaceArticleProps;
 
 export const SpaceStatus = ({ space }: SpaceStatusProps) => {
-  const { t } = useTranslation(meta.id);
+  const { t } = useTranslation(meta.profile.key);
   const { state } = useTriggerRuntimeControls(space.db);
   const isEnabled = state?.enabled ?? false;
   const [properties] = useObject(space.properties);
@@ -115,7 +115,7 @@ const TriggerStatusPopover = ({
   currentFunctionName,
   lastInvocation, // TODO(burdon): Show.
 }: TriggerStatusPopoverProps) => {
-  const { t } = useTranslation(meta.id);
+  const { t } = useTranslation(meta.profile.key);
 
   return (
     <div className='flex flex-col gap-2 p-2 w-[240px]'>

package/src/containers/index.ts

@@ -13,5 +13,7 @@ export const ChatDialog: ComponentType<any> = lazy(() => import('./ChatDialog'))
 export const PlanArticle: ComponentType<any> = lazy(() => import('./PlanArticle'));
 export const RoutineArticle: ComponentType<any> = lazy(() => import('./RoutineArticle'));
 export const RoutineList: ComponentType<any> = lazy(() => import('./RoutineList'));
+export const SpaceHomePrompt: ComponentType<any> = lazy(() => import('./SpaceHomePrompt'));
+export const SpaceHomeSuggestions: ComponentType<any> = lazy(() => import('./SpaceHomeSuggestions'));
 export const TracePanel: ComponentType<any> = lazy(() => import('./TracePanel'));
 export const TriggerStatus: ComponentType<any> = lazy(() => import('./TriggerStatus'));

package/src/execution-graph/execution-graph.ts

@@ -318,6 +318,136 @@ const presentEvent = (event: Trace.FlatEvent, toolCallContext: ToolCallContext):
   return undefined;
 };
 
+export type CollectProcessActivityOptions = {
+  /**
+   * When set, messages with a `conversationId` that disagrees are excluded.
+   * Messages without `conversationId` still match when their pid is in the subtree.
+   */
+  conversationId?: string;
+  eventLimit?: number;
+};
+
+/**
+ * Collects human-readable activity lines for a process subtree (root pid and descendants).
+ * Used to surface live sub-agent status in the task list.
+ */
+export const collectProcessActivityLines = (
+  messages: readonly Trace.Message[],
+  rootPid: string,
+  options: CollectProcessActivityOptions = {},
+): string[] => {
+  const { conversationId, eventLimit = 50 } = options;
+  const descendantPids = collectDescendantPids(messages, rootPid);
+  const filtered = messages.filter((message) => {
+    const pid = message.meta.pid;
+    if (!pid || !descendantPids.has(pid)) {
+      return false;
+    }
+    if (conversationId && message.meta.conversationId !== undefined && message.meta.conversationId !== conversationId) {
+      return false;
+    }
+    return true;
+  });
+
+  const events = filtered
+    .flatMap((message) => Trace.flatten(message))
+    .sort((left, right) => left.timestamp - right.timestamp)
+    .slice(-eventLimit);
+
+  const toolCallContext = buildToolCallContext(filtered);
+  const lines: string[] = [];
+  for (const event of events) {
+    const presentation = presentEvent(event, toolCallContext);
+    if (presentation) {
+      lines.push(presentation.message);
+    }
+  }
+  return lines;
+};
+
+/**
+ * Derives a single in-flight status line from durable trace when ephemeral subscription
+ * is unavailable (e.g. between partial blocks or while a child operation is running).
+ */
+export const deriveInFlightActivityLine = (
+  messages: readonly Trace.Message[],
+  rootPid: string,
+  options: CollectProcessActivityOptions = {},
+): string | undefined => {
+  const { conversationId, eventLimit = 50 } = options;
+  const descendantPids = collectDescendantPids(messages, rootPid);
+  const filtered = messages.filter((message) => {
+    const pid = message.meta.pid;
+    if (!pid || !descendantPids.has(pid)) {
+      return false;
+    }
+    if (conversationId && message.meta.conversationId !== undefined && message.meta.conversationId !== conversationId) {
+      return false;
+    }
+    return true;
+  });
+
+  const events = filtered
+    .flatMap((message) => Trace.flatten(message))
+    .sort((left, right) => left.timestamp - right.timestamp)
+    .slice(-eventLimit);
+
+  const openOperations = new Map<string, { name: string; timestamp: number }>();
+  let agentRequestOpen = false;
+  let lastLine: string | undefined;
+
+  for (const event of events) {
+    const pid = event.meta.pid ?? rootPid;
+    if (Trace.isOfType(Trace.OperationStart, event)) {
+      const key = `${pid}:${event.data.key}`;
+      const name = event.data.name ?? event.data.key;
+      openOperations.set(key, { name, timestamp: event.timestamp });
+      lastLine = `${name}...`;
+      continue;
+    }
+    if (Trace.isOfType(Trace.OperationEnd, event)) {
+      openOperations.delete(`${pid}:${event.data.key}`);
+      continue;
+    }
+    if (Trace.isOfType(AgentRequestBegin, event)) {
+      agentRequestOpen = true;
+      lastLine = 'Generating...';
+      continue;
+    }
+    if (Trace.isOfType(AgentRequestEnd, event)) {
+      agentRequestOpen = false;
+    }
+  }
+
+  if (agentRequestOpen) {
+    return 'Generating...';
+  }
+
+  const latestOperation = [...openOperations.values()].sort((left, right) => right.timestamp - left.timestamp)[0];
+  if (latestOperation) {
+    return `${latestOperation.name}...`;
+  }
+
+  return lastLine;
+};
+
+const collectDescendantPids = (messages: readonly Trace.Message[], rootPid: string): Set<string> => {
+  const pids = new Set([rootPid]);
+  let expanded = true;
+  while (expanded) {
+    expanded = false;
+    for (const message of messages) {
+      const pid = message.meta.pid;
+      const parentPid = message.meta.parentPid;
+      if (pid && parentPid && pids.has(parentPid) && !pids.has(pid)) {
+        pids.add(pid);
+        expanded = true;
+      }
+    }
+  }
+  return pids;
+};
+
 /**
  * A span is "collapsible" when it would otherwise render as an empty fork-and-merge:
  * exactly two events that form a begin/end pair and no child sub-spans. In that case

package/src/execution-graph/index.ts

@@ -5,10 +5,20 @@
 export {
   CommitSelector,
   buildExecutionGraph,
+  collectProcessActivityLines,
+  deriveInFlightActivityLine,
   type BuildExecutionGraphParams,
+  type CollectProcessActivityOptions,
   type ExecutionGraph,
   type ExecutionGraphDetailsMap,
 } from './execution-graph';
+export {
+  estimateTokenCount,
+  formatPendingBlockStatus,
+  pendingStatusFromEphemeralMessage,
+  resolveEphemeralStatusUpdate,
+  type EphemeralStatusUpdate,
+} from './pending-block-status';
 export {
   BEGIN_EVENT_TYPES,
   END_EVENT_TYPES,

package/src/execution-graph/pending-block-status.test.ts

@@ -0,0 +1,114 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { Trace } from '@dxos/compute';
+
+import {
+  formatPendingBlockStatus,
+  pendingStatusFromEphemeralMessage,
+  resolveEphemeralStatusUpdate,
+} from './pending-block-status';
+
+describe('formatPendingBlockStatus', () => {
+  test('formats pending text as generating tokens', ({ expect }) => {
+    const status = formatPendingBlockStatus({
+      _tag: 'text',
+      text: 'Hello world',
+      pending: true,
+    });
+    expect(status).toMatch(/^Generating \d+ tokens\.\.\.\.$/);
+  });
+
+  test('formats pending tool call with byte count', ({ expect }) => {
+    const status = formatPendingBlockStatus({
+      _tag: 'toolCall',
+      toolCallId: 'call-1',
+      name: 'create-document',
+      input: '{"title":"Haiku"}',
+      providerExecuted: false,
+      pending: true,
+    });
+    expect(status).toBe('Calling create-document (17 bytes)...');
+  });
+
+  test('returns undefined for completed blocks', ({ expect }) => {
+    expect(
+      formatPendingBlockStatus({
+        _tag: 'text',
+        text: 'Done',
+        pending: false,
+      }),
+    ).toBeUndefined();
+  });
+
+  test('formats operation input as calling with byte count', ({ expect }) => {
+    const status = pendingStatusFromEphemeralMessage(
+      ephemeralMessage([
+        {
+          type: Trace.OperationInput.key,
+          timestamp: Date.now(),
+          data: { key: 'org.dxos.function.agent.get-context', name: 'Get Agent Context', input: { foo: 'bar' } },
+        },
+      ]),
+    );
+    expect(status).toBe('Calling Get Agent Context (13 bytes)...');
+  });
+
+  test('leaves status unchanged (sticky) when partial block stream completes', ({ expect }) => {
+    expect(
+      resolveEphemeralStatusUpdate(
+        ephemeralMessage([
+          {
+            type: 'assistant.partialBlock',
+            timestamp: Date.now(),
+            data: {
+              messageId: 'msg-1',
+              role: 'assistant',
+              block: {
+                _tag: 'toolCall',
+                toolCallId: 'call-1',
+                name: 'update-tasks',
+                operationName: 'Update tasks',
+                input: '{}',
+                providerExecuted: false,
+                pending: false,
+              },
+            },
+          },
+        ]),
+      ),
+    ).toBe('unchanged');
+  });
+
+  test('suppresses raw routine ULID status updates', ({ expect }) => {
+    expect(
+      pendingStatusFromEphemeralMessage(
+        ephemeralMessage([
+          {
+            type: Trace.StatusUpdate.key,
+            timestamp: Date.now(),
+            data: { message: 'Running 01KVB9WBRG0000000000000000' },
+          },
+        ]),
+      ),
+    ).toBeUndefined();
+  });
+
+  test('keeps descriptive status updates', ({ expect }) => {
+    expect(
+      pendingStatusFromEphemeralMessage(
+        ephemeralMessage([
+          { type: Trace.StatusUpdate.key, timestamp: Date.now(), data: { message: 'Thinking about the plan' } },
+        ]),
+      ),
+    ).toBe('Thinking about the plan');
+  });
+});
+
+// `Trace.Message` is an ECHO object type, so a plain test literal does not structurally overlap it;
+// build the minimal ephemeral envelope the status helpers read via a single boundary cast.
+const ephemeralMessage = (events: readonly Trace.Event[]): Trace.Message =>
+  ({ meta: { pid: 'pid-1' }, isEphemeral: true, events }) as unknown as Trace.Message;

package/src/execution-graph/pending-block-status.ts

@@ -0,0 +1,88 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { PartialBlock } from '@dxos/assistant';
+import { Trace } from '@dxos/compute';
+import { type ContentBlock } from '@dxos/types';
+
+/**
+ * Approximate streamed token count from partial text (UTF-8 length / 4).
+ */
+export const estimateTokenCount = (text: string): number =>
+  Math.max(1, Math.ceil(new TextEncoder().encode(text).length / 4));
+
+const formatOperationInputStatus = (data: { key: string; name?: string; input: unknown }): string => {
+  const name = data.name ?? data.key;
+  const bytes = new TextEncoder().encode(JSON.stringify(data.input)).length;
+  return `Calling ${name} (${bytes} bytes)...`;
+};
+
+/** Raw routine status updates (e.g. `Running 01KVB9WBRG…`) carry an opaque ULID, not a useful label. */
+const ROUTINE_ULID_STATUS = /^Running [0-9A-HJKMNP-TV-Z]{26}$/i;
+
+/**
+ * Formats a pending assistant block for the delegated-task status line.
+ */
+export const formatPendingBlockStatus = (block: ContentBlock.Any): string | undefined => {
+  if (!block.pending) {
+    return undefined;
+  }
+
+  if (block._tag === 'text') {
+    return `Generating ${estimateTokenCount(block.text)} tokens....`;
+  }
+
+  if (block._tag === 'toolCall') {
+    const bytes = new TextEncoder().encode(block.input).length;
+    const name = block.operationName ?? block.name;
+    return `Calling ${name} (${bytes} bytes)...`;
+  }
+
+  return undefined;
+};
+
+/**
+ * Reads the latest pending partial block from an ephemeral trace message.
+ */
+export const pendingStatusFromEphemeralMessage = (message: Trace.Message): string | undefined => {
+  for (const event of message.events) {
+    if (Trace.isOfType(PartialBlock, event)) {
+      const status = formatPendingBlockStatus(event.data.block);
+      if (status) {
+        return status;
+      }
+      continue;
+    }
+
+    if (Trace.isOfType(Trace.OperationInput, event)) {
+      return formatOperationInputStatus(event.data);
+    }
+
+    if (Trace.isOfType(Trace.StatusUpdate, event)) {
+      // Suppress opaque routine ULID lines so descriptive partial-block / operation-input lines win.
+      if (ROUTINE_ULID_STATUS.test(event.data.message.trim())) {
+        continue;
+      }
+      return event.data.message;
+    }
+  }
+  return undefined;
+};
+
+export type EphemeralStatusUpdate = 'unchanged' | { readonly line: string };
+
+/**
+ * Maps an ephemeral trace message to a task-status update.
+ *
+ * The status line is "sticky": a message without a pending line (e.g. a completed block during an
+ * LLM-thinking gap) leaves the previous line in place rather than clearing it, so the row keeps
+ * showing the latest meaningful activity until a new line arrives or the subscription ends.
+ */
+export const resolveEphemeralStatusUpdate = (message: Trace.Message): EphemeralStatusUpdate => {
+  const line = pendingStatusFromEphemeralMessage(message);
+  if (line) {
+    return { line };
+  }
+  return 'unchanged';
+};

package/src/execution-graph/sub-agent-delegation.test.ts

@@ -7,7 +7,7 @@ import { describe, test } from 'vitest';
 import { Trace } from '@dxos/compute';
 import { renderTimelineAscii } from '@dxos/react-ui-components';
 
-import { buildExecutionGraph } from './execution-graph';
+import { buildExecutionGraph, collectProcessActivityLines, deriveInFlightActivityLine } from './execution-graph';
 import subAgentFixture from './testing/sub-agent-delegation.json';
 
 // Real trace captured from a live supervisor → sub-agent delegation via `dxosDumpTrace()`.
@@ -47,4 +47,19 @@ describe('sub-agent delegation fixture', () => {
       "
     `);
   });
+
+  test('collects sub-agent activity lines for a delegated process pid', ({ expect }) => {
+    const subAgentPid = 'cf8f7243-5b1d-4902-b158-70d9107d5f43';
+    const lines = collectProcessActivityLines(messages, subAgentPid);
+    expect(lines.length).toBeGreaterThan(0);
+    expect(lines).toContain('Run Routine');
+    expect(lines[lines.length - 1]).toMatch(/Run Routine - Success/);
+  });
+
+  test('derives in-flight operation before completion', ({ expect }) => {
+    const subAgentPid = 'cf8f7243-5b1d-4902-b158-70d9107d5f43';
+    const partial = messages.slice(0, Math.floor(messages.length / 2));
+    const line = deriveInFlightActivityLine(partial, subAgentPid);
+    expect(line).toBeDefined();
+  });
 });