@dxos/plugin-assistant 0.10.0 → 0.11.0

package/src/components/AgentProperties/AgentProperties.tsx

@@ -2,25 +2,31 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Atom } from '@effect-atom/atom';
-import { useAtomValue } from '@effect-atom/atom-react';
 import * as Option from 'effect/Option';
 import React, { useCallback, useMemo } from 'react';
 
 import { type Agent } from '@dxos/assistant-toolkit';
+import { Trigger } from '@dxos/compute';
 import { Filter, Obj, Ref, Type } from '@dxos/echo';
-import { useQuery } from '@dxos/react-client/echo';
+import { useQuery } from '@dxos/echo-react';
+import { URI } from '@dxos/keys';
 import { Input, useTranslation } from '@dxos/react-ui';
 import { Form } from '@dxos/react-ui-form';
 import { FeedAnnotation } from '@dxos/schema';
 
 import { meta } from '#meta';
 
+/** Mirrors the foreign keys stamped by the agent-wizard automation compiler (`sync-automation`). */
+const AGENT_TRIGGER_EXTENSION_KEY = 'org.dxos.extension.AgentTrigger';
+const AGENT_TRIGGER_TARGET_EXTENSION_KEY = 'org.dxos.extension.AgentTriggerTarget';
+
 export type AgentPropertiesProps = {
   agent: Agent.Agent;
+  /** Invoked with the FULL next subscription set when the user toggles one. */
+  onSubscriptionsChanged?: (subscriptions: Ref.Ref<Obj.Unknown>[]) => void;
 };
 
-export const AgentProperties = ({ agent }: AgentPropertiesProps) => {
+export const AgentProperties = ({ agent, onSubscriptionsChanged }: AgentPropertiesProps) => {
   const { t } = useTranslation(meta.profile.key);
   const db = Obj.getDatabase(agent);
 
@@ -43,36 +49,37 @@ export const AgentProperties = ({ agent }: AgentPropertiesProps) => {
 
   const subscribedObjects = useQuery(db, feedFilter);
 
-  // Query all existing subscriptions (e.g., mail, calendar, etc.)
-  const existingSubscriptions = useAtomValue(
-    useMemo(
-      () =>
-        Obj.atom(agent).pipe((_) =>
-          Atom.make((get) => {
-            const agentObj = get(_);
-            const selectedSubscriptions: Obj.Unknown[] = subscribedObjects.filter((object) =>
-              agentObj.subscriptions.some((subscription) => subscription.uri === Obj.getURI(object)),
-            );
-
-            return selectedSubscriptions;
-          }),
-        ),
-      [agent, subscribedObjects],
-    ),
+  // The subscription state lives on the compiled automation (routine triggers), not the agent:
+  // a trigger's target foreign key holds the subscribed object's URI (`timer:` keys are schedules).
+  const triggers = useQuery(
+    db,
+    Filter.foreignKeys(Trigger.Trigger, [{ source: AGENT_TRIGGER_EXTENSION_KEY, id: agent.id }]),
+  );
+  const subscribedUris = useMemo(
+    () =>
+      new Set(
+        triggers
+          .map(
+            (trigger) => Obj.getMeta(trigger).keys.find((key) => key.source === AGENT_TRIGGER_TARGET_EXTENSION_KEY)?.id,
+          )
+          .filter((id): id is string => id !== undefined && !id.startsWith('timer:')),
+      ),
+    [triggers],
   );
 
-  // Create/remove agent subscription.
+  // Toggle recompiles the full subscription set (see `sync-automation`'s per-category reconcile).
   const handleSubscriptionChange = useCallback(
     (object: Obj.Unknown, checked: boolean) => {
-      Obj.update(agent, (agent) => {
-        if (checked) {
-          agent.subscriptions.push(Ref.fromURI(Obj.getURI(object)));
-        } else {
-          agent.subscriptions = agent.subscriptions.filter((subscription) => subscription.uri !== Obj.getURI(object));
-        }
-      });
+      const next = new Set(subscribedUris);
+      const uri = Obj.getURI(object);
+      if (checked) {
+        next.add(uri);
+      } else {
+        next.delete(uri);
+      }
+      onSubscriptionsChanged?.([...next].map((subscription) => Ref.fromURI(URI.make(subscription))));
     },
-    [agent],
+    [subscribedUris, onSubscriptionsChanged],
   );
 
   if (subscribedObjects.length === 0) {
@@ -89,7 +96,7 @@ export const AgentProperties = ({ agent }: AgentPropertiesProps) => {
         <Input.Root key={object.id}>
           <div className='flex items-center gap-2'>
             <Input.Checkbox
-              checked={existingSubscriptions.includes(object)}
+              checked={subscribedUris.has(Obj.getURI(object))}
               onCheckedChange={(checked) => {
                 handleSubscriptionChange(object, checked === true);
               }}

package/src/components/Chat/Chat.tsx

@@ -4,34 +4,47 @@
 
 import { Atom } from '@effect-atom/atom';
 import { useAtomValue } from '@effect-atom/atom-react';
-import * as Array from 'effect/Array';
 import * as Option from 'effect/Option';
 import React, { type PropsWithChildren, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
-import { Plan } from '@dxos/assistant-toolkit';
 import { Event } from '@dxos/async';
-import { getSpace } from '@dxos/client/echo';
 import { type Database, Filter, Obj, Query } from '@dxos/echo';
-import { useObject, useQuery } from '@dxos/react-client/echo';
-import { useIdentity } from '@dxos/react-client/halo';
-import { Button, Toast, composable, composableProps, useTranslation } from '@dxos/react-ui';
-import { type MarkdownStreamController } from '@dxos/react-ui-markdown';
+import { useObject, useQuery } from '@dxos/echo-react';
+import { useIdentity } from '@dxos/halo-react';
+import { log } from '@dxos/log';
+import {
+  Button,
+  type ThemedClassName,
+  Toast,
+  composable,
+  composableProps,
+  useDynamicRef,
+  useTranslation,
+} from '@dxos/react-ui';
+import { Minimap, type MinimapMarker } from '@dxos/react-ui-components';
+import { type DocumentRange, type MarkdownStreamController } from '@dxos/react-ui-markdown';
 import { Menu, MenuRootProps } from '@dxos/react-ui-menu';
+import { Outline } from '@dxos/types';
 import { Message } from '@dxos/types';
 
-import { useChatKeymapExtensions, useChatToolbarActions, useDebug, useTraceMessages } from '#hooks';
+import { useChatKeymapExtensions, useChatToolbarActions, useDebug } from '#hooks';
 import { meta } from '#meta';
 
-import { AiUsageQuotaError } from '../../processor';
+import { AiUsageQuotaError, type ProcessorRequestContext } from '../../processor';
 import {
   ChatStatus,
   ChatPrompt as NaturalChatPrompt,
   type ChatPromptProps as NaturalChatPromptProps,
 } from '../ChatPrompt';
-import { ChatThread as NaturalChatThread, type ChatThreadProps as NaturalChatThreadProps } from '../ChatThread';
+import {
+  type MessageSpan,
+  ChatThread as NaturalChatThread,
+  type ChatThreadProps as NaturalChatThreadProps,
+} from '../ChatThread';
 import { TaskList } from '../TaskList';
 import { ChatContextProvider, type ChatContextValue, type ChatRequestTiming, useChatContext } from './context';
 import { type ChatEvent } from './events';
+import { projectThread, resolveRewind } from './thread';
 
 //
 // Root
@@ -47,10 +60,21 @@ type ChatRootProps = PropsWithChildren<
      * persist and flush its conversation feed so the agent can resolve it.
      */
     onSubmit?: (text: string) => Promise<void> | void;
+    /** Called at submit time to capture ephemeral request context (e.g. companion selection). */
+    getContext?: () => ProcessorRequestContext | undefined;
   }
 >;
 
-const ChatRoot = ({ children, chat, processor, db: dbFallback, onEvent, onSubmit, ...props }: ChatRootProps) => {
+const ChatRoot = ({
+  children,
+  chat,
+  processor,
+  db: dbFallback,
+  onEvent,
+  onSubmit,
+  getContext,
+  ...props
+}: ChatRootProps) => {
   const [debug, setDebug] = useState(false);
   const streaming = useAtomValue(processor.streaming);
   const active = useAtomValue(processor.active);
@@ -67,14 +91,19 @@ const ChatRoot = ({ children, chat, processor, db: dbFallback, onEvent, onSubmit
   // Event sink.
   const event = useMemo(() => new Event<ChatEvent>(), []);
 
+  // The editor controller and per-message ranges are produced by `Chat.Thread` and consumed by
+  // `Chat.Minimap`; lifted here so both sub-components share the same instance.
+  const [controller, setController] = useState<MarkdownStreamController | null>(null);
+  const [messageRanges, setMessageRanges] = useState<MessageSpan[]>([]);
+
   const feedMessages = useQuery(
     db,
     feed ? Query.select(Filter.type(Message.Message)).from(feed) : Query.select(Filter.nothing()),
   );
   const pendingMessages = useAtomValue(processor.messages);
-  const messages = useMemo(
-    () => Array.dedupeWith([...feedMessages, ...pendingMessages], ({ id: a }, { id: b }) => a === b),
-    [feedMessages, pendingMessages],
+  const { messages } = useMemo(
+    () => projectThread({ feedMessages, pendingMessages, rewindFrom: feedSnapshot?.rewindFrom }),
+    [feedMessages, pendingMessages, feedSnapshot?.rewindFrom],
   );
 
   const dump = useDebug({ processor });
@@ -106,9 +135,25 @@ const ChatRoot = ({ children, chat, processor, db: dbFallback, onEvent, onSubmit
           const text = ev.text.trim();
           if (!streaming && text.length) {
             lastPrompt.current = ev.text;
+            const context = getContext?.();
             // Await persistence (transient chat) before requesting so the agent resolves the
             // now-durable conversation feed; resolves immediately when there is no hook.
-            void Promise.resolve(onSubmit?.(text)).then(() => processor.request({ message: text }));
+            void Promise.resolve(onSubmit?.(text)).then(() => processor.request({ message: text, context }));
+          }
+          break;
+        }
+
+        case 'rewind': {
+          // Edit-and-resend: discard the prompt and everything after it, and put its text back in the
+          // composer so it can be revised. Recorded on the feed rather than the chat because the
+          // continuation is appended by the agent's process, which resolves the feed and never sees the
+          // chat. A stale click (message already gone) resolves to nothing and is a no-op.
+          const rewind = feed && resolveRewind(messages, ev.id);
+          if (rewind) {
+            Obj.update(feed, (feed) => {
+              feed.rewindFrom = rewind.rewindFrom;
+            });
+            event.emit({ type: 'update-prompt', text: rewind.text });
           }
           break;
         }
@@ -133,7 +178,9 @@ const ChatRoot = ({ children, chat, processor, db: dbFallback, onEvent, onSubmit
 
       onEvent?.(ev);
     });
-  }, [event, dump, processor, streaming, onEvent, onSubmit]);
+    // `feed` and `messages` are dependencies because the rewind branch reads and writes them: without
+    // them the handler would keep resolving rewinds against whatever was mounted first.
+  }, [event, dump, processor, streaming, onEvent, onSubmit, getContext, feed, messages]);
 
   return (
     <ChatContextProvider
@@ -144,6 +191,10 @@ const ChatRoot = ({ children, chat, processor, db: dbFallback, onEvent, onSubmit
       messages={messages}
       processor={processor}
       requestTiming={requestTiming}
+      controller={controller}
+      setController={setController}
+      messageRanges={messageRanges}
+      setMessageRanges={setMessageRanges}
       {...props}
     >
       {children}
@@ -212,6 +263,84 @@ const ChatContent = composable<HTMLDivElement, ChatContentProps>(({ children, ..
 
 ChatContent.displayName = CHAT_CONTENT_NAME;
 
+//
+// Markers
+//
+
+const PROMPT_SNIPPET_LINES = 3;
+const PROMPT_SNIPPET_CHARS = 280;
+const PROMPT_TITLE_CHARS = 100;
+
+/** First non-empty line of a message's text, truncated for the marker title. */
+const promptTitle = (message: Message.Message): string => {
+  const text = Message.extractText(message).trim();
+  const firstLine = text.split('\n').find((line) => line.trim().length) ?? '';
+  return firstLine.length > PROMPT_TITLE_CHARS ? `${firstLine.slice(0, PROMPT_TITLE_CHARS)}…` : firstLine;
+};
+
+/** First few text lines of an assistant reply (tool calls, reasoning and status are excluded). */
+const replySnippet = (message: Message.Message): string | undefined => {
+  // `extractText` keeps only `text` blocks, so tool calls / reasoning / status are dropped.
+  const text = Message.extractText(message).trim();
+  if (!text.length) {
+    return undefined;
+  }
+  const snippet = text
+    .split('\n')
+    .filter((line) => line.trim().length)
+    .slice(0, PROMPT_SNIPPET_LINES)
+    .join('\n');
+  return snippet.length > PROMPT_SNIPPET_CHARS ? `${snippet.slice(0, PROMPT_SNIPPET_CHARS)}…` : snippet;
+};
+
+/**
+ * Build one minimap marker per user-prompt turn: title = the prompt text, description = a
+ * snippet of the following assistant reply, range = the turn's document span (prompt start →
+ * next prompt start). Positions come from the syncer's per-message range table.
+ */
+const buildMarkers = (messages: Message.Message[], ranges: MessageSpan[]): MinimapMarker[] => {
+  const rangeById = new Map(ranges.map((range) => [range.id, range] as const));
+  const markers: MinimapMarker[] = [];
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (message.sender.role !== 'user') {
+      continue;
+    }
+    const range = rangeById.get(message.id);
+    if (!range) {
+      continue;
+    }
+
+    // Extend the turn through the following non-user messages and grab the first assistant reply.
+    let turnTo = range.to;
+    let description: string | undefined;
+    for (let next = index + 1; next < messages.length; next++) {
+      const nextMessage = messages[next];
+      const nextRange = rangeById.get(nextMessage.id);
+      if (nextMessage.sender.role === 'user') {
+        if (nextRange) {
+          turnTo = nextRange.from;
+        }
+        break;
+      }
+      if (nextRange) {
+        turnTo = nextRange.to;
+      }
+      if (!description && nextMessage.sender.role === 'assistant') {
+        description = replySnippet(nextMessage);
+      }
+    }
+
+    markers.push({
+      id: message.id,
+      title: promptTitle(message) || 'Prompt',
+      description,
+      range: { from: range.from, to: turnTo },
+    });
+  }
+  return markers;
+};
+
 //
 // Thread
 //
@@ -225,7 +354,8 @@ type ChatThreadProps = Omit<NaturalChatThreadProps, 'identity' | 'messages' | 't
 
 const ChatThread = ({ viewType, debug: debugProp, onViewUsage, ...props }: ChatThreadProps) => {
   const { t } = useTranslation(meta.profile.key);
-  const { debug, event, messages, processor } = useChatContext(CHAT_THREAD_NAME);
+  const { debug, event, messages, processor, messageRanges, setController, setMessageRanges } =
+    useChatContext(CHAT_THREAD_NAME);
   const extensions = useChatKeymapExtensions({ event });
   const identity = useIdentity();
   const error = useAtomValue(processor.error).pipe(Option.getOrUndefined);
@@ -235,25 +365,70 @@ const ChatThread = ({ viewType, debug: debugProp, onViewUsage, ...props }: ChatT
   const debugView = viewType === 'debug';
 
   const controllerRef = useRef<MarkdownStreamController | null>(null);
+  // Share the controller with `Chat.Minimap` (and keep the local ref for event handling).
+  const handleControllerRef = useCallback(
+    (instance: MarkdownStreamController | null) => {
+      controllerRef.current = instance;
+      setController(instance);
+    },
+    [setController],
+  );
+
+  // Prompt-turn positions for navigation; a ref keeps the event handler stable without stale reads.
+  const promptPositions = useMemo(
+    () =>
+      buildMarkers(messages, messageRanges)
+        .map((marker) => marker.range.from)
+        .sort((a, b) => a - b),
+    [messages, messageRanges],
+  );
+  const promptPositionsRef = useDynamicRef(promptPositions);
+
+  // Navigate between prompt turns using the range table (not the xml-tag widget bookmarks).
+  const navigateToPrompt = useCallback(
+    (direction: 1 | -1) => {
+      const controller = controllerRef.current;
+      const positions = promptPositionsRef.current;
+      if (!controller || !positions.length) {
+        return;
+      }
+      const anchor = controller.getVisibleRange()?.from ?? 0;
+      const epsilon = 2;
+      const target =
+        direction > 0
+          ? positions.find((pos) => pos > anchor + epsilon)
+          : [...positions].reverse().find((pos) => pos < anchor - epsilon);
+      if (target != null) {
+        controller.scrollTo(target, { y: 'start' });
+      }
+    },
+    [promptPositionsRef],
+  );
+
   useEffect(() => {
     return event.on((event) => {
       switch (event.type) {
+        case 'rewind':
+          console.log('rewind', event);
+          break;
         case 'submit':
         case 'scroll-to-bottom':
           controllerRef.current?.scrollToBottom();
           break;
         case 'nav-previous':
-          controllerRef.current?.navigatePrevious();
+          navigateToPrompt(-1);
           break;
         case 'nav-next':
-          controllerRef.current?.navigateNext();
+          navigateToPrompt(1);
           break;
         case 'error':
           setToastError(event.error);
           break;
+        default:
+          log.info('no handled', event);
       }
     });
-  }, [event]);
+  }, [event, navigateToPrompt]);
 
   const handleEvent = useCallback<NonNullable<NaturalChatThreadProps['onEvent']>>(
     (ev) => {
@@ -277,7 +452,8 @@ const ChatThread = ({ viewType, debug: debugProp, onViewUsage, ...props }: ChatT
         viewType={viewType}
         extensions={extensions}
         onEvent={handleEvent}
-        ref={controllerRef}
+        onSpans={setMessageRanges}
+        ref={handleControllerRef}
       />
 
       <Toast.Root
@@ -311,6 +487,45 @@ const ChatThread = ({ viewType, debug: debugProp, onViewUsage, ...props }: ChatT
 
 ChatThread.displayName = CHAT_THREAD_NAME;
 
+//
+// Minimap
+//
+
+const CHAT_MINIMAP_NAME = 'Chat.Minimap';
+
+type ChatMinimapProps = ThemedClassName<{}>;
+
+/**
+ * Anchor-marker rail for the thread: one tick per user-prompt turn. Reads the shared controller
+ * and the syncer's range table from context; clicking a tick scrolls the thread to that turn.
+ */
+const ChatMinimap = ({ classNames }: ChatMinimapProps) => {
+  const { messages, messageRanges, controller } = useChatContext(CHAT_MINIMAP_NAME);
+  const [visibleRange, setVisibleRange] = useState<DocumentRange | undefined>(undefined);
+  useEffect(() => {
+    if (!controller) {
+      return;
+    }
+    return controller.onVisibleRangeChange(setVisibleRange);
+  }, [controller]);
+
+  const markers = useMemo(() => buildMarkers(messages, messageRanges), [messages, messageRanges]);
+  const handleSelect = useCallback(
+    (marker: MinimapMarker) => {
+      controller?.scrollTo(marker.range.from, { y: 'start' });
+    },
+    [controller],
+  );
+
+  if (!markers.length) {
+    return null;
+  }
+
+  return <Minimap classNames={classNames} markers={markers} visibleRange={visibleRange} onSelect={handleSelect} />;
+};
+
+ChatMinimap.displayName = CHAT_MINIMAP_NAME;
+
 //
 // Prompt
 //
@@ -333,46 +548,38 @@ ChatPrompt.displayName = CHAT_PROMPT_NAME;
 const CHAT_TASK_LIST_NAME = 'Chat.TaskList';
 
 type ChatTaskListProps = {
-  plan?: Plan.Plan;
+  outline?: Outline.Outline;
 };
 
-const ChatTaskList = composable<HTMLDivElement, ChatTaskListProps>(({ plan: planProp, ...props }, forwardedRef) => {
-  const { chat } = useChatContext(CHAT_TASK_LIST_NAME);
-
-  const plan = useAtomValue(
-    useMemo(
-      () =>
-        Atom.make(
-          (get) =>
-            planProp ??
-            Option.fromNullable(chat).pipe(
-              Option.map((_) => get(Obj.atom(_))),
-              Option.flatMapNullable((_) => _?.plan?.atom),
-              Option.map(get),
-              Option.getOrUndefined,
-            ),
-        ),
-      [chat, planProp],
-    ),
-  );
-  const space = chat ? getSpace(chat) : undefined;
-  const traceMessages = useTraceMessages(space);
-  const conversationId = chat?.feed?.target?.id;
-  if (!plan || !(plan.tasks?.length ?? 0)) {
-    return null;
-  }
+// TODO(burdon): Project chats keep their working checklist on the parent project's outline —
+//  resolve via the parent edge (needs a reactive parent lookup), not only `chat.outline`.
+const ChatTaskList = composable<HTMLDivElement, ChatTaskListProps>(
+  ({ outline: outlineProp, ...props }, forwardedRef) => {
+    const { chat } = useChatContext(CHAT_TASK_LIST_NAME);
+
+    const outline = useAtomValue(
+      useMemo(
+        () =>
+          Atom.make(
+            (get) =>
+              outlineProp ??
+              Option.fromNullable(chat).pipe(
+                Option.map((_) => get(Obj.atom(_))),
+                Option.flatMapNullable((_) => _?.outline?.atom),
+                Option.map(get),
+                Option.getOrUndefined,
+              ),
+          ),
+        [chat, outlineProp],
+      ),
+    );
+    if (!outline) {
+      return null;
+    }
 
-  return (
-    <TaskList
-      {...props}
-      plan={plan}
-      space={space}
-      traceMessages={traceMessages}
-      conversationId={conversationId}
-      ref={forwardedRef}
-    />
-  );
-});
+    return <TaskList {...props} outline={outline} ref={forwardedRef} />;
+  },
+);
 
 ChatTaskList.displayName = CHAT_TASK_LIST_NAME;
 
@@ -387,7 +594,16 @@ export const Chat = {
   Prompt: ChatPrompt,
   Status: ChatStatus,
   Thread: ChatThread,
+  Minimap: ChatMinimap,
   TaskList: ChatTaskList,
 };
 
-export type { ChatContentProps, ChatEvent, ChatPromptProps, ChatRootProps, ChatThreadProps, ChatToolbarProps };
+export type {
+  ChatContentProps,
+  ChatEvent,
+  ChatMinimapProps,
+  ChatPromptProps,
+  ChatRootProps,
+  ChatThreadProps,
+  ChatToolbarProps,
+};

package/src/components/Chat/{Chat.stories.tsx → Error.stories.tsx}

@@ -56,7 +56,7 @@ const FailureToast = ({ rawError }: FailureToastProps) => {
 };
 
 const meta = {
-  title: 'plugins/plugin-assistant/components/Chat',
+  title: 'plugins/plugin-assistant/components/Error',
   render: FailureToast,
   decorators: [withTheme(), withLayout({ layout: 'fullscreen' })],
   parameters: { translations },

package/src/components/Chat/context.ts

@@ -7,9 +7,11 @@ import { createContext } from '@radix-ui/react-context';
 import { type Chat as ChatModule } from '@dxos/assistant-toolkit';
 import { type Event } from '@dxos/async';
 import { type Database } from '@dxos/echo';
+import { type MarkdownStreamController } from '@dxos/react-ui-markdown';
 import { type Message } from '@dxos/types';
 
 import { type AiChatProcessor } from '../../processor';
+import { type MessageSpan } from '../ChatThread';
 import { type ChatEvent } from './events';
 
 /**
@@ -31,6 +33,12 @@ export type ChatContextValue = {
   messages: Message.Message[];
   processor: AiChatProcessor;
   requestTiming: ChatRequestTiming | null;
+  /** The thread's editor controller, shared between `Chat.Thread` and `Chat.Minimap`. */
+  controller: MarkdownStreamController | null;
+  setController: (controller: MarkdownStreamController | null) => void;
+  /** Per-message document offset ranges, published by `Chat.Thread`'s syncer. */
+  messageRanges: MessageSpan[];
+  setMessageRanges: (ranges: MessageSpan[]) => void;
 };
 
 // Internal: not re-exported from `Chat/index.ts`. Accessed by sibling components in this

package/src/components/Chat/events.ts

@@ -29,6 +29,11 @@ export type ChatEvent =
       type: 'delete';
       id: string;
     }
+  /** Soft-fork the thread: continue from this message, leaving what followed it unreachable. */
+  | {
+      type: 'rewind';
+      id: string;
+    }
   | {
       type: 'add';
       object: Obj.Unknown;