@dxos/plugin-assistant 0.9.0 → 0.9.1-staging.ee54ba693a

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/span-tree.test.ts

@@ -9,7 +9,7 @@ import { describe, test } from 'vitest';
 import { AgentRequestBegin, AgentRequestEnd } from '@dxos/assistant';
 import { Trace } from '@dxos/compute';
 
-import { ROOT_SPAN_ID, buildSpanTree, flattenSpanTree } from './span-tree';
+import { ROOT_SPAN_ID, buildSpanTree, collectSpanTreeEventsCategorically, flattenSpanTree } from './span-tree';
 import { collectTraceEvents, withMeta } from './testing';
 
 const NoteEvent = Trace.EventType('note', {
@@ -246,4 +246,36 @@ describe('buildSpanTree', () => {
     expect(order[2].meta.pid).toBe('op-1');
     expect(order).toHaveLength(3);
   });
+
+  test('collectSpanTreeEventsCategorically emits begin, child subtrees, then remaining events', ({ expect }) => {
+    const messages = collectTraceEvents(
+      Effect.gen(function* () {
+        yield* withMeta({ pid: 'parent-1' }, Trace.write(Trace.OperationStart, { key: 'parent', name: 'Parent' }));
+        yield* withMeta(
+          { pid: 'child-1', parentPid: 'parent-1' },
+          Effect.gen(function* () {
+            yield* Trace.write(Trace.OperationStart, { key: 'child', name: 'Child' });
+            yield* Trace.write(Trace.OperationEnd, { key: 'child', name: 'Child', outcome: 'success' });
+          }),
+        );
+        yield* withMeta(
+          { pid: 'parent-1' },
+          Trace.write(Trace.OperationEnd, { key: 'parent', name: 'Parent', outcome: 'success' }),
+        );
+      }),
+    );
+
+    const tree = buildSpanTree(messages);
+    const order = collectSpanTreeEventsCategorically(tree).map(({ span, event }) => ({
+      pid: span.meta.pid ?? ROOT_SPAN_ID,
+      type: event.type,
+    }));
+
+    expect(order).toEqual([
+      { pid: 'parent-1', type: Trace.OperationStart.key },
+      { pid: 'child-1', type: Trace.OperationStart.key },
+      { pid: 'child-1', type: Trace.OperationEnd.key },
+      { pid: 'parent-1', type: Trace.OperationEnd.key },
+    ]);
+  });
 });

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

@@ -4,6 +4,7 @@
 
 import { AgentRequestBegin, AgentRequestEnd } from '@dxos/assistant';
 import { Trace } from '@dxos/compute';
+import { EID } from '@dxos/keys';
 
 /**
  * Synthetic id assigned to the root span.
@@ -54,8 +55,8 @@ const computeMeta = (rawMeta: Trace.Meta): SpanMeta => ({
   pid: rawMeta.pid,
   parentPid: rawMeta.parentPid,
   processName: rawMeta.processName,
-  conversationId: rawMeta.conversationId,
-  triggerId: rawMeta.triggerId,
+  conversationId: rawMeta.conversation ? EID.getEntityId(EID.parse(rawMeta.conversation.uri)) : undefined,
+  triggerId: rawMeta.trigger ? EID.getEntityId(EID.parse(rawMeta.trigger.uri)) : undefined,
   toolCallId: rawMeta.toolCallId,
   runtimeName: rawMeta.runtimeName,
 });
@@ -249,6 +250,46 @@ const applyEventLimit = (events: readonly Trace.FlatEvent[], eventLimit: number
 const isBoundary = (event: Trace.FlatEvent): boolean =>
   BEGIN_EVENT_TYPES.has(event.type) || END_EVENT_TYPES.has(event.type);
 
+/**
+ * A single event positioned within the span tree for commit emission.
+ */
+export interface SpanEventCursor {
+  readonly span: Span;
+  readonly event: Trace.FlatEvent;
+  readonly eventIndex: number;
+}
+
+/**
+ * Flattens span-tree events in categorical (depth-first) order: each span's begin events, its
+ * child subtrees in sibling order, then its remaining events (middle and end).
+ */
+export const collectSpanTreeEventsCategorically = (root: Span): SpanEventCursor[] => {
+  const stream: SpanEventCursor[] = [];
+
+  const visitSpan = (span: Span): void => {
+    for (let eventIndex = 0; eventIndex < span.events.length; eventIndex += 1) {
+      const event = span.events[eventIndex]!;
+      if (isSpanBeginEvent(event)) {
+        stream.push({ span, event, eventIndex });
+      }
+    }
+
+    for (const child of span.children) {
+      visitSpan(child);
+    }
+
+    for (let eventIndex = 0; eventIndex < span.events.length; eventIndex += 1) {
+      const event = span.events[eventIndex]!;
+      if (!isSpanBeginEvent(event)) {
+        stream.push({ span, event, eventIndex });
+      }
+    }
+  };
+
+  visitSpan(root);
+  return stream;
+};
+
 /**
  * Walks the span tree in depth-first pre-order, invoking `visit` for each span (root included).
  */

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()`.
@@ -24,27 +24,42 @@ describe('sub-agent delegation fixture', () => {
     expect(`\n${renderTimelineAscii(commits, branches)}\n`).toMatchInlineSnapshot(`
       "
       ●        [atom] Agent processing request...
-      ├──●     [info] Get Agent Context - Success
+      ├──●     [info] Get Agent Context
+      │  ●     [info] Get Agent Context
+      │  ●     [check-square-offset] Update tasks
+      │  ●     [info] Get Agent Context
+      │  ●     [share-network] Delegate task
+      │  ●     [info] Get Agent Context
+      │  ├──●  [brain] Run Routine
+      │  │  ●  [info] Get Agent Context
+      │  │  ●  [info] Get Agent Context
+      │  │  ●  [file-text] Create
+      │  │  ●  [info] Get Agent Context
+      │  │  ●  [plus] Add artifact - Error
+      │  │  ●  [info] Get Agent Context
+      │  │  ●  [info] Get Agent Context
+      │  │  ●  [user] Complete the following task and report the result concisely.
+      │  │  ●  [wrench] completeJob
+      ◆──┼──╯  [brain] Run Routine
       │  ●     [user] create a sub-agent that creates a haiku in a new document
-      │  ●     [info] Get Agent Context - Success
-      │  ●     [check-square-offset] Update tasks - Success
-      │  ●     [info] Get Agent Context - Success
-      │  ●     [share-network] Delegate task - Success
-      │  ●     [info] Get Agent Context - Success
       ◆──╯     [atom] Agent completed request
-      │  ├──●  [brain] Run Routine
-      │     ●  [info] Get Agent Context - Success
-      │     ●  [user] Complete the following task and report the result concisely.
-      │     ●  [info] Get Agent Context - Success
-      ●     │  [pencil] Update Chat Name - Success
-      │     ●  [file-text] Create - Success
-      │     ●  [info] Get Agent Context - Success
-      │     ●  [plus] Add artifact - Error
-      │     ●  [info] Get Agent Context - Success
-      │     ●  [wrench] completeJob - Success
-      │     ●  [info] Get Agent Context - Success
-      ◆─────╯  [brain] Run Routine - Success
+      ●        [pencil] Update Chat Name
       "
     `);
   });
+
+  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]).toBe('Run Routine');
+  });
+
+  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();
+  });
 });

package/src/extensions/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export { promptRunExtension, type PromptExtensionOptions } from './prompt-extension';
+export { type PromptExtensionOptions, promptRunExtension } from './prompt-extension';

package/src/extensions/prompt-extension.ts

@@ -3,7 +3,7 @@
 //
 
 import { syntaxTree } from '@codemirror/language';
-import { type Extension } from '@codemirror/state';
+import { type Extension, Facet, type Range } from '@codemirror/state';
 import { Decoration, type DecorationSet, EditorView, ViewPlugin, type ViewUpdate, WidgetType } from '@codemirror/view';
 
 import { Domino } from '@dxos/ui';
@@ -13,73 +13,104 @@ export type PromptExtensionOptions = {
   onRun: (promptText: string) => void;
 };
 
-/**
- * CodeMirror extension that adds a green "run" button to ```prompt fenced code blocks.
- */
-export const promptRunExtension = ({ onRun }: PromptExtensionOptions): Extension => {
-  return [
-    ViewPlugin.fromClass(
-      class {
-        decorations: DecorationSet;
-
-        constructor(view: EditorView) {
-          this.decorations = this.buildDecorations(view);
-        }
-
-        update(update: ViewUpdate) {
-          if (update.docChanged || update.viewportChanged || update.selectionSet || update.focusChanged) {
-            this.decorations = this.buildDecorations(update.view);
-          }
-        }
-
-        buildDecorations(view: EditorView): DecorationSet {
-          const decorations: Array<{ from: number; to: number; decoration: Decoration }> = [];
-
-          syntaxTree(view.state).iterate({
-            enter: (node) => {
-              if (node.name === 'FencedCode') {
-                const info = node.node.getChild('CodeInfo');
-                if (info) {
-                  const type = view.state.sliceDoc(info.from, info.to);
-                  const text = node.node.getChild('CodeText');
-                  if (type === 'prompt' && text) {
-                    const content = view.state.sliceDoc(text.from, text.to).trim();
-                    if (content.length > 0) {
-                      const widget = new PromptRunWidget(content, onRun);
-                      decorations.push({
-                        from: node.from,
-                        to: node.from,
-                        decoration: Decoration.widget({ widget, side: -1 }),
-                      });
-                    }
-                  }
+type OnRun = (text: string) => void;
+
+// Module-level facet so the plugin singleton can read the latest handler.
+const promptHandlerFacet = Facet.define<OnRun, OnRun | null>({
+  combine: (handlers) => handlers[0] ?? null,
+});
+
+// Module-level singleton — CM6 deduplicates by reference equality, preventing duplicate buttons
+// when the extension is contributed more than once.
+const promptPlugin = ViewPlugin.fromClass(
+  class {
+    decorations: DecorationSet;
+
+    constructor(view: EditorView) {
+      this.decorations = this.buildDecorations(view);
+    }
+
+    update(update: ViewUpdate) {
+      if (
+        update.docChanged ||
+        update.viewportChanged ||
+        update.selectionSet ||
+        update.focusChanged ||
+        update.startState.facet(promptHandlerFacet) !== update.state.facet(promptHandlerFacet)
+      ) {
+        this.decorations = this.buildDecorations(update.view);
+      }
+    }
+
+    buildDecorations(view: EditorView): DecorationSet {
+      const onRun = view.state.facet(promptHandlerFacet);
+      if (!onRun) {
+        return Decoration.none;
+      }
+
+      const ranges: Range<Decoration>[] = [];
+
+      syntaxTree(view.state).iterate({
+        enter: (node) => {
+          if (node.name === 'FencedCode') {
+            const info = node.node.getChild('CodeInfo');
+            if (info) {
+              const type = view.state.sliceDoc(info.from, info.to);
+              const text = node.node.getChild('CodeText');
+              if (type === 'prompt' && text) {
+                const content = view.state.sliceDoc(text.from, text.to).trim();
+                if (content.length > 0) {
+                  // Mark the header line as a positioned container for the button overlay.
+                  ranges.push(Decoration.line({ class: 'cm-prompt-header' }).range(node.from, node.from));
+                  ranges.push(
+                    Decoration.widget({ widget: new PromptRunWidget(content, onRun), side: -1 }).range(
+                      node.from,
+                      node.from,
+                    ),
+                  );
                 }
               }
-            },
-          });
-
-          return Decoration.set(
-            decorations.sort((a, b) => a.from - b.from || a.to - b.to).map((d) => d.decoration.range(d.from, d.to)),
-          );
-        }
-      },
-      {
-        decorations: (v) => v.decorations,
-      },
-    ),
-  ];
-};
+            }
+          }
+        },
+      });
+
+      // sort=true lets CM6 order by startSide (line decorations before widgets at the same position).
+      return Decoration.set(ranges, true);
+    }
+  },
+  {
+    decorations: (v) => v.decorations,
+  },
+);
+
+// Base theme wires up the positioned container on the header line.
+const promptTheme = EditorView.baseTheme({
+  '.cm-prompt-header': {
+    position: 'relative',
+    overflow: 'visible',
+  },
+});
+
+/**
+ * CodeMirror extension that adds a "run" button to ```prompt fenced code blocks.
+ */
+export const promptRunExtension = ({ onRun }: PromptExtensionOptions): Extension => [
+  promptHandlerFacet.of(onRun),
+  promptPlugin,
+  promptTheme,
+];
 
 class PromptRunWidget extends WidgetType {
   constructor(
     private readonly prompt: string,
-    private readonly onClick: (promptText: string) => void,
+    private readonly onClick: OnRun,
   ) {
     super();
   }
 
   override eq(other: this) {
-    return this.prompt === other.prompt;
+    return this.prompt === other.prompt && this.onClick === other.onClick;
   }
 
   override ignoreEvent() {
@@ -87,24 +118,22 @@ class PromptRunWidget extends WidgetType {
   }
 
   override toDOM() {
-    return Domino.of('div')
-      .classNames('relative')
+    return Domino.of('button')
+      .classNames(
+        'dx-button h-6 w-6 min-h-0 p-1 absolute top-0 right-0 bg-green-bg hover:bg-green-surface text-green-fg',
+      )
+      .on('mousedown', (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        this.onClick(this.prompt);
+      })
       .append(
-        Domino.of('button')
-          .classNames('dx-button absolute right-0 top-4')
-          .on('mousedown', (event) => {
-            event.preventDefault();
-            event.stopPropagation();
-            this.onClick(this.prompt);
-          })
+        Domino.of('svg', Domino.SVG)
+          .classNames('w-4 h-4 cursor-pointer')
           .append(
-            Domino.of('svg', Domino.SVG)
-              .classNames('w-4 h-4 cursor-pointer')
-              .append(
-                Domino.of('use', Domino.SVG).attributes({
-                  href: Domino.icon('ph--play--regular'),
-                }),
-              ),
+            Domino.of('use', Domino.SVG).attributes({
+              href: Domino.icon('ph--sparkle--regular'),
+            }),
           ),
       ).root;
   }