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

package/src/extensions/prompt-extension.ts

@@ -3,7 +3,7 @@
 //
 
 import { syntaxTree } from '@codemirror/language';
-import { type Extension } from '@codemirror/state';
+import { Facet, type Extension, 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;
   }

package/src/feed-logger.ts

@@ -8,24 +8,25 @@ import * as Layer from 'effect/Layer';
 import { createFeedServiceLayer, type Space, getSpace } from '@dxos/client/echo';
 import { Sequence, type SequenceEvent, type SequenceLogger } from '@dxos/conductor';
 import { Feed, Obj, Ref } from '@dxos/echo';
-import { type Queue } from '@dxos/echo-client';
 import { EffectEx } from '@dxos/effect';
 import { InvocationTraceEndEvent, InvocationTraceEventType, InvocationTraceStartEvent } from '@dxos/functions-runtime';
 import { TraceEvent } from '@dxos/functions-runtime';
 import { InvocationOutcome } from '@dxos/functions-runtime';
 import { invariant } from '@dxos/invariant';
-import { EID, type EntityId } from '@dxos/keys';
+import { type EntityId } from '@dxos/keys';
 
 export class QueueLogger implements SequenceLogger {
   private _space: Space;
   private _invocationTraceFeed: Feed.Feed;
   private _feedServiceLayer: Layer.Layer<Feed.FeedService>;
+  /** Per-invocation trace feeds, keyed by invocationId. Created on `begin` and looked up for subsequent events. */
+  private _invocationFeeds = new Map<EntityId, Feed.Feed>();
 
   constructor(private readonly sequence: Sequence.Sequence) {
     const space = getSpace(sequence);
     invariant(space, 'Space not found');
     this._space = space;
-    this._feedServiceLayer = createFeedServiceLayer(space.queues);
+    this._feedServiceLayer = createFeedServiceLayer(space.db);
 
     const existingFeedRef = this._space.properties.invocationTraceFeed;
 
@@ -47,18 +48,22 @@ export class QueueLogger implements SequenceLogger {
 
   log(event: SequenceEvent) {
     switch (event.type) {
-      case 'begin':
+      case 'begin': {
+        // Create a per-invocation trace feed and store it so subsequent events can append to it.
+        const invocationFeed = this._space.db.add(Feed.make({ namespace: 'trace' }));
+        this._invocationFeeds.set(event.invocationId, invocationFeed);
         void this._appendToTraceFeed([
           Obj.make(InvocationTraceStartEvent, {
             type: InvocationTraceEventType.START,
             invocationId: event.invocationId,
             timestamp: Date.now(),
             input: {},
-            invocationTraceFeed: Ref.fromURI(this._getTraceQueueEchoId(event.invocationId)),
+            invocationTraceFeed: Ref.make(invocationFeed),
             invocationTarget: Ref.make(this.sequence),
           }),
         ]);
         break;
+      }
       case 'end':
         void this._appendToTraceFeed([
           Obj.make(InvocationTraceEndEvent, {
@@ -68,10 +73,12 @@ export class QueueLogger implements SequenceLogger {
             outcome: InvocationOutcome.SUCCESS,
           }),
         ]);
+        // Clean up the per-invocation feed reference once the invocation is complete.
+        this._invocationFeeds.delete(event.invocationId);
         break;
       case 'step-start':
       case 'step-complete':
-        void this._getTraceEventQueue(event.invocationId).append([
+        void this._appendToInvocationFeed(event.invocationId, [
           Obj.make(TraceEvent, {
             outcome: event.type,
             truncated: false,
@@ -89,7 +96,7 @@ export class QueueLogger implements SequenceLogger {
         ]);
         break;
       case 'message':
-        void this._getTraceEventQueue(event.invocationId).append([
+        void this._appendToInvocationFeed(event.invocationId, [
           Obj.make(TraceEvent, {
             outcome: event.type,
             truncated: false,
@@ -107,7 +114,7 @@ export class QueueLogger implements SequenceLogger {
         ]);
         break;
       case 'block':
-        void this._getTraceEventQueue(event.invocationId).append([
+        void this._appendToInvocationFeed(event.invocationId, [
           Obj.make(TraceEvent, {
             outcome: event.type,
             truncated: false,
@@ -127,10 +134,6 @@ export class QueueLogger implements SequenceLogger {
     }
   }
 
-  private _getTraceQueueEchoId(invocationId: EntityId): EID.EID {
-    return EID.make({ spaceId: this._space.id, entityId: invocationId });
-  }
-
   private _appendToTraceFeed(items: any[]): Promise<void> {
     return Feed.append(this._invocationTraceFeed, items).pipe(
       Effect.provide(this._feedServiceLayer),
@@ -138,12 +141,11 @@ export class QueueLogger implements SequenceLogger {
     );
   }
 
-  // TODO(burdon): The per-invocation trace event queues address feeds by raw queue DXN
-  // (no backing Feed.Feed object). Migration to Feed.append is blocked on either
-  // (a) materializing a Feed object per invocation, or (b) a lower-level
-  // FeedService.appendByDxn primitive. Tracked as Phase 6 work in echo/AUDIT.md.
-  private _getTraceEventQueue(invocationId: EntityId): Queue<TraceEvent> {
-    const echoUri = this._getTraceQueueEchoId(invocationId);
-    return this._space.queues.get(echoUri);
+  private _appendToInvocationFeed(invocationId: EntityId, items: any[]): Promise<void> {
+    const invocationFeed = this._invocationFeeds.get(invocationId);
+    if (!invocationFeed) {
+      return Promise.resolve();
+    }
+    return this._space.db.appendToFeed(invocationFeed, items);
   }
 }

package/src/hooks/index.ts

@@ -16,5 +16,7 @@ export * from './useFlush';
 export * from './useOnline';
 export * from './usePresets';
 export * from './useReferencesProvider';
+export * from './useTraceMessages';
+export * from './useProcessEphemeralStatus';
 
 export { type AiChatProcessor } from '../processor';

package/src/hooks/useChatProcessor.ts

@@ -57,7 +57,7 @@ export const useChatProcessor = ({
     if (!feedTarget) {
       return;
     }
-    const feedServiceLayer = createFeedServiceLayer(space.queues);
+    const feedServiceLayer = createFeedServiceLayer(space.db);
     const runtime = await EffectEx.runAndForwardErrors(
       Effect.runtime<Feed.FeedService>().pipe(Effect.provide(feedServiceLayer)),
     );

package/src/hooks/useChatServices.ts

@@ -4,7 +4,7 @@
 
 import { Capabilities } from '@dxos/app-framework';
 import { useCapability } from '@dxos/app-framework/ui';
-import { getPersonalSpace } from '@dxos/app-toolkit';
+import { AppSpace } from '@dxos/app-toolkit';
 import { type Key } from '@dxos/echo';
 import { useClient } from '@dxos/react-client';
 
@@ -21,7 +21,7 @@ export type UseChatServicesProps = {
  */
 export const useChatServices = ({ id }: UseChatServicesProps) => {
   const client = useClient();
-  id ??= getPersonalSpace(client)?.id;
+  id ??= AppSpace.getPersonalSpace(client)?.id;
 
   const runtime = useCapability(Capabilities.ProcessManagerRuntime);
   return id ? runtime : undefined;

package/src/hooks/useChatToolbarActions.ts

@@ -35,12 +35,12 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
 
       const builder = MenuBuilder.make()
         .root({
-          label: ['chat-toolbar.title', { ns: meta.id }],
+          label: ['chat-toolbar.title', { ns: meta.profile.key }],
         })
         .action(
           'new',
           {
-            label: ['new-thread.button', { ns: meta.id }],
+            label: ['new-thread.button', { ns: meta.profile.key }],
             icon: 'ph--plus--regular',
             type: 'new',
             disabled: !companionTo,
@@ -56,7 +56,7 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
         .action(
           'rename',
           {
-            label: ['rename-thread.button', { ns: meta.id }],
+            label: ['rename-thread.button', { ns: meta.profile.key }],
             icon: 'ph--magic-wand--regular',
             type: 'rename',
             disabled: !chat,
@@ -70,7 +70,7 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
         .action(
           'branch',
           {
-            label: ['branch-thread.menu', { ns: meta.id }],
+            label: ['branch-thread.menu', { ns: meta.profile.key }],
             icon: 'ph--git-branch--regular',
             type: 'branch',
             disabled: !chat || !db,
@@ -86,7 +86,7 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
         builder.group(
           'chats',
           {
-            label: ['chat-history.label', { ns: meta.id }],
+            label: ['chat-history.label', { ns: meta.profile.key }],
             icon: 'ph--clock-counter-clockwise--regular',
             selectCardinality: 'single',
             variant: 'dropdownMenu',

package/src/hooks/useContextBinder.ts

@@ -26,7 +26,7 @@ export const useContextBinder = (
       return;
     }
 
-    const feedServiceLayer = createFeedServiceLayer(space.queues);
+    const feedServiceLayer = createFeedServiceLayer(space.db);
     const runtime = await EffectEx.runAndForwardErrors(
       Effect.runtime<Feed.FeedService>().pipe(Effect.provide(feedServiceLayer)),
     );

package/src/hooks/useProcessEphemeralStatus.ts

@@ -0,0 +1,192 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom';
+import { useAtomValue } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
+import * as Stream from 'effect/Stream';
+import { useEffect, useMemo, useRef, useState } from 'react';
+
+import { Capabilities } from '@dxos/app-framework';
+import { useOptionalCapability } from '@dxos/app-framework/ui';
+import { Process, ServiceResolver, type Trace } from '@dxos/compute';
+import { ProcessManager } from '@dxos/compute-runtime';
+import { type Space } from '@dxos/react-client/echo';
+
+import { resolveEphemeralStatusUpdate } from '#execution-graph';
+
+const atomEmpty = Atom.make(() => [] as const);
+
+const ACTIVE_PROCESS_STATES = new Set<Process.State>([Process.State.RUNNING, Process.State.HYBERNATING]);
+
+/** Durable trace lines that represent finished work, not in-flight status. */
+export const isTerminalActivityLine = (line: string): boolean =>
+  line.endsWith(' - Success') || line.endsWith(' - Error') || line === 'Agent completed request';
+
+const collectDescendantPids = (processes: readonly Process.Info[], rootPid: string): Set<string> => {
+  const pids = new Set([rootPid]);
+  let expanded = true;
+  while (expanded) {
+    expanded = false;
+    for (const process of processes) {
+      const pid = String(process.pid);
+      const parentPid = process.parentPid ? String(process.parentPid) : undefined;
+      if (parentPid && pids.has(parentPid) && !pids.has(pid)) {
+        pids.add(pid);
+        expanded = true;
+      }
+    }
+  }
+  return pids;
+};
+
+const resolveSubscribePids = (agentPid: Process.ID, processes: readonly Process.Info[]): Process.ID[] => {
+  const rootPid = String(agentPid);
+  const descendants = collectDescendantPids(processes, rootPid);
+  const activePids = processes
+    .filter((process) => descendants.has(String(process.pid)) && ACTIVE_PROCESS_STATES.has(process.state))
+    .map((process) => process.pid);
+
+  if (activePids.length > 0) {
+    return activePids;
+  }
+
+  return [agentPid];
+};
+
+const attachActiveHandle = (
+  processManager: ProcessManager.Manager,
+  pid: Process.ID,
+): Effect.Effect<ProcessManager.Handle<any, any> | undefined> =>
+  Effect.gen(function* () {
+    const maxAttempts = 15;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const handle = yield* processManager.attach(pid).pipe(Effect.catchAll(() => Effect.succeed(undefined)));
+      if (handle && ACTIVE_PROCESS_STATES.has(handle.status.state)) {
+        return handle;
+      }
+      if (handle) {
+        return undefined;
+      }
+      yield* Effect.sleep(100);
+    }
+    return undefined;
+  });
+
+/**
+ * Subscribes to ephemeral trace events for a delegated sub-agent process subtree
+ * and surfaces the latest pending text or tool-call block as a status line.
+ */
+export const useProcessEphemeralStatus = (
+  agentPid: Process.ID | undefined,
+  space: Space | undefined,
+): string | undefined => {
+  // Optional capabilities: the live status is a progressive enhancement, so the component still
+  // renders (e.g. in standalone stories) when there is no plugin manager / process runtime.
+  const runtime = useOptionalCapability(Capabilities.ProcessManagerRuntime);
+  const monitor = useOptionalCapability(Capabilities.ProcessMonitor);
+  const processes = useAtomValue(monitor?.processTreeAtom ?? atomEmpty);
+  const [status, setStatus] = useState<string | undefined>();
+  const fibersRef = useRef<Fiber.RuntimeFiber<void, unknown>[]>([]);
+
+  const subscribePidsKey = useMemo(() => {
+    if (!agentPid) {
+      return '';
+    }
+    return resolveSubscribePids(agentPid, processes)
+      .map((pid) => String(pid))
+      .sort()
+      .join('|');
+  }, [agentPid, processes]);
+
+  useEffect(() => {
+    if (!agentPid || !space?.id || !runtime || !subscribePidsKey) {
+      setStatus(undefined);
+      return;
+    }
+
+    const pids = subscribePidsKey.split('|').map((pid) => Process.ID.make(pid));
+    let disposed = false;
+    let replaying = true;
+    let replayStatus: string | undefined;
+    const endReplay = () => {
+      replaying = false;
+      if (!disposed) {
+        setStatus(replayStatus);
+      }
+    };
+    queueMicrotask(endReplay);
+    fibersRef.current = [];
+
+    const handleEphemeralMessage = (message: Trace.Message) => {
+      const update = resolveEphemeralStatusUpdate(message);
+      if (update === 'unchanged') {
+        return;
+      }
+
+      if (replaying) {
+        replayStatus = update.line;
+        return;
+      }
+      setStatus(update.line);
+    };
+
+    const layer = ServiceResolver.provide({ space: space.id }, ProcessManager.ProcessManagerService);
+
+    const subscribe = (pid: Process.ID) =>
+      Effect.gen(function* () {
+        // `attachActiveHandle` polls, so a teardown can land mid-resolve; bail before forking a
+        // daemon that the cleanup pass below would never see (and thus never interrupt).
+        if (disposed) {
+          return;
+        }
+        const processManager = yield* ProcessManager.ProcessManagerService;
+        const handle = yield* attachActiveHandle(processManager, pid);
+        if (!handle || disposed) {
+          return;
+        }
+
+        // `forkDaemon` keeps the stream fiber alive after `runPromise(forEach)` returns;
+        // scoped `fork` is interrupted when the subscribe effect's parent scope closes.
+        const fiber = yield* handle.subscribeEphemeral().pipe(
+          Stream.runForEach((message) =>
+            Effect.sync(() => {
+              if (disposed) {
+                return;
+              }
+              handleEphemeralMessage(message);
+            }),
+          ),
+          Effect.forkDaemon,
+        );
+        if (disposed) {
+          yield* Fiber.interrupt(fiber);
+          return;
+        }
+        fibersRef.current.push(fiber);
+      });
+
+    void runtime
+      .runPromise(
+        Effect.forEach(pids, subscribe, { concurrency: 'unbounded', discard: true }).pipe(Effect.provide(layer)),
+      )
+      .catch(() => {
+        if (!disposed) {
+          setStatus(undefined);
+        }
+      });
+
+    return () => {
+      disposed = true;
+      const fibers = fibersRef.current;
+      fibersRef.current = [];
+      for (const fiber of fibers) {
+        void runtime.runPromise(Fiber.interrupt(fiber).pipe(Effect.provide(layer)));
+      }
+    };
+  }, [agentPid, runtime, space?.id, subscribePidsKey]);
+
+  return status;
+};

package/src/hooks/useTraceMessages.ts

@@ -0,0 +1,41 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom';
+import { useAtomValue } from '@effect-atom/atom-react';
+import { pipe } from 'effect/Function';
+import { useMemo } from 'react';
+
+import { Trace } from '@dxos/compute';
+import { Filter, Query } from '@dxos/echo';
+import { FeedTraceSink } from '@dxos/functions-runtime';
+import { type Space } from '@dxos/react-client/echo';
+
+const atomEmpty = Atom.make(() => [] as const);
+
+/**
+ * Atom of raw trace messages for a space — the input to `buildExecutionGraph`.
+ */
+export const getTraceMessagesAtom = (space: Space): Atom.Atom<readonly Trace.Message[]> =>
+  pipe(
+    space.db.query(FeedTraceSink.query).atom,
+    Atom.map(
+      (feeds) =>
+        // TODO(dmaretskyi): Single query with limit(1) and feed traversal when query supports it.
+        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))),
+  );
+
+/**
+ * Subscribes to the space invocation trace feed.
+ */
+export const useTraceMessages = (space?: Space): readonly Trace.Message[] => {
+  const atom = useMemo(() => (space ? getTraceMessagesAtom(space) : atomEmpty), [space]);
+  return useAtomValue(atom);
+};