@dxos/plugin-assistant 0.8.4-main.bc674ce → 0.8.4-main.bcb3aa67d6

package/src/components/Typewriter/assistant-extension.tsx

@@ -8,7 +8,7 @@ import { EditorView, type Tooltip, showTooltip } from '@codemirror/view';
 import * as LanguageModel from '@effect/ai/LanguageModel';
 import * as Effect from 'effect/Effect';
 import * as Runtime from 'effect/Runtime';
-import React from 'react';
+import { createElement } from 'react';
 import { createRoot } from 'react-dom/client';
 
 import { unwrapExit } from '@dxos/effect';
@@ -54,8 +54,7 @@ const assistantState = (runtime: Runtime.Runtime<LanguageModel.LanguageModel>) =
             const dom = document.createElement('div');
             dom.classList.add('cm-tooltip-assistant');
             const root = createRoot(dom);
-
-            root.render(React.createElement(AssistantToolbar, { view, runtime, from, to }));
+            root.render(createElement(AssistantToolbar, { view, runtime, from, to }));
 
             return {
               dom,
@@ -111,9 +110,7 @@ const assistantLinter = (runtime: Runtime.Runtime<LanguageModel.LanguageModel>)
         if (match) {
           suggestions = JSON.parse(match[0]);
         }
-      } catch (e) {
-        // failed to parse
-      }
+      } catch {}
 
       const diagnostics: Diagnostic[] = [];
       for (const s of suggestions) {
@@ -137,8 +134,8 @@ const assistantLinter = (runtime: Runtime.Runtime<LanguageModel.LanguageModel>)
         }
       }
       return diagnostics;
-    } catch (e) {
-      log.error('Proofreading failed', { error: e });
+    } catch (error) {
+      log.catch(error);
       return [];
     }
   });

package/src/components/index.ts

@@ -2,15 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
-import { lazy } from 'react';
+import { type ComponentType, lazy } from 'react';
 
-export * from './AssistantSettings';
 export * from './Chat';
+export * from './ProcessTree';
 export * from './TemplateEditor';
 export * from './Toolbox';
 
-export const BlueprintArticle = lazy(() => import('./BlueprintArticle'));
-export const ChatCompanion = lazy(() => import('./ChatCompanion'));
-export const ChatContainer = lazy(() => import('./ChatContainer'));
-export const ChatDialog = lazy(() => import('./ChatDialog'));
-export const PromptArticle = lazy(() => import('./PromptArticle'));
+export const AssistantSettings: ComponentType<any> = lazy(() => import('./AssistantSettings'));

package/src/containers/BlueprintArticle/BlueprintArticle.tsx

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { type ObjectSurfaceProps } from '@dxos/app-toolkit/ui';
+import { type Blueprint } from '@dxos/blueprints';
+import { Panel, Toolbar } from '@dxos/react-ui';
+import { useAttention } from '@dxos/react-ui-attention';
+
+import { TemplateEditor } from '#components';
+
+export type BlueprintArticleProps = ObjectSurfaceProps<Blueprint.Blueprint>;
+
+export const BlueprintArticle = ({ role, attendableId, subject }: BlueprintArticleProps) => {
+  const { hasAttention } = useAttention(attendableId);
+
+  return (
+    <Panel.Root role={role} classNames='dx-document'>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root disabled={!hasAttention} />
+      </Panel.Toolbar>
+      <Panel.Content asChild>
+        <TemplateEditor id={subject.id} template={subject.instructions} />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};

package/src/containers/BlueprintArticle/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { BlueprintArticle } from './BlueprintArticle';
+
+export default BlueprintArticle;

package/src/{components → containers/ChatCompanion}/ChatCompanion.tsx

@@ -5,63 +5,44 @@
 import * as Array from 'effect/Array';
 import * as Function from 'effect/Function';
 import * as Option from 'effect/Option';
-import React, { forwardRef, useCallback, useEffect, useMemo, useState } from 'react';
+import React, { forwardRef, useCallback, useMemo } from 'react';
 
-import { Common } from '@dxos/app-framework';
-import { useCapabilities, useOperationInvoker } from '@dxos/app-framework/react';
+import { useCapabilities, useOperationInvoker } from '@dxos/app-framework/ui';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { type CompanionSurfaceProps } from '@dxos/app-toolkit/ui';
+import { Chat } from '@dxos/assistant-toolkit';
 import { Blueprint } from '@dxos/blueprints';
 import { getSpace } from '@dxos/client/echo';
-import { Filter, Obj, Ref } from '@dxos/echo';
-import { SpaceOperation } from '@dxos/plugin-space/types';
+import { Feed, Filter, Obj, Ref } from '@dxos/echo';
+import { SpaceOperation } from '@dxos/plugin-space/operations';
 import { useQuery } from '@dxos/react-client/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
 
-import { ChatContainer, type ChatEvent } from '../components';
-import { useBlueprintRegistry, useContextBinder } from '../hooks';
-import { Assistant, AssistantOperation } from '../types';
+import { type ChatEvent } from '#components';
+import { useBlueprintRegistry, useContextBinder } from '#hooks';
+import { AssistantOperation } from '#operations';
 
-export type ChatCompanionProps = {
-  role?: string;
-  data: {
-    subject: Assistant.Chat | 'assistant-chat';
-    companionTo: Obj.Unknown;
-  };
-};
+import ChatContainer from '../ChatContainer';
+
+export type ChatCompanionProps = CompanionSurfaceProps<Chat.Chat>;
 
 export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
-  ({ role, data }: ChatCompanionProps, forwardedRef) => {
+  ({ role, subject: chat, companionTo, attendableId }, forwardedRef) => {
     const { invokePromise } = useOperationInvoker();
     const blueprintRegistry = useBlueprintRegistry();
-    const companionTo = data.companionTo;
-
     const space = getSpace(companionTo);
-    const [chat, setChat] = useState(data.subject === 'assistant-chat' ? undefined : data.subject);
-    useEffect(() => {
-      setChat(data.subject === 'assistant-chat' ? undefined : data.subject);
-    }, [data.subject]);
-
-    const chatQueue = space && chat ? space.queues.get(chat.queue.dxn) : undefined;
+    const feedTarget = chat?.feed.target;
+    const chatQueue = space && feedTarget ? space.queues.get(Feed.getQueueDxn(feedTarget)!) : undefined;
     const binder = useContextBinder(chatQueue);
 
-    // Initialize companion chat if it doesn't exist, but don't add it to the space immediately.
-    useAsyncEffect(async () => {
-      if (!space || chat) {
-        return;
-      }
-
-      const { data } = await invokePromise(AssistantOperation.CreateChat, { db: space.db });
-      setChat(data?.object);
-    }, [chat, space]);
-
-    // Add chat to space when user submits the first message.
+    // Persist chat on first submit.
     const handleEvent = useCallback(
       async (event: ChatEvent) => {
-        const chatInSpace = !!getSpace(chat);
-        if (chatInSpace || !chat || !space) {
+        if (!space || !chat) {
           return;
         }
 
-        if (event.type === 'submit') {
+        if (event.type === 'submit' && !getSpace(chat)) {
           await invokePromise(SpaceOperation.AddObject, {
             object: chat,
             target: space.db,
@@ -69,7 +50,7 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
           });
           await invokePromise(SpaceOperation.AddRelation, {
             db: space.db,
-            schema: Assistant.CompanionTo,
+            schema: Chat.CompanionTo,
             source: chat,
             target: companionTo,
           });
@@ -82,7 +63,7 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
       [chat, space, companionTo, invokePromise],
     );
 
-    const metadata = useCapabilities(Common.Capability.Metadata);
+    const metadata = useCapabilities(AppCapabilities.Metadata);
     const blueprintKeys = useMemo(
       () =>
         Function.pipe(
@@ -125,7 +106,7 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
           continue;
         }
 
-        space.db.add(Obj.clone(blueprint));
+        space.db.add(Obj.clone(blueprint, { deep: true }));
       }
     }, [space, blueprintRegistry, blueprintKeys]);
 
@@ -152,6 +133,7 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
         role={role}
         space={space}
         subject={chat}
+        attendableId={attendableId}
         companionTo={companionTo}
         onEvent={handleEvent}
         ref={forwardedRef}
@@ -159,5 +141,3 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
     );
   },
 );
-
-export default ChatCompanion;

package/src/containers/ChatCompanion/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ChatCompanion } from './ChatCompanion';
+
+export default ChatCompanion;

package/src/containers/ChatContainer/ChatContainer.tsx

@@ -0,0 +1,95 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { forwardRef, useEffect, useRef } from 'react';
+
+import { Capabilities } from '@dxos/app-framework';
+import { useAtomCapability, useCapability } from '@dxos/app-framework/ui';
+import { type ObjectSurfaceProps } from '@dxos/app-toolkit/ui';
+import { type Space, getSpace } from '@dxos/client/echo';
+import { Feed, type Obj } from '@dxos/echo';
+import { Panel } from '@dxos/react-ui';
+import { getParentId } from '@dxos/react-ui-attention';
+
+import { Chat as ChatComponent, type ChatRootProps } from '#components';
+import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '#hooks';
+import { AssistantCapabilities, type ChatType } from '#types';
+
+export type ChatContainerProps = ObjectSurfaceProps<
+  ChatType.Chat | undefined,
+  {
+    space?: Space;
+    companionTo?: Obj.Unknown;
+  } & Pick<ChatRootProps, 'onEvent'>
+>;
+
+export const ChatContainer = forwardRef<HTMLDivElement, ChatContainerProps>((props, forwardedRef) => {
+  const { role, attendableId, subject: chat, space: spaceProp, companionTo, onEvent } = props;
+  const parentId = attendableId ? getParentId(attendableId) : undefined;
+  const space = spaceProp ?? getSpace(chat);
+  const settings = useAtomCapability(AssistantCapabilities.Settings);
+  const runtime = useChatServices({ id: space?.id });
+  const [online, setOnline] = useOnline();
+  const { preset, ...chatProps } = usePresets(online);
+  const blueprintRegistry = useBlueprintRegistry();
+  const processor = useChatProcessor({
+    space,
+    chat,
+    preset,
+    runtime,
+    blueprintRegistry,
+    settings,
+  });
+
+  const registry = useCapability(Capabilities.AtomRegistry);
+  const stateAtom = useCapability(AssistantCapabilities.State);
+  const pendingSubmitted = useRef(false);
+  useEffect(() => {
+    if (!processor || !attendableId || pendingSubmitted.current) {
+      return;
+    }
+
+    const state = registry.get(stateAtom);
+    const pendingPrompt = state.pendingPrompts[attendableId];
+    if (pendingPrompt) {
+      pendingSubmitted.current = true;
+      registry.update(stateAtom, (current) => {
+        const { [attendableId]: _, ...rest } = current.pendingPrompts;
+        return { ...current, pendingPrompts: rest };
+      });
+      void processor.request({ message: pendingPrompt });
+    }
+  }, [processor, attendableId, registry, stateAtom]);
+
+  const feedTarget = chat?.feed.target;
+  const queue = space && feedTarget ? space.queues.get(Feed.getQueueDxn(feedTarget)!) : undefined;
+
+  if (!processor) {
+    return null;
+  }
+
+  return (
+    <ChatComponent.Root db={space?.db} chat={chat} queue={queue} processor={processor} onEvent={onEvent}>
+      <Panel.Root role={role} classNames='dx-document' ref={forwardedRef}>
+        <Panel.Toolbar className='bg-toolbar-surface'>
+          <ChatComponent.Toolbar classNames='dx-document' attendableId={parentId} companionTo={companionTo} />
+        </Panel.Toolbar>
+        <Panel.Content>
+          <ChatComponent.Viewport>
+            <ChatComponent.Thread />
+            <div role='none' className='p-4'>
+              <ChatComponent.Prompt
+                {...chatProps}
+                outline
+                preset={preset?.id}
+                online={online}
+                onOnlineChange={setOnline}
+              />
+            </div>
+          </ChatComponent.Viewport>
+        </Panel.Content>
+      </Panel.Root>
+    </ChatComponent.Root>
+  );
+});

package/src/containers/ChatContainer/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ChatContainer } from './ChatContainer';
+
+export default ChatContainer;

package/src/{components → containers/ChatDialog}/ChatDialog.tsx

@@ -4,19 +4,19 @@
 
 import React, { useCallback, useState } from 'react';
 
-import { useAtomCapability } from '@dxos/app-framework/react';
+import { useAtomCapability } from '@dxos/app-framework/ui';
+import { type Chat as ChatTypes } from '@dxos/assistant-toolkit';
 import { Obj } from '@dxos/echo';
 import { useTranslation } from '@dxos/react-ui';
 import { ChatDialog as NaturalChatDialog } from '@dxos/react-ui-chat';
 
-import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../hooks';
-import { meta } from '../meta';
-import { type Assistant, AssistantCapabilities } from '../types';
-
-import { Chat, type ChatRootProps } from './Chat';
+import { Chat, type ChatRootProps } from '#components';
+import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '#hooks';
+import { meta } from '#meta';
+import { AssistantCapabilities } from '#types';
 
 export type ChatDialogProps = {
-  chat?: Assistant.Chat;
+  chat?: ChatTypes.Chat;
 };
 
 export const ChatDialog = ({ chat }: ChatDialogProps) => {
@@ -24,14 +24,14 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
 
   const db = chat && Obj.getDatabase(chat);
   const settings = useAtomCapability(AssistantCapabilities.Settings);
-  const services = useChatServices({ id: db?.spaceId, chat });
+  const runtime = useChatServices({ id: db?.spaceId });
   const [online, setOnline] = useOnline();
   const { preset, ...chatProps } = usePresets(online);
   const blueprintRegistry = useBlueprintRegistry();
   const processor = useChatProcessor({
     chat,
     preset,
-    services,
+    runtime,
     blueprintRegistry,
     settings,
   });
@@ -59,7 +59,7 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
   return (
     <Chat.Root chat={chat} processor={processor} onEvent={handleEvent}>
       <NaturalChatDialog.Root open={open} expanded={expanded} onOpenChange={setOpen}>
-        <NaturalChatDialog.Header title={t('assistant dialog title')} />
+        <NaturalChatDialog.Header title={t('assistant-dialog.title')} />
         <NaturalChatDialog.Content>
           <Chat.Thread />
         </NaturalChatDialog.Content>
@@ -70,5 +70,3 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
     </Chat.Root>
   );
 };
-
-export default ChatDialog;

package/src/containers/ChatDialog/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ChatDialog } from './ChatDialog';
+
+export default ChatDialog;

package/src/containers/ProjectArticle/ProjectArticle.tsx

@@ -0,0 +1,127 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Atom, useAtomValue } from '@effect-atom/atom-react';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import React, { forwardRef, useMemo, useState } from 'react';
+
+import { Surface } from '@dxos/app-framework/ui';
+import { type ObjectSurfaceProps, useObjectMenuItems } from '@dxos/app-toolkit/ui';
+import { type Project } from '@dxos/assistant-toolkit';
+import { Annotation, Filter, Obj, Query } from '@dxos/echo';
+import { AtomObj, AtomRef } from '@dxos/echo-atom';
+import { useQuery } from '@dxos/react-client/echo';
+import { Card, Panel, ScrollArea, Toolbar } from '@dxos/react-ui';
+import { Menu } from '@dxos/react-ui-menu';
+import { Focus, Mosaic, type MosaicTileProps } from '@dxos/react-ui-mosaic';
+import { isNonNullable } from '@dxos/util';
+
+export type ProjectArticleProps = ObjectSurfaceProps<Project.Project>;
+
+export const ProjectArticle = ({ subject: project }: ProjectArticleProps) => {
+  const inputQueue = useAtomValue(
+    AtomObj.make(project).pipe((_) =>
+      Atom.make((get) =>
+        Option.fromNullable(get(_).queue).pipe(Option.map(AtomRef.make), Option.map(get), Option.getOrUndefined),
+      ),
+    ),
+  );
+
+  const inputQueueItems: Obj.Unknown[] = useQuery(inputQueue, Query.select(Filter.everything()));
+
+  const artifacts = useAtomValue(
+    useMemo(
+      () =>
+        AtomObj.make(project).pipe((project) =>
+          Atom.make((get) => {
+            return get(project).artifacts.map((artifact) => get(AtomRef.make(artifact.data)) as Obj.Unknown);
+          }),
+        ),
+      [project],
+    ),
+  );
+
+  const [viewport, setViewport] = useState<HTMLElement | null>(null);
+
+  const stackObjects = [...artifacts, ...inputQueueItems].filter(isNonNullable);
+
+  return (
+    <Panel.Root className='dx-document'>
+      <Panel.Content>
+        {/* TODO(burdon): Factor out. */}
+        {stackObjects.length === 0 && (
+          <div className='text-subdued'>
+            Project has no objects associated with it.
+            <br />
+            <br />
+            To get started:
+            <br />- Write the initative spec: what is the goal of the project?
+            <br />- subscribe project to your email.
+            <br />- Chat with the agent.
+          </div>
+        )}
+
+        {stackObjects.length > 0 && (
+          <Focus.Group asChild border>
+            <Mosaic.Container asChild withFocus autoScroll={viewport}>
+              <ScrollArea.Root orientation='vertical'>
+                <ScrollArea.Viewport classNames='p-2' ref={setViewport}>
+                  <Mosaic.Stack items={stackObjects} getId={(item) => item.id} draggable={false} Tile={StackTile} />
+                </ScrollArea.Viewport>
+              </ScrollArea.Root>
+            </Mosaic.Container>
+          </Focus.Group>
+        )}
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+const StackTile = forwardRef<HTMLDivElement, MosaicTileProps<Obj.Unknown>>(
+  ({ data, location, debug }, forwardedRef) => {
+    const objectMenuItems = useObjectMenuItems(data);
+    const icon = Function.pipe(
+      Obj.getSchema(data),
+      Option.fromNullable,
+      Option.flatMap(Annotation.IconAnnotation.get),
+      Option.map(({ icon }) => icon),
+      Option.getOrElse(() => 'ph--placeholder--regular'),
+    );
+
+    return (
+      <Menu.Root>
+        <Mosaic.Tile asChild id={data.id} data={data} location={location} debug={debug}>
+          <Focus.Item asChild>
+            <Card.Root ref={forwardedRef} data-testid='board-item'>
+              <Card.Toolbar>
+                <Card.IconBlock padding>
+                  <Card.Icon icon={icon} />
+                </Card.IconBlock>
+                <Card.Title>{Obj.getLabel(data)}</Card.Title>
+                {/* TODO(wittjosiah): Reconcile with Card.Menu. */}
+                <Card.IconBlock padding>
+                  <Menu.Trigger asChild disabled={!objectMenuItems?.length}>
+                    <Toolbar.IconButton
+                      iconOnly
+                      variant='ghost'
+                      icon='ph--dots-three-vertical--regular'
+                      label='Actions'
+                    />
+                  </Menu.Trigger>
+                  <Menu.Content items={objectMenuItems} />
+                </Card.IconBlock>
+              </Card.Toolbar>
+              <Card.Content>
+                <Surface.Surface role='card--content' limit={1} data={{ subject: data }} />
+              </Card.Content>
+            </Card.Root>
+          </Focus.Item>
+        </Mosaic.Tile>
+      </Menu.Root>
+    );
+  },
+);
+
+StackTile.displayName = 'StackTile';

package/src/containers/ProjectArticle/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { ProjectArticle } from './ProjectArticle';
+
+export default ProjectArticle;

package/src/containers/ProjectSettings/ProjectSettings.tsx

@@ -0,0 +1,139 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom';
+import { useAtomValue } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import React, { useCallback, useEffect, useMemo } from 'react';
+
+import { useCapability } from '@dxos/app-framework/ui';
+import { type ObjectSurfaceProps } from '@dxos/app-toolkit/ui';
+import { Project, syncProjectTriggers } from '@dxos/assistant-toolkit';
+import { DXN, Obj, Ref } from '@dxos/echo';
+import { AtomObj, AtomRef } from '@dxos/echo-atom';
+import { QueueService } from '@dxos/functions';
+import { AutomationCapabilities } from '@dxos/plugin-automation/types';
+import { MarkdownEditor } from '@dxos/plugin-markdown';
+import { Filter, useQuery } from '@dxos/react-client/echo';
+import { useObject } from '@dxos/react-client/echo';
+import { Button } from '@dxos/react-ui';
+import { useTranslation, Input } from '@dxos/react-ui';
+import { FeedAnnotation } from '@dxos/schema';
+
+import { meta } from '#meta';
+
+export type ProjectSettingsProps = ObjectSurfaceProps<Project.Project>;
+
+export const ProjectSettings = ({ subject: project }: ProjectSettingsProps) => {
+  const { t } = useTranslation(meta.id);
+  const computeRuntime = useCapability(AutomationCapabilities.ComputeRuntime);
+
+  const handleResetHistory = useCallback(async () => {
+    const runtime = computeRuntime.getRuntime(Obj.getDatabase(project)!.spaceId);
+    await runtime.runPromise(Project.resetChatHistory(project));
+    if (!project.queue) {
+      await runtime.runPromise(
+        Effect.gen(function* () {
+          const queue = yield* QueueService.createQueue();
+          Obj.change(project, (project) => {
+            project.queue = Ref.fromDXN(queue.dxn);
+          });
+        }),
+      );
+    }
+  }, [project, computeRuntime]);
+
+  const spec = useAtomValue(AtomRef.make(project.spec));
+  const [specInitialValue] = useObject(spec, 'content');
+
+  useEffect(() => {
+    const db = Obj.getDatabase(project);
+    if (!db) return;
+    const runtime = computeRuntime.getRuntime(db.spaceId);
+    return Obj.subscribe(project, () => {
+      queueMicrotask(() => runtime.runPromise(syncProjectTriggers(project)));
+    });
+  }, [project, computeRuntime]);
+
+  const db = Obj.getDatabase(project);
+  const feedFilter = useMemo(() => {
+    if (!db) {
+      return Filter.nothing();
+    }
+
+    const schemas = db.schemaRegistry.query({ location: ['database', 'runtime'] }).runSync();
+    const feedSchemas = schemas.filter((schema) => {
+      const annotation = FeedAnnotation.get(schema);
+      return Option.isSome(annotation) && annotation.value === true;
+    });
+
+    if (feedSchemas.length === 0) {
+      return Filter.nothing();
+    }
+
+    return Filter.or(...feedSchemas.map((schema) => Filter.type(schema)));
+  }, [db]);
+  const subscribableObjects = useQuery(db, feedFilter);
+
+  const existingSubscripts = useAtomValue(
+    useMemo(
+      () =>
+        AtomObj.make(project).pipe((_) =>
+          Atom.make((get) => {
+            const project = get(_);
+            const selectedSubscriptions: Obj.Unknown[] = subscribableObjects.filter((object) =>
+              project.subscriptions.some((subscription) => DXN.equals(subscription.dxn, Obj.getDXN(object))),
+            );
+
+            return selectedSubscriptions;
+          }),
+        ),
+      [project, subscribableObjects],
+    ),
+  );
+
+  return (
+    <div role='none' className='dx-container grid grid-rows-[min-content_1fr_min-content] gap-2 pb-trim-md'>
+      <div role='none' className='flex flex-col'>
+        <Input.Root>
+          <Input.Label>{t('subscriptions.label')}</Input.Label>
+        </Input.Root>
+        {subscribableObjects.map((object) => (
+          <Input.Root key={object.id}>
+            <div className='flex items-center gap-2'>
+              <Input.Checkbox
+                checked={existingSubscripts.includes(object)}
+                onCheckedChange={(checked) => {
+                  Obj.change(project, (project) => {
+                    if (checked) {
+                      project.subscriptions.push(Ref.fromDXN(Obj.getDXN(object)));
+                    } else {
+                      project.subscriptions = project.subscriptions.filter(
+                        (subscription) => !DXN.equals(subscription.dxn, Obj.getDXN(object)),
+                      );
+                    }
+                  });
+                }}
+              />
+              <Input.Label>{Obj.getLabel(object) ?? object.id}</Input.Label>
+            </div>
+          </Input.Root>
+        ))}
+      </div>
+      <div className='dx-expander flex flex-col'>
+        <Input.Root>
+          <Input.Label>{t('instructions.label')}</Input.Label>
+          {spec && (
+            <MarkdownEditor.Root id={spec.id} object={spec}>
+              <MarkdownEditor.Content initialValue={specInitialValue} />
+            </MarkdownEditor.Root>
+          )}
+        </Input.Root>
+      </div>
+      {/* TODO(burdon): Move into toolbar in parent. */}
+      <Button onClick={handleResetHistory}>{t('reset-history.button')}</Button>
+    </div>
+  );
+};