@dxos/plugin-thread 0.8.4-main.1f223c7 → 0.8.4-main.2c6827d

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

@@ -2,18 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Rx } from '@effect-rx/rx-react';
-import { Option, pipe } from 'effect';
+import { Atom } from '@effect-atom/atom-react';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
 
 import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
 import { Obj } from '@dxos/echo';
 import { AttentionCapabilities } from '@dxos/plugin-attention';
 import { ATTENDABLE_PATH_SEPARATOR, DECK_COMPANION_TYPE, PLANK_COMPANION_TYPE } from '@dxos/plugin-deck/types';
-import { ROOT_ID, createExtension, rxFromSignal } from '@dxos/plugin-graph';
-import { fullyQualifiedId } from '@dxos/react-client/echo';
+import { ROOT_ID, atomFromSignal, createExtension } from '@dxos/plugin-graph';
 
-import { THREAD_PLUGIN, meta } from '../meta';
-import { ChannelType, ThreadAction } from '../types';
+import { meta } from '../meta';
+import { Channel, ThreadAction } from '../types';
 import { getAnchor } from '../util';
 
 import { ThreadCapabilities } from './capabilities';
@@ -26,16 +26,16 @@ export default (context: PluginContext) => {
 
   return contributes(Capabilities.AppGraphBuilder, [
     createExtension({
-      id: `${THREAD_PLUGIN}/active-call`,
+      id: `${meta.id}/active-call`,
       connector: (node) =>
-        Rx.make((get) =>
-          pipe(
+        Atom.make((get) =>
+          Function.pipe(
             get(node),
             Option.flatMap((node) => (node.id === ROOT_ID ? Option.some(node) : Option.none())),
             Option.map((node) => {
               const [call] = get(context.capabilities(ThreadCapabilities.CallManager));
               return get(
-                rxFromSignal(() =>
+                atomFromSignal(() =>
                   call?.joined
                     ? [
                         {
@@ -43,7 +43,7 @@ export default (context: PluginContext) => {
                           type: DECK_COMPANION_TYPE,
                           data: null,
                           properties: {
-                            label: ['call panel label', { ns: THREAD_PLUGIN }],
+                            label: ['call panel label', { ns: meta.id }],
                             icon: 'ph--video-conference--regular',
                             position: 'hoist',
                             disposition: 'hidden',
@@ -61,16 +61,18 @@ export default (context: PluginContext) => {
     // TODO(wittjosiah): The channel shouldn't become the companion during a call.
     //   Alternative: the call/meeting/thread should be a child node of the channel and that should be opened.
     createExtension({
-      id: `${THREAD_PLUGIN}/channel-chat-companion`,
+      id: `${meta.id}/channel-chat-companion`,
       connector: (node) => {
-        return Rx.make((get) => {
-          return pipe(
+        return Atom.make((get) => {
+          return Function.pipe(
             get(node),
-            Option.flatMap((node) => (Obj.instanceOf(ChannelType, node.data) ? Option.some(node.data) : Option.none())),
+            Option.flatMap((node) =>
+              Obj.instanceOf(Channel.Channel, node.data) ? Option.some(node.data) : Option.none(),
+            ),
             Option.map((channel) => {
               const callManager = context.getCapability(ThreadCapabilities.CallManager);
               const joined = get(
-                rxFromSignal(() => callManager.joined && callManager.roomId === fullyQualifiedId(channel)),
+                atomFromSignal(() => callManager.joined && callManager.roomId === Obj.getDXN(channel).toString()),
               );
               if (!joined) {
                 return [];
@@ -78,11 +80,11 @@ export default (context: PluginContext) => {
 
               return [
                 {
-                  id: `${fullyQualifiedId(channel)}${ATTENDABLE_PATH_SEPARATOR}chat`,
+                  id: `${Obj.getDXN(channel).toString()}${ATTENDABLE_PATH_SEPARATOR}chat`,
                   type: PLANK_COMPANION_TYPE,
                   data: 'chat',
                   properties: {
-                    label: ['channel companion label', { ns: THREAD_PLUGIN }],
+                    label: ['channel companion label', { ns: meta.id }],
                     icon: 'ph--hash--regular',
                     position: 'hoist',
                     disposition: 'hidden',
@@ -98,11 +100,11 @@ export default (context: PluginContext) => {
     createExtension({
       id: `${meta.id}/comments-companion`,
       connector: (node) =>
-        Rx.make((get) =>
-          pipe(
+        Atom.make((get) =>
+          Function.pipe(
             get(node),
             Option.flatMap((node) => {
-              if (!Obj.isObject(node.data) || Obj.instanceOf(ChannelType, node.data)) {
+              if (!Obj.isObject(node.data) || Obj.instanceOf(Channel.Channel, node.data)) {
                 return Option.none();
               }
               const metadata = resolve(Obj.getTypename(node.data)!);
@@ -128,11 +130,11 @@ export default (context: PluginContext) => {
     createExtension({
       id: `${meta.id}/comment-toolbar`,
       actions: (node) =>
-        Rx.make((get) =>
-          pipe(
+        Atom.make((get) =>
+          Function.pipe(
             get(node),
             Option.flatMap((node) => {
-              if (!Obj.isObject(node.data) || Obj.instanceOf(ChannelType, node.data)) {
+              if (!Obj.isObject(node.data) || Obj.instanceOf(Channel.Channel, node.data)) {
                 return Option.none();
               }
               const metadata = resolve(Obj.getTypename(node.data)!);
@@ -142,28 +144,37 @@ export default (context: PluginContext) => {
               const selectionManager = context.getCapability(AttentionCapabilities.Selection);
               const toolbar = get(context.capabilities(ThreadCapabilities.State))[0]?.state.toolbar ?? {};
               const disabled = get(
-                rxFromSignal(() => {
+                atomFromSignal(() => {
                   const metadata = resolve(Obj.getTypename(object)!);
-                  const selection = selectionManager.getSelection(fullyQualifiedId(object), metadata.selectionMode);
+                  const selection = selectionManager.getSelection(
+                    Obj.getDXN(object).toString(),
+                    metadata.selectionMode,
+                  );
                   const anchor = getAnchor(selection);
                   const invalidSelection = !anchor;
-                  const overlappingComment = toolbar[fullyQualifiedId(object)];
+                  const overlappingComment = toolbar[Obj.getDXN(object).toString()];
                   return (metadata.comments === 'anchored' && invalidSelection) || overlappingComment;
                 }),
               );
 
               return [
                 {
-                  id: `${fullyQualifiedId(object)}/comment`,
+                  id: `${Obj.getDXN(object).toString()}/comment`,
                   data: () => {
                     const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
                     const metadata = resolve(Obj.getTypename(object)!);
-                    const selection = selectionManager.getSelection(fullyQualifiedId(object));
+                    const selection = selectionManager.getSelection(Obj.getDXN(object).toString());
                     // TODO(wittjosiah): Use presence of selection to determine if the comment should be anchored.
                     // Requires all components which support selection (e.g. table/kanban) to support anchored comments.
                     const anchor = metadata.comments === 'anchored' ? getAnchor(selection) : Date.now().toString();
                     const name = metadata.getAnchorLabel?.(object, anchor);
-                    void dispatch(createIntent(ThreadAction.Create, { anchor, name, subject: object }));
+                    void dispatch(
+                      createIntent(ThreadAction.Create, {
+                        anchor,
+                        name,
+                        subject: object,
+                      }),
+                    );
                   },
                   properties: {
                     label: ['add comment label', { ns: meta.id }],

package/src/capabilities/blueprint-definition.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, type Capability, contributes } from '@dxos/app-framework';
+import { Blueprint, Template } from '@dxos/blueprints';
+import { type FunctionDefinition } from '@dxos/functions';
+import { trim } from '@dxos/util';
+
+import { createProposals } from '../functions';
+
+const functions: FunctionDefinition[] = [createProposals];
+
+export const ASSISTANT_BLUEPRINT_KEY = 'dxos.org/blueprint/thread';
+
+export default (): Capability<any>[] => [
+  contributes(Capabilities.Functions, functions),
+  contributes(
+    Capabilities.BlueprintDefinition,
+    Blueprint.make({
+      key: ASSISTANT_BLUEPRINT_KEY,
+      name: 'Thread',
+      tools: Blueprint.toolDefinitions({ functions }),
+      instructions: Template.make({
+        // TODO(wittjosiah): Move example to function input schema annotation.
+        source: trim`
+            You can update markdown documents via proposals.
+            For each diff, respond with the smallest possible matching span.
+            For example:
+              - "There is a tyop in this sentence."
+              + "There is a typo in this sentence."
+              - "This id goof."
+              + "This is good."
+          `,
+      }),
+    }),
+  ),
+];

package/src/capabilities/capabilities.ts

@@ -6,28 +6,28 @@ import { defineCapability } from '@dxos/app-framework';
 import { type DeepReadonly } from '@dxos/util';
 
 import { type CallManager, type CallState, type MediaState } from '../calls';
-import { THREAD_PLUGIN } from '../meta';
-import { type ChannelType, type ThreadState, type ViewState } from '../types';
+import { meta } from '../meta';
+import { type Channel, type ThreadState, type ViewState } from '../types';
 
 export namespace ThreadCapabilities {
-  export const CallManager = defineCapability<CallManager>(`${THREAD_PLUGIN}/capability/call-manager`);
+  export const CallManager = defineCapability<CallManager>(`${meta.id}/capability/call-manager`);
 
   // TODO(burdon): Better way to define specific extensions for meeting companions.
   // TODO(burdon): This brings in deps from ../calls; how should we manage/minimize explicit type exposure to other plugins?
   // TODO(wittjosiah): These callbacks could be intents once we support broadcast.
   export type CallProperties = {
-    onJoin: (state: { channel?: ChannelType; roomId?: string }) => Promise<void>;
+    onJoin: (state: { channel?: Channel.Channel; roomId?: string }) => Promise<void>;
     onLeave: (roomId?: string) => Promise<void>;
     onCallStateUpdated: (callState: CallState) => Promise<void>;
     onMediaStateUpdated: ([mediaState, isSpeaking]: [MediaState, boolean]) => Promise<void>;
   };
-  export const CallExtension = defineCapability<CallProperties>(`${THREAD_PLUGIN}/capability/call-extension`);
+  export const CallExtension = defineCapability<CallProperties>(`${meta.id}/capability/call-extension`);
 
   type GetViewState = (subjectId: string) => ViewState;
   export const State = defineCapability<{ state: DeepReadonly<ThreadState>; getViewState: GetViewState }>(
-    `${THREAD_PLUGIN}/capability/state`,
+    `${meta.id}/capability/state`,
   );
   export const MutableState = defineCapability<{ state: ThreadState; getViewState: GetViewState }>(
-    `${THREAD_PLUGIN}/capability/state`,
+    `${meta.id}/capability/state`,
   );
 }

package/src/capabilities/index.ts

@@ -5,6 +5,7 @@
 import { lazy } from '@dxos/app-framework';
 
 export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
+export const BlueprintDefinition = lazy(() => import('./blueprint-definition'));
 export const CallManager = lazy(() => import('./call-manager'));
 export const IntentResolver = lazy(() => import('./intent-resolver'));
 export const Markdown = lazy(() => import('./markdown'));
@@ -12,6 +13,5 @@ export const ReactRoot = lazy(() => import('./react-root'));
 export const ReactSurface = lazy(() => import('./react-surface'));
 export const ThreadSettings = lazy(() => import('./settings'));
 export const ThreadState = lazy(() => import('./state'));
-export const Toolkit = lazy(() => import('./toolkit'));
 
 export * from './capabilities';

package/src/capabilities/intent-resolver.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 
 import { Capabilities, type PluginContext, contributes, createIntent, createResolver } from '@dxos/app-framework';
 import { sleep } from '@dxos/async';
@@ -11,23 +11,23 @@ import { invariant } from '@dxos/invariant';
 import { ATTENDABLE_PATH_SEPARATOR, DeckAction } from '@dxos/plugin-deck/types';
 import { ObservabilityAction } from '@dxos/plugin-observability/types';
 import { CollectionAction, SpaceAction } from '@dxos/plugin-space/types';
-import { Ref, fullyQualifiedId, getSpace } from '@dxos/react-client/echo';
-import { AnchoredTo, DataType } from '@dxos/schema';
+import { Ref, getSpace } from '@dxos/react-client/echo';
+import { AnchoredTo, Message, Thread } from '@dxos/types';
 
-import { THREAD_PLUGIN } from '../meta';
-import { ChannelType, ThreadAction, ThreadType } from '../types';
+import { meta } from '../meta';
+import { Channel, ThreadAction } from '../types';
 
 import { ThreadCapabilities } from './capabilities';
 
 export default (context: PluginContext) =>
   contributes(Capabilities.IntentResolver, [
     createResolver({
-      intent: ThreadAction.OnSpaceCreated,
+      intent: ThreadAction.onCreateSpace,
       resolve: ({ space, rootCollection }) =>
         Effect.gen(function* () {
           const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
           const { object: collection } = yield* dispatch(
-            createIntent(CollectionAction.CreateQueryCollection, { typename: Type.getTypename(ChannelType) }),
+            createIntent(CollectionAction.CreateQueryCollection, { typename: Type.getTypename(Channel.Channel) }),
           );
           rootCollection.objects.push(Ref.make(collection));
 
@@ -41,18 +41,14 @@ export default (context: PluginContext) =>
       intent: ThreadAction.CreateChannel,
       resolve: ({ name }) => ({
         data: {
-          object: Obj.make(ChannelType, {
-            name,
-            defaultThread: Ref.make(Obj.make(ThreadType, { messages: [], status: 'active' })),
-            threads: [],
-          }),
+          object: Channel.make({ name }),
         },
       }),
     }),
     createResolver({
       intent: ThreadAction.CreateChannelThread,
       resolve: ({ channel }) => {
-        const thread = Obj.make(ThreadType, { messages: [], status: 'active' });
+        const thread = Thread.make({ status: 'active' });
         channel.threads.push(Ref.make(thread));
         return {
           data: {
@@ -65,13 +61,10 @@ export default (context: PluginContext) =>
     createResolver({
       intent: ThreadAction.Create,
       resolve: ({ name, anchor: _anchor, subject }) => {
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-
         const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
-        const thread = Obj.make(ThreadType, { name, messages: [], status: 'staged' });
-        const anchor = Relation.make(AnchoredTo, {
+        const subjectId = Obj.getDXN(subject).toString();
+        const thread = Thread.make({ name });
+        const anchor = Relation.make(AnchoredTo.AnchoredTo, {
           [Relation.Source]: thread,
           [Relation.Target]: subject,
           anchor: _anchor,
@@ -86,40 +79,7 @@ export default (context: PluginContext) =>
 
         return {
           intents: [
-            createIntent(ThreadAction.Select, { current: fullyQualifiedId(thread) }),
-            createIntent(DeckAction.ChangeCompanion, {
-              primary: subjectId,
-              companion: `${subjectId}${ATTENDABLE_PATH_SEPARATOR}comments`,
-            }),
-          ],
-        };
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.AddProposal,
-      resolve: ({ text, anchor, sender, subject }) => {
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-
-        const subjectId = fullyQualifiedId(subject);
-        const proposal = Obj.make(DataType.Message, {
-          created: new Date().toISOString(),
-          sender,
-          blocks: [{ _tag: 'proposal', text }],
-        });
-        const thread = Obj.make(ThreadType, { name: 'Proposal', messages: [Ref.make(proposal)], status: 'active' });
-
-        return {
-          intents: [
-            createIntent(SpaceAction.AddObject, { object: thread, target: space, hidden: true }),
-            createIntent(SpaceAction.AddRelation, {
-              space,
-              schema: AnchoredTo,
-              source: thread,
-              target: subject,
-              fields: { anchor },
-            }),
-            createIntent(ThreadAction.Select, { current: fullyQualifiedId(thread) }),
+            createIntent(ThreadAction.Select, { current: Obj.getDXN(thread).toString() }),
             createIntent(DeckAction.ChangeCompanion, {
               primary: subjectId,
               companion: `${subjectId}${ATTENDABLE_PATH_SEPARATOR}comments`,
@@ -164,9 +124,9 @@ export default (context: PluginContext) =>
     createResolver({
       intent: ThreadAction.Delete,
       resolve: async ({ subject, anchor, thread: _thread }, undo) => {
-        const thread = _thread ?? (Relation.getSource(anchor) as ThreadType);
+        const thread = _thread ?? (Relation.getSource(anchor) as Thread.Thread);
         const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
+        const subjectId = Obj.getDXN(subject).toString();
         const draft = state.drafts[subjectId];
         if (draft) {
           // Check if we're deleting a draft; if so, remo ve it.
@@ -190,7 +150,7 @@ export default (context: PluginContext) =>
 
           return {
             undoable: {
-              message: ['thread deleted label', { ns: THREAD_PLUGIN }],
+              message: ['thread deleted label', { ns: meta.id }],
               data: { thread, anchor },
             },
             intents: [
@@ -226,13 +186,13 @@ export default (context: PluginContext) =>
     createResolver({
       intent: ThreadAction.AddMessage,
       resolve: ({ anchor, subject, sender, text }) => {
-        const thread = Relation.getSource(anchor) as ThreadType;
+        const thread = Relation.getSource(anchor) as Thread.Thread;
         const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
+        const subjectId = Obj.getDXN(subject).toString();
         const space = getSpace(subject);
         invariant(space, 'Space not found');
 
-        const message = Obj.make(DataType.Message, {
+        const message = Obj.make(Message.Message, {
           created: new Date().toISOString(),
           sender,
           blocks: [{ _tag: 'text', text }],
@@ -252,7 +212,7 @@ export default (context: PluginContext) =>
           intents.push(
             createIntent(SpaceAction.AddRelation, {
               space,
-              schema: AnchoredTo,
+              schema: AnchoredTo.AnchoredTo,
               source: thread,
               target: subject,
               fields: { anchor: draft.anchor },
@@ -288,7 +248,7 @@ export default (context: PluginContext) =>
     createResolver({
       intent: ThreadAction.DeleteMessage,
       resolve: ({ subject, anchor, messageId, message, messageIndex }, undo) => {
-        const thread = Relation.getSource(anchor) as ThreadType;
+        const thread = Relation.getSource(anchor) as Thread.Thread;
         const space = getSpace(subject);
         invariant(space, 'Space not found');
 
@@ -310,7 +270,7 @@ export default (context: PluginContext) =>
 
           return {
             undoable: {
-              message: ['message deleted label', { ns: THREAD_PLUGIN }],
+              message: ['message deleted label', { ns: meta.id }],
               data: { message, messageIndex },
             },
             intents: [

package/src/capabilities/markdown.ts

@@ -5,9 +5,9 @@
 import { EditorView } from '@codemirror/view';
 
 import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
+import { Obj } from '@dxos/echo';
 import { ATTENDABLE_PATH_SEPARATOR, DeckAction } from '@dxos/plugin-deck/types';
 import { MarkdownCapabilities } from '@dxos/plugin-markdown';
-import { fullyQualifiedId } from '@dxos/react-client/echo';
 import { type EditorState, commentClickedEffect, commentsState, overlap } from '@dxos/react-ui-editor';
 
 import { threads } from '../extensions';
@@ -22,17 +22,19 @@ export default (context: PluginContext) =>
       return threads(state, doc, dispatch);
     },
     ({ document: doc }) => {
+      if (!doc) return [];
       const { state } = context.getCapability(ThreadCapabilities.MutableState);
 
       return EditorView.updateListener.of((update) => {
         if (update.docChanged || update.selectionSet) {
-          state.toolbar[fullyQualifiedId(doc)] = selectionOverlapsComment(update.state);
+          state.toolbar[Obj.getDXN(doc).toString()] = selectionOverlapsComment(update.state);
         }
       });
     },
     ({ document: doc }) => {
+      if (!doc) return [];
       const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-      const id = fullyQualifiedId(doc);
+      const id = Obj.getDXN(doc).toString();
 
       return EditorView.updateListener.of((update) => {
         update.transactions.forEach((transaction) => {

package/src/capabilities/react-root.tsx

@@ -7,11 +7,11 @@ import React from 'react';
 import { Capabilities, contributes } from '@dxos/app-framework';
 
 import { Call } from '../components';
-import { THREAD_PLUGIN } from '../meta';
+import { meta } from '../meta';
 
 export default () => {
   return contributes(Capabilities.ReactRoot, {
-    id: THREAD_PLUGIN,
+    id: meta.id,
     root: () => <Call.Audio />,
   });
 };

package/src/capabilities/react-surface.tsx

@@ -4,37 +4,39 @@
 
 import React from 'react';
 
-import { Capabilities, contributes, createSurface, useCapability } from '@dxos/app-framework';
+import { Capabilities, contributes, createSurface } from '@dxos/app-framework';
+import { useCapability } from '@dxos/app-framework/react';
 import { Obj, type Ref } from '@dxos/echo';
 import { SettingsStore } from '@dxos/local-storage';
 import { getSpace } from '@dxos/react-client/echo';
+import { Thread } from '@dxos/types';
 
 import {
   CallDebugPanel,
   CallSidebar,
   ChannelContainer,
   ChatContainer,
-  ThreadComplementary,
+  ThreadCompanion,
   ThreadSettings,
 } from '../components';
-import { THREAD_PLUGIN } from '../meta';
-import { ChannelType, type ThreadSettingsProps, ThreadType } from '../types';
+import { meta } from '../meta';
+import { Channel, type ThreadSettingsProps } from '../types';
 
 import { ThreadCapabilities } from './capabilities';
 
 export default () =>
   contributes(Capabilities.ReactSurface, [
     createSurface({
-      id: `${THREAD_PLUGIN}/channel`,
+      id: `${meta.id}/channel`,
       role: 'article',
-      filter: (data): data is { subject: ChannelType } => Obj.instanceOf(ChannelType, data.subject),
-      component: ({ data: { subject: channel }, role }) => <ChannelContainer channel={channel} role={role} />,
+      filter: (data): data is { subject: Channel.Channel } => Obj.instanceOf(Channel.Channel, data.subject),
+      component: ({ data: { subject }, role }) => <ChannelContainer channel={subject} role={role} />,
     }),
     createSurface({
-      id: `${THREAD_PLUGIN}/chat-companion`,
+      id: `${meta.id}/chat-companion`,
       role: 'article',
-      filter: (data): data is { companionTo: ChannelType; subject: 'chat' } =>
-        Obj.instanceOf(ChannelType, data.companionTo) && data.subject === 'chat',
+      filter: (data): data is { companionTo: Channel.Channel; subject: 'chat' } =>
+        Obj.instanceOf(Channel.Channel, data.companionTo) && data.subject === 'chat',
       component: ({ data: { companionTo: channel } }) => {
         const space = getSpace(channel);
         const thread = channel.defaultThread.target;
@@ -46,40 +48,40 @@ export default () =>
       },
     }),
     createSurface({
-      id: `${THREAD_PLUGIN}/thread`,
+      id: `${meta.id}/thread`,
       role: 'article',
-      filter: (data): data is { subject: ThreadType } => Obj.instanceOf(ThreadType, data.subject),
-      component: ({ data: { subject: thread } }) => {
-        const space = getSpace(thread);
-        if (!space || !thread) {
+      filter: (data): data is { subject: Thread.Thread } => Obj.instanceOf(Thread.Thread, data.subject),
+      component: ({ data: { subject } }) => {
+        const space = getSpace(subject);
+        if (!space || !subject) {
           return null;
         }
 
-        return <ChatContainer thread={thread} space={space} />;
+        return <ChatContainer thread={subject} space={space} />;
       },
     }),
     createSurface({
-      id: `${THREAD_PLUGIN}/comments`,
+      id: `${meta.id}/comments`,
       role: 'article',
-      filter: (data): data is { companionTo: { threads: Ref.Ref<ThreadType>[] } } =>
+      filter: (data): data is { companionTo: { threads: Ref.Ref<Thread.Thread>[] } } =>
         data.subject === 'comments' && Obj.isObject(data.companionTo),
       // TODO(wittjosiah): This isn't scrolling properly in a plank.
-      component: ({ data }) => <ThreadComplementary subject={data.companionTo} />,
+      component: ({ data }) => <ThreadCompanion subject={data.companionTo} />,
     }),
     createSurface({
-      id: `${THREAD_PLUGIN}/plugin-settings`,
+      id: `${meta.id}/plugin-settings`,
       role: 'article',
       filter: (data): data is { subject: SettingsStore<ThreadSettingsProps> } =>
-        data.subject instanceof SettingsStore && data.subject.prefix === THREAD_PLUGIN,
+        data.subject instanceof SettingsStore && data.subject.prefix === meta.id,
       component: ({ data: { subject } }) => <ThreadSettings settings={subject.value} />,
     }),
     createSurface({
-      id: `${THREAD_PLUGIN}/assistant`,
+      id: `${meta.id}/assistant`,
       role: 'deck-companion--active-call',
       component: () => <CallSidebar />,
     }),
     createSurface({
-      id: `${THREAD_PLUGIN}/devtools-overview`,
+      id: `${meta.id}/devtools-overview`,
       role: 'devtools-overview',
       component: () => {
         const call = useCapability(ThreadCapabilities.CallManager);

package/src/components/Call/Call.tsx

@@ -4,7 +4,7 @@
 
 import React, { type FC, type PropsWithChildren } from 'react';
 
-import { useCapability } from '@dxos/app-framework';
+import { useCapability } from '@dxos/app-framework/react';
 import { type ThemedClassName } from '@dxos/react-ui';
 
 import { ThreadCapabilities } from '../../capabilities';

package/src/components/Call/Toolbar.tsx

@@ -4,9 +4,9 @@
 
 import React from 'react';
 
-import { useAppGraph, useCapability } from '@dxos/app-framework';
+import { useAppGraph, useCapability } from '@dxos/app-framework/react';
+import { Obj } from '@dxos/echo';
 import { useActions, useNode } from '@dxos/plugin-graph';
-import { fullyQualifiedId } from '@dxos/react-client/echo';
 import {
   Icon,
   IconButton,
@@ -20,10 +20,10 @@ import { groupHoverControlItemWithTransition, mx } from '@dxos/react-ui-theme';
 
 import { ThreadCapabilities } from '../../capabilities';
 import { meta } from '../../meta';
-import { type ChannelType } from '../../types';
+import { type Channel } from '../../types';
 
 export type ToolbarProps = ThemedClassName<{
-  channel?: ChannelType;
+  channel?: Channel.Channel;
   participants?: number;
   autoHideControls?: boolean;
   isInRoom?: boolean;
@@ -45,7 +45,7 @@ export const Toolbar = ({
   const call = useCapability(ThreadCapabilities.CallManager);
 
   // Channel app graph node.
-  const node = useNode(graph, channel && fullyQualifiedId(channel));
+  const node = useNode(graph, channel && Obj.getDXN(channel).toString());
   const actions = useActions(graph, node?.id).filter((action) => action.properties.disposition === 'toolbar');
 
   // Screen sharing.