@dxos/plugin-assistant 0.8.4-main.74a063c4e0 → 0.8.4-main.765dc60934

package/src/capabilities/app-graph-builder.ts

@@ -6,25 +6,24 @@ import * as Effect from 'effect/Effect';
 import { pipe } from 'effect/Function';
 import * as Option from 'effect/Option';
 
-import { Capabilities, Capability } from '@dxos/app-framework';
-import { AppCapabilities, AppNode, getActiveSpace, getPersonalSpace, LayoutOperation } from '@dxos/app-toolkit';
-import { Chat } from '@dxos/assistant-toolkit';
-import { Blueprint, Prompt } from '@dxos/blueprints';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities, AppNode, getActiveSpace, getPersonalSpace } from '@dxos/app-toolkit';
+import { AgentPrompt, Chat } from '@dxos/assistant-toolkit';
+import { Blueprint, Routine, Operation } from '@dxos/compute';
 import { Sequence } from '@dxos/conductor';
 import { DXN, Database, Filter, Obj, type Ref } from '@dxos/echo';
 import { AtomObj } from '@dxos/echo-atom';
 import { invariant } from '@dxos/invariant';
-import { Operation, type OperationInvoker } from '@dxos/operation';
-import { AutomationCapabilities } from '@dxos/plugin-automation/types';
-import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { AutomationCapabilities } from '@dxos/plugin-automation';
+import { ClientCapabilities } from '@dxos/plugin-client';
 import { GraphBuilder, Node, NodeMatcher } from '@dxos/plugin-graph';
-import { SpaceOperation } from '@dxos/plugin-space/operations';
-import { Query } from '@dxos/react-client/echo';
 import { linkedSegment } from '@dxos/react-ui-attention';
 
-import { ASSISTANT_COMPANION_VARIANT, ASSISTANT_DIALOG, meta } from '#meta';
-import { AssistantOperation } from '#operations';
-import { AssistantCapabilities } from '#types';
+import { ASSISTANT_COMPANION_VARIANT, meta } from '#meta';
+import { AssistantCapabilities, AssistantOperation } from '#types';
+
+/** Operation definitions to seed as `PersistentOperation` records for automation / triggers. */
+const computeOperationsToImport = [AgentPrompt] as const;
 
 /** Match ECHO objects that are NOT chats. */
 const whenNonChatObject = NodeMatcher.whenAll(
@@ -69,36 +68,32 @@ export default Capability.makeModule(
         actions: () =>
           Effect.succeed([
             Node.makeAction({
-              id: `${LayoutOperation.UpdateDialog.meta.key}.assistant.open`,
+              id: 'import-compute-operations',
               data: Effect.fnUntraced(function* () {
                 const capabilities = yield* Capability.Service;
                 const client = yield* Capability.get(ClientCapabilities.Client);
-                const operationInvoker = yield* Capability.get(Capabilities.OperationInvoker);
                 const space = getActiveSpace(client, capabilities) ?? getPersonalSpace(client);
                 if (!space) {
                   return;
                 }
-                const chat = yield* Effect.tryPromise(() => getOrCreateChat(operationInvoker.invokePromise, space.db));
-                if (!chat) {
-                  return;
+                for (const definition of computeOperationsToImport) {
+                  const key = definition.meta.key;
+                  if (!key) {
+                    continue;
+                  }
+                  const existing = yield* Effect.promise(
+                    (): Promise<Operation.PersistentOperation[]> =>
+                      space.db.query(Filter.and(Filter.type(Operation.PersistentOperation), Filter.key(key))).run(),
+                  );
+                  if (existing.length === 0) {
+                    space.db.add(Operation.serialize(definition));
+                  }
                 }
-
-                yield* Operation.invoke(LayoutOperation.UpdateDialog, {
-                  subject: ASSISTANT_DIALOG,
-                  state: true,
-                  blockAlign: 'end',
-                  props: { chat },
-                });
+                yield* Database.flush();
               }),
               properties: {
-                label: ['open-assistant.label', { ns: meta.id }],
-                icon: 'ph--sparkle--regular',
-                disposition: 'pin-end',
-                position: 'hoist',
-                keyBinding: {
-                  macos: 'shift+meta+k',
-                  windows: 'shift+ctrl+k',
-                },
+                label: ['import-compute-operations.label', { ns: meta.id }],
+                icon: 'ph--download-simple--regular',
               },
             }),
             Node.makeAction({
@@ -134,16 +129,16 @@ export default Capability.makeModule(
           Effect.gen(function* () {
             const state = get(yield* Capability.get(AssistantCapabilities.State));
             const cache = get(yield* Capability.get(AssistantCapabilities.CompanionChatCache));
-            const objectDxn = Obj.getDXN(object).toString();
+            const objectDXN = Obj.getDXN(object).toString();
 
             // Resolve chat from persisted state or transient cache.
             const chat = pipe(
-              Option.fromNullable(state.currentChat[objectDxn]),
+              Option.fromNullable(state.currentChat[objectDXN]),
               Option.flatMap((dxnStr) => Option.fromNullable(DXN.tryParse(dxnStr))),
               Option.flatMap((dxn) => Option.fromNullable(Obj.getDatabase(object)?.makeRef(dxn))),
               Option.map((ref) => get(AtomObj.make(ref as Ref.Ref<Obj.Unknown>))),
               Option.filter(Obj.isObject),
-              Option.orElse(() => pipe(Option.fromNullable(cache[objectDxn]), Option.filter(Obj.isObject))),
+              Option.orElse(() => pipe(Option.fromNullable(cache[objectDXN]), Option.filter(Obj.isObject))),
               Option.getOrNull,
             );
 
@@ -162,8 +157,8 @@ export default Capability.makeModule(
       GraphBuilder.createExtension({
         id: 'invocations',
         match: NodeMatcher.whenAny(
-          NodeMatcher.whenEchoTypeMatches(Sequence),
-          NodeMatcher.whenEchoTypeMatches(Prompt.Prompt),
+          NodeMatcher.whenEchoTypeMatches(Sequence.Sequence),
+          NodeMatcher.whenEchoTypeMatches(Routine.Routine),
         ),
         connector: () =>
           Effect.succeed([
@@ -195,23 +190,3 @@ export default Capability.makeModule(
     return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions);
   }),
 );
-
-// TODO(burdon): Factor out.
-const getOrCreateChat = async (
-  invokePromise: OperationInvoker.OperationInvoker['invokePromise'],
-  db: Database.Database,
-): Promise<Chat.Chat | undefined> => {
-  // TODO(wittjosiah): This should be possible with a single query.
-  const allChats = await db.query(Query.type(Chat.Chat)).run();
-  const relatedChats = await db.query(Query.type(Chat.Chat).sourceOf(Chat.CompanionTo).source()).run();
-
-  const chats = allChats.filter((chat) => !relatedChats.includes(chat));
-  if (chats.length > 0) {
-    return chats.at(-1);
-  }
-
-  const { data } = await invokePromise(AssistantOperation.CreateChat, { db });
-  invariant(Obj.instanceOf(Chat.Chat, data?.object));
-  await invokePromise(SpaceOperation.AddObject, { target: db, object: data.object });
-  return data.object;
-};

package/src/capabilities/blueprint-definition.ts

@@ -7,25 +7,25 @@ import * as Effect from 'effect/Effect';
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { AppCapabilities } from '@dxos/app-toolkit';
 import {
+  AgentBlueprint,
+  AgentBlueprintHandlers,
   AgentHandlers,
+  AgentWizardBlueprint,
+  AgentWizardHandlers,
   BlueprintManagerBlueprint,
   BlueprintManagerHandlers,
   BrowserBlueprint,
   DatabaseBlueprint,
   DatabaseHandlers,
   DiscordBlueprint,
-  EntityExtractionHandlers,
   LinearBlueprint,
   PlanningBlueprint,
-  ProjectBlueprint,
-  ProjectHandlers,
-  ProjectWizardBlueprint,
-  ProjectWizardHandlers,
-  ResearchBlueprint,
   WebSearchBlueprint,
   MemoryBlueprint,
   AutomationBlueprint,
 } from '@dxos/assistant-toolkit';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Blueprint } from '@dxos/compute';
 
 import { AssistantBlueprint } from '#blueprints';
 
@@ -35,23 +35,21 @@ const blueprintDefinition: () => Effect.Effect<Capability.Capability<unknown>[]>
     Capability.contributes(AppCapabilities.BlueprintDefinition, AssistantBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, BrowserBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, DatabaseBlueprint),
-    Capability.contributes(AppCapabilities.BlueprintDefinition, ResearchBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, WebSearchBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, DiscordBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, LinearBlueprint),
-    Capability.contributes(AppCapabilities.BlueprintDefinition, ProjectBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, AgentBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, PlanningBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, MemoryBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, AutomationBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, BlueprintManagerBlueprint),
-    Capability.contributes(AppCapabilities.BlueprintDefinition, ProjectWizardBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, AgentWizardBlueprint),
 
     Capability.contributes(Capabilities.OperationHandler, AgentHandlers),
+    Capability.contributes(Capabilities.OperationHandler, AgentBlueprintHandlers),
     Capability.contributes(Capabilities.OperationHandler, BlueprintManagerHandlers),
     Capability.contributes(Capabilities.OperationHandler, DatabaseHandlers),
-    Capability.contributes(Capabilities.OperationHandler, EntityExtractionHandlers),
-    Capability.contributes(Capabilities.OperationHandler, ProjectHandlers),
-    Capability.contributes(Capabilities.OperationHandler, ProjectWizardHandlers),
+    Capability.contributes(Capabilities.OperationHandler, AgentWizardHandlers),
   ]),
 );
 

package/src/capabilities/companion-chat-provisioner.ts

@@ -12,13 +12,12 @@ import { AppCapabilities } from '@dxos/app-toolkit';
 import { Chat } from '@dxos/assistant-toolkit';
 import { Obj } from '@dxos/echo';
 import { log } from '@dxos/log';
-import { DeckCapabilities, PLANK_COMPANION_TYPE, type StoredDeckState } from '@dxos/plugin-deck/types';
+import { DeckCapabilities, PLANK_COMPANION_TYPE, type StoredDeckState } from '@dxos/plugin-deck';
 import { getLinkedVariant } from '@dxos/react-ui-attention';
 import { byPosition } from '@dxos/util';
 
 import { ASSISTANT_COMPANION_VARIANT } from '#meta';
-import { AssistantOperation } from '#operations';
-import { AssistantCapabilities } from '#types';
+import { AssistantCapabilities, AssistantOperation } from '#types';
 
 /**
  * Non-React capability that watches deck companion state and provisions transient chats
@@ -65,9 +64,9 @@ export default Capability.makeModule(
       }
 
       const object = node.data;
-      const companionDxn = Obj.getDXN(object).toString();
+      const companionDXN = Obj.getDXN(object).toString();
       const cache = registry.get(cacheAtom);
-      if (cache[companionDxn]) {
+      if (cache[companionDXN]) {
         return true;
       }
 

package/src/capabilities/create-object.ts

@@ -0,0 +1,107 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Agent, AgentBlueprint, Chat } from '@dxos/assistant-toolkit';
+import { Blueprint, Operation, Routine } from '@dxos/compute';
+import { Sequence } from '@dxos/conductor';
+import { Obj } from '@dxos/echo';
+import { type SpaceId } from '@dxos/keys';
+import { AutomationCapabilities } from '@dxos/plugin-automation';
+import { SpaceOperation } from '@dxos/plugin-space';
+import { SpaceCapabilities } from '@dxos/plugin-space';
+
+import { AssistantOperation } from '#types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return [
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Chat.Chat.typename,
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const { object } = yield* Operation.invoke(AssistantOperation.CreateChat, {
+              db: options.db,
+              name: props?.name,
+            });
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Blueprint.Blueprint.typename,
+        inputSchema: AssistantOperation.BlueprintForm,
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Blueprint.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Routine.Routine.typename,
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Routine.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Sequence.Sequence.typename,
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Obj.make(Sequence.Sequence, props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Agent.Agent.typename,
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = yield* Agent.makeInitialized({ name: '', instructions: '' }, AgentBlueprint.make()).pipe(
+              withComputeRuntime(options.db.spaceId),
+            );
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+    ];
+  }),
+);
+
+// TODO(dmaretskyi): Extract to a helper module.
+const withComputeRuntime =
+  (spaceId: SpaceId) =>
+  <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+  ): Effect.Effect<A, E, Exclude<R, AutomationCapabilities.ComputeServices> | Capability.Service> =>
+    Effect.gen(function* () {
+      const provider = yield* Capability.get(AutomationCapabilities.ComputeRuntime).pipe(Effect.orDie);
+      const runtime = yield* provider.getRuntime(spaceId).runtimeEffect;
+      return yield* effect.pipe(Effect.provide(runtime));
+    });

package/src/capabilities/index.ts

@@ -3,7 +3,8 @@
 //
 
 import { Capability } from '@dxos/app-framework';
-import { OperationHandlerSet } from '@dxos/operation';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Blueprint, OperationHandlerSet } from '@dxos/compute';
 
 export const AiService = Capability.lazy('AiService', () => import('./ai-service'));
 export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));
@@ -12,6 +13,7 @@ export const CompanionChatProvisioner = Capability.lazy(
   'CompanionChatProvisioner',
   () => import('./companion-chat-provisioner'),
 );
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
 export const EdgeModelResolver = Capability.lazy('EdgeModelResolver', () => import('./edge-model-resolver'));
 export const LocalModelResolver = Capability.lazy('LocalModelResolver', () => import('./local-model-resolver'));
 export const MarkdownExtension = Capability.lazy('MarkdownExtension', () => import('./markdown'));

package/src/capabilities/local-model-resolver.ts

@@ -4,22 +4,26 @@
 
 import * as OpenAiClient from '@effect/ai-openai/OpenAiClient';
 import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
+import * as HttpClient from '@effect/platform/HttpClient';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import { LMStudioResolver } from '@dxos/ai/resolvers';
+import { LMStudioResolver, OllamaResolver } from '@dxos/ai/resolvers';
 import { Capability } from '@dxos/app-framework';
 import { AppCapabilities } from '@dxos/app-toolkit';
 
-export type LocalModelResolverCapabilities = [Capability.Capability<typeof AppCapabilities.AiModelResolver>];
-
 /**
  * To start LM Studio server:
  * ```bash
  * ~/.lmstudio/bin/lms server start --cors
  * ```
+ *
+ * To start Ollama server:
+ * ```bash
+ * OLLAMA_ORIGINS="*" ollama serve
+ * ```
  */
-const localModelResolver = Capability.makeModule<[], LocalModelResolverCapabilities>(() =>
+const localModelResolver = Capability.makeModule<[]>(() =>
   Effect.succeed([
     Capability.contributes(
       AppCapabilities.AiModelResolver,
@@ -32,6 +36,12 @@ const localModelResolver = Capability.makeModule<[], LocalModelResolverCapabilit
         Layer.provide(FetchHttpClient.layer),
       ),
     ),
+    Capability.contributes(
+      AppCapabilities.AiModelResolver,
+      OllamaResolver.make({
+        transformClient: HttpClient.withTracerPropagation(false),
+      }).pipe(Layer.provide(FetchHttpClient.layer)),
+    ),
   ]),
 );
 

package/src/capabilities/markdown.ts

@@ -8,7 +8,7 @@ import { Capabilities, Capability } from '@dxos/app-framework';
 import { Obj } from '@dxos/echo';
 import { MarkdownCapabilities } from '@dxos/plugin-markdown';
 
-import { AssistantOperation } from '#operations';
+import { AssistantOperation } from '#types';
 
 import { promptRunExtension } from '../extensions';
 

package/src/capabilities/migrations.ts

@@ -5,26 +5,20 @@
 import * as Effect from 'effect/Effect';
 
 import { Capability } from '@dxos/app-framework';
-import { Chat, ResearchGraph } from '@dxos/assistant-toolkit';
-import { defineObjectMigration } from '@dxos/client/echo';
-import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { Chat } from '@dxos/assistant-toolkit';
+import { Migration } from '@dxos/echo';
+import { ClientCapabilities } from '@dxos/plugin-client';
 
 const identityTransform = async (from: any) => ({ ...from });
 const noopCallback = async () => {};
 
 const migrations = [
-  defineObjectMigration({
+  Migration.define({
     from: Chat.LegacyCompanionTo,
     to: Chat.CompanionTo,
     transform: identityTransform,
     onMigration: noopCallback,
   }),
-  defineObjectMigration({
-    from: ResearchGraph.LegacyResearchGraph,
-    to: ResearchGraph.ResearchGraph,
-    transform: identityTransform,
-    onMigration: noopCallback,
-  }),
 ];
 
 export default Capability.makeModule(

package/src/capabilities/operation-handler.ts

@@ -5,7 +5,7 @@
 import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
-import type { OperationHandlerSet } from '@dxos/operation';
+import type { OperationHandlerSet } from '@dxos/compute';
 
 import { AssistantOperationHandlerSet } from '#operations';
 

package/src/capabilities/react-surface.tsx

@@ -3,29 +3,31 @@
 //
 
 import * as Effect from 'effect/Effect';
-import React from 'react';
+import React, { type ComponentProps, useEffect } from 'react';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { Surface, useSettingsState } from '@dxos/app-framework/ui';
 import { AppSurface, useActiveSpace } from '@dxos/app-toolkit/ui';
-import { Chat, Project } from '@dxos/assistant-toolkit';
-import { Blueprint, Prompt } from '@dxos/blueprints';
+import { Chat, Agent, Plan } from '@dxos/assistant-toolkit';
 import { getSpace } from '@dxos/client/echo';
+import { Blueprint, Routine } from '@dxos/compute';
 import { Sequence } from '@dxos/conductor';
 import { InvocationTraceContainer } from '@dxos/devtools';
-import { Obj } from '@dxos/echo';
+import { Feed, Obj } from '@dxos/echo';
+import { log } from '@dxos/log';
 import { Panel } from '@dxos/react-ui';
 
 import { AssistantSettings } from '#components';
 import {
   BlueprintArticle,
   ChatCompanion,
-  ChatContainer,
+  ChatArticle,
   ChatDialog,
-  ProjectArticle,
-  ProjectSettings,
-  PromptArticle,
-  PromptList,
+  AgentArticle,
+  AgentProperties,
+  PlanArticle,
+  RoutineArticle,
+  RoutineList,
   TracePanel,
   TriggerStatus,
 } from '#containers';
@@ -37,8 +39,7 @@ export default Capability.makeModule(() =>
     Capability.contributes(Capabilities.ReactSurface, [
       Surface.create({
         id: 'plugin-settings',
-        role: 'article',
-        filter: AppSurface.settingsArticle(meta.id),
+        filter: AppSurface.settings(AppSurface.Article, meta.id),
         component: ({ data: { subject } }) => {
           const { settings, updateSettings } = useSettingsState<Assistant.Settings>(subject.atom);
           return <AssistantSettings settings={settings} onSettingsChange={updateSettings} />;
@@ -52,22 +53,20 @@ export default Capability.makeModule(() =>
           Obj.instanceOf(Chat.Chat, data.subject) &&
           data.variant !== ASSISTANT_COMPANION_VARIANT,
         component: ({ data, role, ref }) => {
-          return <ChatContainer role={role} subject={data.subject} attendableId={data.attendableId} ref={ref} />;
+          return <ChatArticle role={role} subject={data.subject} attendableId={data.attendableId} ref={ref} />;
         },
       }),
       Surface.create({
-        id: 'project',
-        role: 'article',
-        filter: AppSurface.objectArticle(Project.Project),
+        id: 'agent',
+        filter: AppSurface.object(AppSurface.Article, Agent.Agent),
         component: ({ data, role }) => (
-          <ProjectArticle role={role} subject={data.subject} attendableId={data.attendableId} />
+          <AgentArticle role={role} subject={data.subject} attendableId={data.attendableId} />
         ),
       }),
       Surface.create({
-        id: 'project.companion.settings',
-        role: 'object-settings',
-        filter: AppSurface.objectSettings(Project.Project),
-        component: ({ data }) => <ProjectSettings subject={data.subject} />,
+        id: 'agent-properties',
+        filter: AppSurface.object(AppSurface.ObjectProperties, Agent.Agent),
+        component: ({ data }) => <AgentProperties subject={data.subject} />,
       }),
       Surface.create({
         id: 'companion-chat',
@@ -89,18 +88,20 @@ export default Capability.makeModule(() =>
       Surface.create({
         id: 'companion-invocations',
         role: 'article',
-        filter: (data): data is { companionTo: Sequence } =>
-          (Obj.instanceOf(Sequence, data.companionTo) || Obj.instanceOf(Prompt.Prompt, data.companionTo)) &&
+        filter: (data): data is { companionTo: Sequence.Sequence } =>
+          (Obj.instanceOf(Sequence.Sequence, data.companionTo) || Obj.instanceOf(Routine.Routine, data.companionTo)) &&
           data.subject === 'invocations',
         component: ({ data, role }) => {
           const space = getSpace(data.companionTo);
-          const queueDxn = space?.properties.invocationTraceQueue?.dxn;
+          const feed = space?.properties.invocationTraceFeed?.target;
+          const feedDXN = feed ? Feed.getQueueDxn(feed) : undefined;
           // TODO(wittjosiah): Support invocation filtering for prompts.
-          const target = Obj.instanceOf(Prompt.Prompt, data.companionTo) ? undefined : data.companionTo;
+          const target = Obj.instanceOf(Routine.Routine, data.companionTo) ? undefined : data.companionTo;
+
           return (
             <Panel.Root role={role} className='dx-document'>
               <Panel.Content asChild>
-                <InvocationTraceContainer db={space?.db} queueDxn={queueDxn} target={target} detailAxis='block' />
+                <InvocationTraceContainer db={space?.db} feedDXN={feedDXN} target={target} detailAxis='block' />
               </Panel.Content>
             </Panel.Root>
           );
@@ -108,34 +109,42 @@ export default Capability.makeModule(() =>
       }),
       Surface.create({
         id: 'blueprint',
-        role: 'article',
-        filter: AppSurface.objectArticle(Blueprint.Blueprint),
+        filter: AppSurface.object(AppSurface.Article, Blueprint.Blueprint),
         component: ({ data, role }) => (
           <BlueprintArticle role={role} subject={data.subject} attendableId={data.attendableId} />
         ),
       }),
       Surface.create({
         id: 'prompt',
-        role: 'article',
-        filter: AppSurface.objectArticle(Prompt.Prompt),
+        filter: AppSurface.object(AppSurface.Article, Routine.Routine),
         component: ({ data, role }) => (
-          <PromptArticle role={role} subject={data.subject} attendableId={data.attendableId} />
+          <RoutineArticle role={role} subject={data.subject} attendableId={data.attendableId} />
+        ),
+      }),
+      Surface.create({
+        id: 'plan',
+        filter: AppSurface.object(AppSurface.Article, Plan.Plan),
+        component: ({ data, role }) => (
+          <PlanArticle role={role} subject={data.subject} attendableId={data.attendableId} />
         ),
       }),
       Surface.create({
         id: ASSISTANT_DIALOG,
-        role: 'dialog',
-        filter: AppSurface.componentDialog(ASSISTANT_DIALOG),
+        filter: AppSurface.component<ComponentProps<typeof ChatDialog>>(AppSurface.Dialog, ASSISTANT_DIALOG),
         component: ({ data }) => <ChatDialog {...data.props} />,
       }),
       Surface.create({
         id: 'trace',
-        role: 'deck-companion--trace',
-        filter: AppSurface.literalSection('trace'),
+        filter: AppSurface.literal(Surface.makeType<{ subject: string }>('deck-companion--trace'), 'trace'),
         component: () => {
           const space = useActiveSpace();
+          useEffect(() => {
+            log('trace panel surface', { hasSpace: Boolean(space), spaceId: space?.id });
+          }, [space?.id]);
+
           if (!space) {
-            return null;
+            // TODO(dmaretskyi): Not really part of UX, but so we know what the error is.
+            return <span>No active space</span>;
           }
 
           return <TracePanel space={space} />;
@@ -144,13 +153,22 @@ export default Capability.makeModule(() =>
       Surface.create({
         id: 'status',
         role: 'status-indicator',
-        component: () => <TriggerStatus />,
+        component: () => {
+          const space = useActiveSpace();
+          if (!space) {
+            return null;
+          }
+
+          return <TriggerStatus role='status-indicator' space={space} />;
+        },
       }),
       Surface.create({
         id: 'prompts',
-        role: 'prompts',
-        filter: AppSurface.anyObjectSection(),
-        component: ({ data }) => <PromptList subject={data.subject} />,
+        filter: AppSurface.subject(
+          Surface.makeType<{ subject: Obj.Any; attendableId: string }>('prompts'),
+          Obj.isObject,
+        ),
+        component: ({ data }) => <RoutineList subject={data.subject} />,
       }),
     ]),
   ),

package/src/capabilities/toolkit.ts

@@ -6,8 +6,8 @@ import * as Effect from 'effect/Effect';
 
 import { Capability } from '@dxos/app-framework';
 import { AppCapabilities } from '@dxos/app-toolkit';
-import { WebSearchToolkitGeneric } from '@dxos/assistant-toolkit';
+import { WebSearchToolkitOpaque } from '@dxos/assistant-toolkit';
 
 export default Capability.makeModule(() =>
-  Effect.succeed([Capability.contributes(AppCapabilities.Toolkit, WebSearchToolkitGeneric)]),
+  Effect.succeed([Capability.contributes(AppCapabilities.Toolkit, WebSearchToolkitOpaque)]),
 );