@dxos/plugin-assistant 0.10.0 → 0.11.0

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

@@ -2,10 +2,19 @@
 // Copyright 2026 DXOS.org
 //
 
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+
 import { AgentRequestBegin, AgentRequestEnd } from '@dxos/assistant';
 import { Trace } from '@dxos/compute';
 import { EID } from '@dxos/keys';
 
+/**
+ * Default duration a span may sit open with no new events before it's considered abandoned
+ * (the runtime crashed, lost connectivity, or otherwise never wrote the closing event).
+ */
+export const DEFAULT_SPAN_TIMEOUT_MS = 20 * 60 * 1_000;
+
 /**
  * Synthetic id assigned to the root span.
  * The root is a virtual container for top-level spans (those without a parent in the captured trace).
@@ -93,6 +102,20 @@ export interface BuildSpanTreeOptions {
    * and collapse them onto the root branch.
    */
   eventLimit?: number;
+
+  /**
+   * Duration a span may sit open with no new events before it's force-closed with a synthetic
+   * end event. Only takes effect when `now` is also provided. Defaults to
+   * `DEFAULT_SPAN_TIMEOUT_MS`.
+   */
+  spanTimeoutMs?: number;
+
+  /**
+   * Reference time used to detect abandoned spans. Force-closing is skipped entirely when this
+   * is omitted, so callers that don't pass it (tests, deterministic snapshots) keep the prior
+   * behavior of leaving unterminated spans open regardless of their fixture timestamps.
+   */
+  now?: number;
 }
 
 /**
@@ -133,6 +156,12 @@ export const buildSpanTree = (messages: readonly Trace.Message[], options: Build
   // a sibling's released lane instead of forking off its parent.
   const lastSpanByPid = new Map<string, MutableSpan>();
 
+  // Every span ever opened, including ones later superseded by a same-pid begin event before
+  // getting an end event (§15 "interleaved same-pid begin/end pairs"). `openSpans` only tracks
+  // the *current* span per pid, so a superseded span — which will never receive an end event —
+  // would otherwise be unreachable by the timeout sweep below.
+  const allSpans: MutableSpan[] = [];
+
   let spanCounter = 0;
   const allocSpanId = (pid: string): string => {
     const id = `${pid}#${spanCounter}`;
@@ -165,6 +194,7 @@ export const buildSpanTree = (messages: readonly Trace.Message[], options: Build
       span.events.push(event);
       noteTimestamp(span, event.timestamp);
       parent.children.push(span);
+      allSpans.push(span);
       // The new span supersedes any previously-open span for this pid.
       openSpans.set(pid, span);
       lastSpanByPid.set(pid, span);
@@ -196,6 +226,29 @@ export const buildSpanTree = (messages: readonly Trace.Message[], options: Build
     }
   }
 
+  // Force-close spans the runtime never reported the end of (crash, dropped connection, etc.) —
+  // otherwise they stay open forever and the UI renders them as stuck mid-flight. Walks every
+  // span ever opened (not just `openSpans`) so a span superseded by a later same-pid begin event
+  // — which never receives its own end event — is force-closed too. Skipped when `now` isn't
+  // supplied so callers that don't care about wall-clock staleness are unaffected.
+  if (options.now !== undefined) {
+    const now = options.now;
+    const spanTimeoutMs = options.spanTimeoutMs ?? DEFAULT_SPAN_TIMEOUT_MS;
+    for (const span of allSpans) {
+      const lastEvent = span.events[span.events.length - 1]!;
+      if (isSpanEndEvent(lastEvent)) {
+        continue;
+      }
+      const timeoutAt = lastEvent.timestamp + spanTimeoutMs;
+      if (now < timeoutAt) {
+        continue;
+      }
+      const endEvent = makeTimeoutEndEvent(span, timeoutAt);
+      span.events.push(endEvent);
+      noteTimestamp(span, endEvent.timestamp);
+    }
+  }
+
   // Sort children chronologically for deterministic output.
   const sortChildren = (span: MutableSpan): void => {
     span.children.sort((a, b) => a.firstTimestamp - b.firstTimestamp);
@@ -208,6 +261,48 @@ export const buildSpanTree = (messages: readonly Trace.Message[], options: Build
   return freezeSpan(root);
 };
 
+/**
+ * Message stamped on synthetic end events produced when a span times out.
+ */
+const SPAN_TIMEOUT_MESSAGE = 'No end event was recorded for this span; it was closed after a timeout.';
+
+/**
+ * Synthesizes the end event that closes an abandoned span, matching the event type its begin
+ * event opened it with (`OperationStart` → `OperationEnd`, `AgentRequestBegin` → `AgentRequestEnd`).
+ */
+const makeTimeoutEndEvent = (span: MutableSpan, timestamp: number): Trace.FlatEvent => {
+  const beginEvent = span.events[0]!;
+  if (beginEvent.type === AgentRequestBegin.key) {
+    return {
+      type: AgentRequestEnd.key,
+      timestamp,
+      meta: beginEvent.meta,
+      isEphemeral: false,
+      data: { status: 'interrupted', error: SPAN_TIMEOUT_MESSAGE },
+    };
+  }
+
+  // `beginEvent.data` is unvalidated wire data; decode defensively rather than trusting its shape.
+  const fallback: Schema.Schema.Type<typeof Trace.OperationStart.schema> = { key: 'unknown' };
+  const beginData = Option.getOrElse(
+    Schema.decodeUnknownOption(Trace.OperationStart.schema)(beginEvent.data),
+    () => fallback,
+  );
+  return {
+    type: Trace.OperationEnd.key,
+    timestamp,
+    meta: beginEvent.meta,
+    isEphemeral: false,
+    data: {
+      key: beginData.key,
+      name: beginData.name,
+      icon: beginData.icon,
+      outcome: 'failure',
+      error: SPAN_TIMEOUT_MESSAGE,
+    },
+  };
+};
+
 /**
  * Caps the number of non-boundary events while retaining every span boundary event.
  *

package/src/feed-logger.ts

@@ -6,16 +6,16 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
 import { type Space, getSpace } from '@dxos/client/echo';
+import { InvocationTraceEndEvent, InvocationTraceEventType, InvocationTraceStartEvent } from '@dxos/compute-runtime';
+import { TraceEvent } from '@dxos/compute-runtime';
+import { InvocationOutcome } from '@dxos/compute-runtime';
 import { Sequence, type SequenceEvent, type SequenceLogger } from '@dxos/conductor';
 import { Database, Feed, Obj, Ref } from '@dxos/echo';
 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 { type EntityId } from '@dxos/keys';
 
-export class QueueLogger implements SequenceLogger {
+export class FeedLogger implements SequenceLogger {
   private _space: Space;
   private _invocationTraceFeed: Feed.Feed;
   private _feedServiceLayer: Layer.Layer<Database.Service>;
@@ -34,11 +34,11 @@ export class QueueLogger implements SequenceLogger {
       // A feed reference exists; ensure its target is loaded. If not, fail loudly
       // rather than silently creating a new feed and orphaning existing traces.
       invariant(existingFeedRef.target, 'invocationTraceFeed reference is not yet loaded');
-      invariant(Feed.getQueueUri(existingFeedRef.target), 'invocationTraceFeed has no queue DXN');
+      invariant(Feed.getFeedUri(existingFeedRef.target), 'invocationTraceFeed has no feed URI');
       this._invocationTraceFeed = existingFeedRef.target;
     } else {
       const feed = space.db.add(Feed.make({ namespace: 'trace' }));
-      invariant(Feed.getQueueUri(feed), 'New invocationTraceFeed has no queue DXN');
+      invariant(Feed.getFeedUri(feed), 'New invocationTraceFeed has no feed URI');
       Obj.update(this._space.properties, (obj) => {
         obj.invocationTraceFeed = Ref.make(feed);
       });

package/src/hooks/index.ts

@@ -12,9 +12,9 @@ export * from './useContextBinder';
 export * from './useContextObjects';
 export { useDebug } from './useDebug';
 export * from './useFilteredTypes';
-export * from './useFlush';
 export * from './usePresets';
 export * from './useReferencesProvider';
+export * from './useSelectionContext';
 export * from './useTraceMessages';
 export * from './useHomeSuggestions';
 export * from './useProcessEphemeralStatus';

package/src/hooks/useChatProcessor.ts

@@ -14,9 +14,10 @@ import { AiSession } from '@dxos/assistant';
 import { type Chat } from '@dxos/assistant-toolkit';
 import { AgentService, Credential, ServiceResolver } from '@dxos/compute';
 import { Database, Obj, Ref, Registry } from '@dxos/echo';
+import { useObject } from '@dxos/echo-react';
 import { EffectEx } from '@dxos/effect';
 import { log } from '@dxos/log';
-import { type Space, useObject } from '@dxos/react-client/echo';
+import { type Space } from '@dxos/react-client/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
 
 import { type Assistant } from '#types';

package/src/hooks/useChatToolbarActions.ts

@@ -33,17 +33,17 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
           ? get(db.query(Query.select(Filter.id(companionTo.id)).targetOf(Chat.CompanionTo).source()).atom)
           : [];
 
-      const builder = MenuBuilder.make()
-        .root({
-          label: ['chat-toolbar.title', { ns: meta.profile.key }],
-        })
-        .action(
+      const builder = MenuBuilder.make().root({
+        label: ['chat-toolbar.title', { ns: meta.profile.key }],
+      });
+
+      if (companionTo) {
+        builder.action(
           'new',
           {
             label: ['new-thread.button', { ns: meta.profile.key }],
             icon: 'ph--plus--regular',
             type: 'new',
-            disabled: !companionTo,
           },
           () => {
             invariant(companionTo);
@@ -52,33 +52,36 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
               chat: undefined,
             }).pipe(EffectEx.runAndForwardErrors);
           },
-        )
+        );
+      }
+
+      builder
         .action(
-          'rename',
+          'branch',
           {
-            label: ['rename-thread.button', { ns: meta.profile.key }],
-            icon: 'ph--magic-wand--regular',
-            type: 'rename',
-            disabled: !chat,
+            label: ['branch-thread.menu', { ns: meta.profile.key }],
+            icon: 'ph--git-branch--regular',
+            type: 'branch',
+            disabled: !chat || !db,
           },
           () =>
             Effect.gen(function* () {
               invariant(chat);
-              yield* invoke(AssistantOperation.UpdateChatName, { chat }, { spaceId: db?.spaceId });
+              yield* invoke(AssistantOperation.ForkChat, { chat, companionTo }, { spaceId: db?.spaceId });
             }).pipe(EffectEx.runAndForwardErrors),
         )
         .action(
-          'branch',
+          'rename',
           {
-            label: ['branch-thread.menu', { ns: meta.profile.key }],
-            icon: 'ph--git-branch--regular',
-            type: 'branch',
-            disabled: !chat || !db,
+            label: ['rename-thread.button', { ns: meta.profile.key }],
+            icon: 'ph--magic-wand--regular',
+            type: 'rename',
+            disabled: !chat,
           },
           () =>
             Effect.gen(function* () {
               invariant(chat);
-              yield* invoke(AssistantOperation.ForkChat, { chat, companionTo }, { spaceId: db?.spaceId });
+              yield* invoke(AssistantOperation.UpdateChatName, { chat }, { spaceId: db?.spaceId });
             }).pipe(EffectEx.runAndForwardErrors),
         );
 

package/src/hooks/useContextObjects.ts

@@ -3,10 +3,11 @@
 //
 
 import { Atom, useAtomValue } from '@effect-atom/atom-react';
-import { useCallback } from 'react';
+import { useCallback, useMemo } from 'react';
 
 import { type AiContext } from '@dxos/assistant';
-import { type Database, type Obj } from '@dxos/echo';
+import { Chat } from '@dxos/assistant-toolkit';
+import { type Database, Obj } from '@dxos/echo';
 import { type URI } from '@dxos/keys';
 
 export type UseContextObjectsProps = {
@@ -25,7 +26,12 @@ const emptyObjectsAtom = Atom.make<Obj.Unknown[]>([]);
  * Create reactive map of active object references (by DXN string).
  */
 export const useContextObjects = ({ db, context }: UseContextObjectsProps): UseContextObjects => {
-  const objects = useAtomValue(context?.objects ?? emptyObjectsAtom);
+  const boundObjects = useAtomValue(context?.objects ?? emptyObjectsAtom);
+  // The session's own chat is bound into its context so the agent harness can resolve it
+  // (`get-context` requires a bound chat to read the plan when no agent is present); it is not a
+  // user-added reference, so exclude it from the UI. Mirrors the `!Obj.instanceOf(Chat.Chat, …)`
+  // filter applied when copying context objects in `assistant-toolkit` `Agent`.
+  const objects = useMemo(() => boundObjects.filter((object) => !Obj.instanceOf(Chat.Chat, object)), [boundObjects]);
 
   const handleUpdateObject = useCallback<UseContextObjects['onUpdateObject']>(
     async (dxn: URI.URI, checked: boolean) => {

package/src/hooks/useSelectionContext.test.ts

@@ -0,0 +1,93 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { Obj } from '@dxos/echo';
+import { Expando } from '@dxos/schema';
+
+import { getSelectionContext } from './useSelectionContext';
+
+describe('getSelectionContext', () => {
+  const object = Obj.make(Expando.Expando, { content: 'hello brave world' });
+  const typename = Obj.getTypename(object);
+  const resolver = {
+    key: typename ?? '',
+    getText: (_obj: unknown, anchor: string) => (anchor === 'a:b' ? 'brave' : undefined),
+  };
+
+  test('resolves selection ranges to text via the typename resolver', ({ expect }) => {
+    const context = getSelectionContext({
+      object,
+      selection: { mode: 'multi-range', ranges: [{ from: 'a', to: 'b' }] },
+      resolvers: [resolver],
+    });
+    expect(context?.selection?.text).toBe('brave');
+    expect(context?.selection?.anchors).toEqual(['a:b']);
+  });
+
+  test('returns undefined without a matching resolver', ({ expect }) => {
+    const context = getSelectionContext({
+      object,
+      selection: { mode: 'multi-range', ranges: [{ from: 'a', to: 'b' }] },
+      resolvers: [],
+    });
+    expect(context).toBeUndefined();
+  });
+
+  test('returns undefined when nothing resolves', ({ expect }) => {
+    const context = getSelectionContext({
+      object,
+      selection: { mode: 'multi-range', ranges: [{ from: 'x', to: 'y' }] },
+      resolvers: [resolver],
+    });
+    expect(context).toBeUndefined();
+  });
+
+  test('returns undefined for an empty selection', ({ expect }) => {
+    expect(getSelectionContext({ object, selection: undefined, resolvers: [resolver] })).toBeUndefined();
+  });
+
+  test('skips a range whose cursor throws and keeps the ranges that resolve', ({ expect }) => {
+    const throwingResolver = {
+      key: typename ?? '',
+      getText: (_obj: unknown, anchor: string) => {
+        if (anchor === 'stale:cursor') {
+          throw new Error('unparseable cursor');
+        }
+        return anchor === 'a:b' ? 'brave' : undefined;
+      },
+    };
+
+    const context = getSelectionContext({
+      object,
+      selection: {
+        mode: 'multi-range',
+        ranges: [
+          { from: 'stale', to: 'cursor' },
+          { from: 'a', to: 'b' },
+        ],
+      },
+      resolvers: [throwingResolver],
+    });
+    expect(context?.selection?.text).toBe('brave');
+    expect(context?.selection?.anchors).toEqual(['a:b']);
+  });
+
+  test('drops an unresolvable range from anchors so anchors stay aligned with text', ({ expect }) => {
+    const context = getSelectionContext({
+      object,
+      selection: {
+        mode: 'multi-range',
+        ranges: [
+          { from: 'x', to: 'y' },
+          { from: 'a', to: 'b' },
+        ],
+      },
+      resolvers: [resolver],
+    });
+    expect(context?.selection?.text).toBe('brave');
+    expect(context?.selection?.anchors).toEqual(['a:b']);
+  });
+});

package/src/hooks/useSelectionContext.ts

@@ -0,0 +1,72 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useCallback } from 'react';
+
+import { useCapabilities } from '@dxos/app-framework/ui';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Obj } from '@dxos/echo';
+import { AttentionCapabilities } from '@dxos/plugin-attention';
+import { Selection } from '@dxos/react-ui-attention';
+
+import { type ProcessorRequestContext } from '../processor';
+
+/** Resolve `object`'s selection to text via the AnchorResolver contributed for its typename. */
+export const getSelectionContext = ({
+  object,
+  selection,
+  resolvers,
+}: {
+  object: Obj.Unknown;
+  selection: Selection.Selection | undefined;
+  resolvers: readonly AppCapabilities.AnchorResolver[];
+}): ProcessorRequestContext | undefined => {
+  const typename = Obj.getTypename(object);
+  const resolver = typename ? resolvers.find((candidate) => candidate.key === typename) : undefined;
+  if (!resolver) {
+    return undefined;
+  }
+
+  // A stale cursor throws in Automerge; a bad range must not abort the submit.
+  const resolveAnchorText = (anchor: string): string | undefined => {
+    try {
+      return resolver.getText(object, anchor);
+    } catch {
+      return undefined;
+    }
+  };
+
+  // Anchors and text stay pairwise-aligned: a range that fails to resolve is dropped from both.
+  const resolved = Selection.toAnchors(selection).flatMap((anchor) => {
+    const text = resolveAnchorText(anchor);
+    return text != null && text.length > 0 ? [{ anchor, text }] : [];
+  });
+  if (resolved.length === 0) {
+    return undefined;
+  }
+
+  return {
+    selection: {
+      anchors: resolved.map(({ anchor }) => anchor),
+      text: resolved.map(({ text }) => text).join('\n…\n'),
+    },
+  };
+};
+
+/** Submit-time provider of the companion object's current selection as request context. */
+export const useSelectionContext = (
+  companionTo: Obj.Unknown | undefined,
+): (() => ProcessorRequestContext | undefined) => {
+  // getAll-style lookup: absent capabilities yield empty arrays so non-companion chats stay inert.
+  const [viewState] = useCapabilities(AttentionCapabilities.ViewState);
+  const resolvers = useCapabilities(AppCapabilities.AnchorResolver);
+
+  return useCallback(() => {
+    if (!companionTo || !viewState) {
+      return undefined;
+    }
+    const selection = viewState.get(Selection.aspect, Obj.getURI(companionTo));
+    return getSelectionContext({ object: companionTo, selection, resolvers });
+  }, [companionTo, viewState, resolvers]);
+};

package/src/hooks/useSkillRegistry.ts

@@ -7,7 +7,7 @@ import { useCallback, useEffect, useMemo, useState } from 'react';
 import { type AiContext } from '@dxos/assistant';
 import { Skill } from '@dxos/compute';
 import { type Database, Filter, Obj, Ref, type Registry } from '@dxos/echo';
-import { useQuery } from '@dxos/react-client/echo';
+import { useQuery } from '@dxos/echo-react';
 import { distinctBy } from '@dxos/util';
 
 export const useSkills = ({ registry, db }: { registry?: Registry.Registry; db?: Database.Database }) => {

package/src/hooks/useTraceMessages.ts

@@ -8,8 +8,8 @@ import { pipe } from 'effect/Function';
 import { useMemo } from 'react';
 
 import { Trace } from '@dxos/compute';
+import { FeedTraceSink } from '@dxos/compute-runtime';
 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);
@@ -22,10 +22,12 @@ export const getTraceMessagesAtom = (space: Space): Atom.Atom<readonly Trace.Mes
     space.db.query(FeedTraceSink.query).atom,
     Atom.map(
       (feeds) =>
-        // TODO(dmaretskyi): Single query with limit(1) and feed traversal when query supports it.
+        // Query across ALL trace feeds: writers race on feed creation (the edge's indexer-backed
+        // lookup can miss a not-yet-indexed feed and create a duplicate), so a space may hold
+        // several trace feeds — reading only one would silently drop the others' events.
         space.db.query(
           feeds.length > 0
-            ? Query.type(Trace.Message).from(feeds[0])
+            ? Query.type(Trace.Message).from([...feeds])
             : (Query.select(Filter.nothing()) as Query.Query<never>),
         ).atom,
     ),

package/src/operations/create-chat.ts

@@ -17,13 +17,13 @@ import { AssistantOperation } from '#types';
 
 const handler: Operation.WithHandler<typeof AssistantOperation.CreateChat> = AssistantOperation.CreateChat.pipe(
   Operation.withHandler(
-    Effect.fnUntraced(function* ({ db, name, addToSpace = true }) {
+    Effect.fnUntraced(function* ({ db, name, instructions, addToSpace = true }) {
       const registry = yield* Capability.get(Capabilities.AtomRegistry);
       const client = yield* Capability.get(ClientCapabilities.Client);
       const space = client.spaces.get(db.spaceId);
       invariant(space, 'Space not found');
       const feed = space.db.add(Feed.make());
-      const chat = Chat.make({ name, feed: Ref.make(feed) });
+      const chat = Chat.make({ name, feed: Ref.make(feed), instructions });
       Obj.setParent(feed, chat);
       if (addToSpace) {
         space.db.add(chat);

package/src/operations/fork-chat.ts

@@ -5,7 +5,7 @@
 import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
-import { LayoutOperation, Paths } from '@dxos/app-toolkit';
+import { GraphPath, LayoutOperation } from '@dxos/app-toolkit';
 import { AiContext, SessionLink } from '@dxos/assistant';
 import { Chat } from '@dxos/assistant-toolkit';
 import { Operation } from '@dxos/compute';
@@ -95,7 +95,7 @@ const handler: Operation.WithHandler<typeof AssistantOperation.ForkChat> = Assis
         );
       } else {
         // Navigate to the forked chat as a standalone plank.
-        const chatPath = Paths.getObjectPathFromObject(newChat);
+        const chatPath = GraphPath.getObjectPathFromObject(newChat);
         yield* Operation.invoke(LayoutOperation.Open, { subject: [chatPath] });
       }
 

package/src/operations/generate-home-suggestions.test.ts

@@ -2,16 +2,16 @@
 // Copyright 2026 DXOS.org
 //
 
-import { Atom, Registry } from '@effect-atom/atom-react';
+import { Atom, Registry } from '@effect-atom/atom';
 import { describe, expect, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
+import { AssistantTestLayer } from '@dxos/agent-runtime/testing';
 import { Capabilities, Capability, CapabilityManager } from '@dxos/app-framework';
 import { Operation } from '@dxos/compute';
 import { Database } from '@dxos/echo';
 import { TestHelpers } from '@dxos/effect/testing';
-import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 import { EntityId } from '@dxos/keys';
 
 import { AssistantCapabilities, AssistantOperation } from '#types';

package/src/operations/index.ts

@@ -9,7 +9,6 @@ export const AssistantOperationHandlerSet = OperationHandlerSet.lazy(
   () => import('./ensure-companion-chat'),
   () => import('./fork-chat'),
   () => import('./generate-home-suggestions'),
-  () => import('./resolve-navigation-targets'),
   () => import('./run-prompt-in-new-chat'),
   () => import('./set-current-chat'),
   () => import('./toggle-trace-panel-debug'),

package/src/operations/prompt.node.test.ts

@@ -27,7 +27,7 @@ describe('Agent prompt (composer plugin harness)', () => {
   // Requires reachable edge AI (see repo DX_EDGE_AI_SERVICE_URL); not memoized like AssistantTestLayer tests.
   test(
     'chat mode appends assistant messages to the chat queue',
-    { tags: ['llm'], timeout: 60_000 },
+    { tags: ['manual'], timeout: 60_000 },
     async ({ expect }) => {
       await using harness = await createComposerTestApp({
         plugins: [ClientPlugin({}), AssistantPlugin(), RoutinePlugin()],

package/src/paths.ts

@@ -2,11 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Paths } from '@dxos/app-toolkit';
+import { GraphPath } from '@dxos/app-toolkit';
 import { Chat } from '@dxos/assistant-toolkit';
 
-const { getSectionPath: getChatsPath, getObjectPath: getChatPath } = Paths.createTypeSectionPaths(Chat.Chat, {
-  groupId: Paths.GroupSegments.ai,
+const { getSectionPath: getChatsPath, getObjectPath: getChatPath } = GraphPath.createTypeSectionPaths(Chat.Chat, {
+  groupId: GraphPath.GroupSegments.ai,
 });
 
 export { getChatPath, getChatsPath };

package/src/processor/index.ts

@@ -4,3 +4,4 @@
 
 export * from './presets';
 export * from './processor';
+export * from './prompt';

package/src/processor/processor.node.test.ts

@@ -10,6 +10,7 @@ import * as ManagedRuntime from 'effect/ManagedRuntime';
 import * as Option from 'effect/Option';
 import { test } from 'vitest';
 
+import { AssistantTestLayer } from '@dxos/agent-runtime/testing';
 import { Capabilities } from '@dxos/app-framework';
 import { AiSession } from '@dxos/assistant';
 import { Chat } from '@dxos/assistant-toolkit';
@@ -17,7 +18,6 @@ import { Database, Feed } from '@dxos/echo';
 import { UsageQuotaExceededError } from '@dxos/edge-client';
 import { EffectEx } from '@dxos/effect';
 import { TestHelpers } from '@dxos/effect/testing';
-import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 
 import { AiChatProcessor, AiUsageQuotaError, parseError } from './processor';