@dxos/plugin-assistant 0.8.4-main.422d1c7879 → 0.8.4-main.43cb759274

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

@@ -8,21 +8,21 @@ import * as Option from 'effect/Option';
 
 import { Capability } from '@dxos/app-framework';
 import { AppCapabilities, AppNode, getActiveSpace, getPersonalSpace } from '@dxos/app-toolkit';
-import { Chat } from '@dxos/assistant-toolkit';
-import { Blueprint, Prompt } from '@dxos/blueprints';
+import { AgentPrompt, Chat } from '@dxos/assistant-toolkit';
+import { Blueprint, Operation, Routine } 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 } from '@dxos/operation';
-import { AutomationCapabilities } from '@dxos/plugin-automation/types';
-import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { ClientCapabilities } from '@dxos/plugin-client';
 import { GraphBuilder, Node, NodeMatcher } from '@dxos/plugin-graph';
 import { linkedSegment } from '@dxos/react-ui-attention';
 
 import { ASSISTANT_COMPANION_VARIANT, meta } from '#meta';
-import { AssistantOperation } from '#operations';
-import { AssistantCapabilities } from '#types';
+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(
@@ -45,11 +45,9 @@ export default Capability.makeModule(
               data: () =>
                 Effect.gen(function* () {
                   // TODO(dmaretskyi): This goes away when composer will have unified operation invocations.
-                  const computeRuntime = yield* Capability.get(AutomationCapabilities.ComputeRuntime);
                   const db = Obj.getDatabase(chat);
                   invariant(db);
-                  const runtime = yield* computeRuntime.getRuntime(db.spaceId).runtimeEffect;
-                  yield* Operation.invoke(AssistantOperation.UpdateChatName, { chat }).pipe(Effect.provide(runtime));
+                  yield* Operation.invoke(AssistantOperation.UpdateChatName, { chat }, { spaceId: db.spaceId });
                 }),
               properties: {
                 label: ['chat-update-name.label', { ns: meta.id }],
@@ -67,7 +65,44 @@ export default Capability.makeModule(
         actions: () =>
           Effect.succeed([
             Node.makeAction({
-              id: 'reset-blueprints',
+              id: 'importComputeOperations',
+              data: Effect.fnUntraced(function* () {
+                const capabilities = yield* Capability.Service;
+                const client = yield* Capability.get(ClientCapabilities.Client);
+                const space = getActiveSpace(client, capabilities) ?? getPersonalSpace(client);
+                if (!space) {
+                  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* Database.flush();
+              }),
+              properties: {
+                label: ['import-compute-operations.label', { ns: meta.id }],
+                icon: 'ph--download-simple--regular',
+              },
+            }),
+            Node.makeAction({
+              id: AssistantOperation.ToggleTracePanelDebug.meta.key,
+              data: () => Operation.invoke(AssistantOperation.ToggleTracePanelDebug, {}),
+              properties: {
+                label: ['toggle-trace-panel-debug.label', { ns: meta.id }],
+                icon: 'ph--brackets-curly--regular',
+              },
+            }),
+            Node.makeAction({
+              id: 'resetBlueprints',
               data: Effect.fnUntraced(function* () {
                 const capabilities = yield* Capability.Service;
                 const client = yield* Capability.get(ClientCapabilities.Client);
@@ -93,22 +128,22 @@ export default Capability.makeModule(
 
       // Don't show assistant companion when a chat is already the primary object.
       GraphBuilder.createExtension({
-        id: 'companion-chat',
+        id: 'companionChat',
         match: whenNonChatObject,
         connector: (object, get) =>
           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 objectUri = Obj.getURI(object);
 
             // Resolve chat from persisted state or transient cache.
             const chat = pipe(
-              Option.fromNullable(state.currentChat[objectDxn]),
-              Option.flatMap((dxnStr) => Option.fromNullable(DXN.tryParse(dxnStr))),
+              Option.fromNullable(state.currentChat[objectUri]),
+              Option.flatMap((dxnStr) => Option.fromNullable(DXN.tryMake(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[objectUri]), Option.filter(Obj.isObject))),
               Option.getOrNull,
             );
 
@@ -118,7 +153,7 @@ export default Capability.makeModule(
                 label: ['assistant-chat.label', { ns: meta.id }],
                 icon: 'ph--sparkle--regular',
                 data: chat,
-                position: 'hoist',
+                position: 'first',
               }),
             ];
           }),
@@ -127,8 +162,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([
@@ -151,7 +186,7 @@ export default Capability.makeModule(
               label: ['trace.label', { ns: meta.id }],
               icon: 'ph--line-segments--regular',
               data: 'trace' as const,
-              position: 'fallback',
+              position: 'last',
             }),
           ]),
       }),

package/src/capabilities/blueprint-definition.ts

@@ -18,14 +18,14 @@ import {
   DatabaseBlueprint,
   DatabaseHandlers,
   DiscordBlueprint,
-  EntityExtractionHandlers,
   LinearBlueprint,
   PlanningBlueprint,
-  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,7 +35,6 @@ 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),
@@ -50,7 +49,6 @@ const blueprintDefinition: () => Effect.Effect<Capability.Capability<unknown>[]>
     Capability.contributes(Capabilities.OperationHandler, AgentBlueprintHandlers),
     Capability.contributes(Capabilities.OperationHandler, BlueprintManagerHandlers),
     Capability.contributes(Capabilities.OperationHandler, DatabaseHandlers),
-    Capability.contributes(Capabilities.OperationHandler, EntityExtractionHandlers),
     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 companionUri = Obj.getURI(object);
       const cache = registry.get(cacheAtom);
-      if (cache[companionDxn]) {
+      if (cache[companionUri]) {
         return true;
       }
 

package/src/capabilities/create-object.ts

@@ -0,0 +1,98 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { Capability, Capabilities } from '@dxos/app-framework';
+import { Agent, AgentBlueprint, Chat } from '@dxos/assistant-toolkit';
+import { Blueprint, Operation, Routine, ServiceResolver } from '@dxos/compute';
+import { Sequence } from '@dxos/conductor';
+import { Database, Feed, Obj, Type } from '@dxos/echo';
+import { SpaceCapabilities, SpaceOperation } from '@dxos/plugin-space';
+
+import { AssistantOperation } from '#types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return [
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Type.getTypename(Chat.Chat),
+        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: Type.getTypename(Blueprint.Blueprint),
+        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: Type.getTypename(Routine.Routine),
+        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: Type.getTypename(Sequence.Sequence),
+        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: Type.getTypename(Agent.Agent),
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = yield* Agent.makeInitialized({ name: '', instructions: '' }, AgentBlueprint.make());
+
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }).pipe(
+            Effect.provide(
+              ServiceResolver.provide({ space: options.db.spaceId }, Database.Service, Feed.FeedService).pipe(
+                Layer.provide(Capability.asLayer(Capabilities.ServiceResolver, ServiceResolver.ServiceResolver)),
+              ),
+            ),
+          ),
+      }),
+    ];
+  }),
+);

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

@@ -3,31 +3,67 @@
 //
 
 import * as AnthropicClient from '@effect/ai-anthropic/AnthropicClient';
-import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
 import { AnthropicResolver } from '@dxos/ai/resolvers';
 import { Capability } from '@dxos/app-framework';
 import { AppCapabilities } from '@dxos/app-toolkit';
+import { createEdgeIdentity } from '@dxos/client/edge';
+import { EdgeAiHttpClient, EdgeHttpClient } from '@dxos/edge-client';
+import { invariant } from '@dxos/invariant';
+import { ClientCapabilities } from '@dxos/plugin-client';
 
-export type EdgeModelResolverCapabilities = [Capability.Capability<typeof AppCapabilities.AiModelResolver>];
+// Named alias so the module's inferred type stays portable (avoids TS2883 leaking the internal
+// `@dxos/ai/AiModelResolver` Layer type into the emitted declarations).
+export type EdgeModelResolverCapabilities = Capability.Capability<typeof AppCapabilities.AiModelResolver>[];
 
-const edgeModelResolver = Capability.makeModule<[], EdgeModelResolverCapabilities>(() =>
-  Effect.succeed([
-    Capability.contributes(
+const edgeModelResolver = Capability.makeModule<[], EdgeModelResolverCapabilities>(
+  Effect.fnUntraced(function* () {
+    const manager = yield* Capability.Service;
+
+    // The authenticated EDGE client is resolved lazily on the first AI request. AI providers are
+    // set up before the Client capability and user identity exist (the startup cascade activates
+    // this module before `ClientReady`), so requiring the Client here would throw — or deadlock
+    // if we blocked on it. `EdgeAiHttpClient` invokes this thunk per request, by which point the
+    // Client is available.
+    let edgeClient: EdgeHttpClient | undefined;
+    let identitySubscription: { unsubscribe: () => void } | undefined;
+    const getEdgeClient = (): EdgeHttpClient => {
+      if (!edgeClient) {
+        const [client] = manager.getAll(ClientCapabilities.Client);
+        invariant(client, 'Client capability is required for edge AI requests.');
+        const edgeUrl = client.config.values.runtime?.services?.edge?.url;
+        invariant(edgeUrl, 'EDGE services are not configured.');
+        const created = new EdgeHttpClient(edgeUrl);
+        const updateIdentity = () => {
+          if (client.halo.identity.get()) {
+            created.setIdentity(createEdgeIdentity(client));
+          }
+        };
+        updateIdentity();
+        identitySubscription = client.halo.identity.subscribe(updateIdentity);
+        edgeClient = created;
+      }
+      return edgeClient;
+    };
+
+    const contribution: Capability.Capability<typeof AppCapabilities.AiModelResolver> = Capability.contributes(
       AppCapabilities.AiModelResolver,
       AnthropicResolver.make().pipe(
         Layer.provide(
           AnthropicClient.layer({
-            // TODO(dmaretskyi): Read endpoint from config/settings.
-            apiUrl: 'https://ai-service.dxos.workers.dev/provider/anthropic',
-          }),
+            // Host-only sentinel; `EdgeAiHttpClient` re-bases the request onto the EDGE
+            // `/ai/generate/anthropic` route and signs it with the verifiable presentation.
+            apiUrl: 'http://edge.internal',
+          }).pipe(Layer.provide(EdgeAiHttpClient.layer(getEdgeClient))),
         ),
-        Layer.provide(FetchHttpClient.layer),
       ),
-    ),
-  ]),
+      () => Effect.sync(() => identitySubscription?.unsubscribe()),
+    );
+
+    return [contribution];
+  }),
 );
 
 export default edgeModelResolver;

package/src/capabilities/index.ts

@@ -3,15 +3,23 @@
 //
 
 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'));
+import type { AssistantPluginOptions } from '#types';
+
+export const AiContext = Capability.lazy<void, Capability.Any[]>('AiContext', () => import('./ai-context'));
+export const AiService = Capability.lazy<AssistantPluginOptions | void, Capability.Any[]>(
+  'AiService',
+  () => import('./ai-service'),
+);
 export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));
 export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));
 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/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,27 +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.ResearchGraphV1,
-    transform: identityTransform,
-    onMigration: noopCallback,
-  }),
-  ...ResearchGraph.migrations,
 ];
 
 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, { type ComponentProps } 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, Agent } 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 { 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,
   AgentArticle,
   AgentProperties,
-  PromptArticle,
-  PromptList,
+  PlanArticle,
+  RoutineArticle,
+  RoutineList,
   TracePanel,
   TriggerStatus,
 } from '#containers';
@@ -36,7 +38,7 @@ export default Capability.makeModule(() =>
   Effect.succeed(
     Capability.contributes(Capabilities.ReactSurface, [
       Surface.create({
-        id: 'plugin-settings',
+        id: 'pluginSettings',
         filter: AppSurface.settings(AppSurface.Article, meta.id),
         component: ({ data: { subject } }) => {
           const { settings, updateSettings } = useSettingsState<Assistant.Settings>(subject.atom);
@@ -51,7 +53,7 @@ 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({
@@ -62,12 +64,12 @@ export default Capability.makeModule(() =>
         ),
       }),
       Surface.create({
-        id: 'agent-properties',
+        id: 'agentProperties',
         filter: AppSurface.object(AppSurface.ObjectProperties, Agent.Agent),
         component: ({ data }) => <AgentProperties subject={data.subject} />,
       }),
       Surface.create({
-        id: 'companion-chat',
+        id: 'companionChat',
         role: 'article',
         filter: (data): data is { subject: Chat.Chat | null; attendableId: string; companionTo: Obj.Unknown } =>
           typeof data.attendableId === 'string' &&
@@ -84,22 +86,22 @@ export default Capability.makeModule(() =>
         ),
       }),
       Surface.create({
-        id: 'companion-invocations',
+        id: 'companionInvocations',
         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 feed = space?.properties.invocationTraceFeed?.target;
-          const queueDxn = feed ? Feed.getQueueDxn(feed) : undefined;
+          const feedDXN = feed ? Feed.getQueueUri(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>
           );
@@ -114,9 +116,16 @@ export default Capability.makeModule(() =>
       }),
       Surface.create({
         id: 'prompt',
-        filter: AppSurface.object(AppSurface.Article, 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({
@@ -129,6 +138,10 @@ export default Capability.makeModule(() =>
         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;
           }
@@ -137,7 +150,7 @@ export default Capability.makeModule(() =>
         },
       }),
       Surface.create({
-        id: 'status',
+        id: 'triggerStatus',
         role: 'status-indicator',
         component: () => {
           const space = useActiveSpace();
@@ -154,7 +167,7 @@ export default Capability.makeModule(() =>
           Surface.makeType<{ subject: Obj.Any; attendableId: string }>('prompts'),
           Obj.isObject,
         ),
-        component: ({ data }) => <PromptList subject={data.subject} />,
+        component: ({ data }) => <RoutineList subject={data.subject} />,
       }),
     ]),
   ),