@dxos/plugin-assistant 0.8.4-main.422d1c7879 → 0.8.4-main.4668b7de9b

package/src/containers/AgentProperties/AgentProperties.tsx

@@ -2,126 +2,42 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Atom } from '@effect-atom/atom';
-import { useAtomValue } from '@effect-atom/atom-react';
-import * as Option from 'effect/Option';
-import React, { useCallback, useEffect, useMemo } from 'react';
+import React, { useEffect } from 'react';
 
-import { useCapability } from '@dxos/app-framework/ui';
+import { useSpaceCallback } from '@dxos/app-framework/ui';
 import { type AppSurface } from '@dxos/app-toolkit/ui';
 import { Agent, SyncTriggers } from '@dxos/assistant-toolkit';
-import { DXN, Obj, Ref } from '@dxos/echo';
-import { AtomObj } from '@dxos/echo-atom';
+import { Operation } from '@dxos/compute';
+import { Obj, Ref } from '@dxos/echo';
 import { log } from '@dxos/log';
-import { Operation } from '@dxos/operation';
-import { AutomationCapabilities } from '@dxos/plugin-automation/types';
-import { Filter, useQuery } from '@dxos/react-client/echo';
-import { Input, useTranslation } from '@dxos/react-ui';
-import { FeedAnnotation } from '@dxos/schema';
 
-import { meta } from '#meta';
+import { AgentProperties as AgentPropertiesComponent } from '#components';
 
 export type AgentPropertiesProps = AppSurface.ObjectPropertiesProps<Agent.Agent>;
 
 export const AgentProperties = ({ subject: agent }: AgentPropertiesProps) => {
-  const { t } = useTranslation(meta.id);
-  const db = Obj.getDatabase(agent);
+  const spaceId = Obj.getDatabase(agent)?.spaceId;
 
-  // TODO(burdon): Factor out (separate component from container)?
-  const computeRuntime = useCapability(AutomationCapabilities.ComputeRuntime);
+  // TODO(burdon): Factor this out?
+  const syncTriggers = useSpaceCallback(
+    spaceId,
+    [] as const,
+    () => Operation.invoke(SyncTriggers, { agent: Ref.make(agent) }),
+    [agent],
+  );
+
+  // Sync triggers whenever the agent mutates (e.g., subscriptions change).
   useEffect(() => {
-    if (!db) {
+    if (!spaceId) {
       return;
     }
 
     return Obj.subscribe(agent, () => {
       queueMicrotask(() => {
-        const runtime = computeRuntime.getRuntime(db.spaceId);
-        runtime
-          .runPromise(
-            Operation.invoke(SyncTriggers, {
-              agent: Ref.make(agent),
-            }),
-          )
-          .catch((err) => log.catch(err));
+        syncTriggers().catch((err) => log.catch(err));
       });
     });
-  }, [db, agent, computeRuntime]);
-
-  // Build a filter matching objects of any schema annotated as a feed.
-  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;
-    });
-
-    return feedSchemas.length === 0 ? Filter.nothing() : Filter.or(...feedSchemas.map((schema) => Filter.type(schema)));
-  }, [db]);
-
-  const subscribedObjects = useQuery(db, feedFilter);
-
-  // Query all existing subscriptions (e.g., mail, calendar, etc.)
-  const existingSubscriptions = useAtomValue(
-    useMemo(
-      () =>
-        AtomObj.make(agent).pipe((_) =>
-          Atom.make((get) => {
-            const agentObj = get(_);
-            const selectedSubscriptions: Obj.Unknown[] = subscribedObjects.filter((object) =>
-              agentObj.subscriptions.some((subscription) => DXN.equals(subscription.dxn, Obj.getDXN(object))),
-            );
+  }, [spaceId, agent, syncTriggers]);
 
-            return selectedSubscriptions;
-          }),
-        ),
-      [agent, subscribedObjects],
-    ),
-  );
-
-  // Create/remove agent subscription.
-  const handleSubscriptionChange = useCallback(
-    (object: Obj.Unknown, checked: boolean) => {
-      Obj.change(agent, (agent) => {
-        if (checked) {
-          agent.subscriptions.push(Ref.fromDXN(Obj.getDXN(object)));
-        } else {
-          agent.subscriptions = agent.subscriptions.filter(
-            (subscription) => !DXN.equals(subscription.dxn, Obj.getDXN(object)),
-          );
-        }
-      });
-    },
-    [agent],
-  );
-
-  if (subscribedObjects.length === 0) {
-    return null;
-  }
-
-  return (
-    <div role='none' className='dx-expander flex flex-col'>
-      <Input.Root>
-        <Input.Label classNames='mt-form-gap'>{t('subscriptions.label')}</Input.Label>
-      </Input.Root>
-
-      {subscribedObjects.map((object) => (
-        <Input.Root key={object.id}>
-          <div className='flex items-center gap-2'>
-            <Input.Checkbox
-              checked={existingSubscriptions.includes(object)}
-              onCheckedChange={(checked) => {
-                handleSubscriptionChange(object, checked === true);
-              }}
-            />
-            <Input.Label>{Obj.getLabel(object) ?? object.id}</Input.Label>
-          </div>
-        </Input.Root>
-      ))}
-    </div>
-  );
+  return <AgentPropertiesComponent agent={agent} />;
 };

package/src/containers/BlueprintArticle/BlueprintArticle.tsx

@@ -5,7 +5,7 @@
 import React from 'react';
 
 import { type AppSurface } from '@dxos/app-toolkit/ui';
-import { type Blueprint } from '@dxos/blueprints';
+import { type Blueprint } from '@dxos/compute';
 import { Panel, Toolbar } from '@dxos/react-ui';
 import { useAttention } from '@dxos/react-ui-attention';
 
@@ -22,7 +22,7 @@ export const BlueprintArticle = ({ role, attendableId, subject }: BlueprintArtic
         <Toolbar.Root disabled={!hasAttention} />
       </Panel.Toolbar>
       <Panel.Content asChild>
-        <TemplateEditor id={subject.id} template={subject.instructions} />
+        <TemplateEditor id={subject.id} source={subject.instructions.source} />
       </Panel.Content>
     </Panel.Root>
   );

package/src/containers/ChatArticle/ChatArticle.stories.tsx

@@ -0,0 +1,76 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { AppActivationEvents } from '@dxos/app-toolkit';
+import { Chat } from '@dxos/assistant-toolkit';
+import { capabilities } from '@dxos/assistant-toolkit/testing';
+import { Feed, Filter, Ref } from '@dxos/echo';
+import { AutomationPlugin } from '@dxos/plugin-automation/testing';
+import { initializeIdentity, ClientPlugin } from '@dxos/plugin-client/testing';
+import { PreviewPlugin } from '@dxos/plugin-preview/testing';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { useQuery, useSpaces } from '@dxos/react-client/echo';
+import { Loading, withTheme } from '@dxos/react-ui/testing';
+
+import { translations } from '#translations';
+
+import { AssistantPlugin } from '../../AssistantPlugin';
+import { ChatArticle } from './ChatArticle';
+
+const DefaultStory = () => {
+  const [space] = useSpaces();
+  const [chat] = useQuery(space?.db, Filter.type(Chat.Chat));
+  if (!chat) {
+    return <Loading />;
+  }
+
+  return <ChatArticle role='article' subject={chat} attendableId='story' />;
+};
+
+const meta = {
+  title: 'plugins/plugin-assistant/containers/ChatArticle',
+  render: DefaultStory,
+  decorators: [
+    withTheme(),
+    withPluginManager({
+      setupEvents: [AppActivationEvents.SetupSettings],
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          types: [Chat.Chat, Feed.Feed],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* initializeIdentity(client);
+              const [space] = client.spaces.get();
+              yield* Effect.promise(() => space.waitUntilReady());
+
+              const feed = space.db.add(Feed.make());
+              space.db.add(Chat.make({ name: 'Test chat', feed: Ref.make(feed) }));
+              yield* Effect.promise(() => space.db.flush({ indexes: true }));
+            }),
+        }),
+        AutomationPlugin(),
+        AssistantPlugin(),
+        PreviewPlugin(),
+        StorybookPlugin({}),
+      ],
+      capabilities,
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/containers/{ChatContainer/ChatContainer.tsx → ChatArticle/ChatArticle.tsx}

@@ -8,15 +8,16 @@ import { Capabilities } from '@dxos/app-framework';
 import { useAtomCapability, useCapability } from '@dxos/app-framework/ui';
 import { type AppSurface } from '@dxos/app-toolkit/ui';
 import { type Space, getSpace } from '@dxos/client/echo';
-import { Feed, type Obj } from '@dxos/echo';
+import { type Obj } from '@dxos/echo';
+import { useRegistry } from '@dxos/react-client/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';
+import { useChatProcessor, useChatServices, useOnline, usePresets } from '#hooks';
+import { type Assistant, AssistantCapabilities, type ChatType } from '#types';
 
-export type ChatContainerProps = (
+export type ChatArticleProps = (
   | AppSurface.ObjectArticleProps<ChatType.Chat | undefined>
   | AppSurface.ObjectSectionProps<ChatType.Chat | undefined>
 ) & {
@@ -24,7 +25,7 @@ export type ChatContainerProps = (
   companionTo?: Obj.Unknown;
 } & Pick<ChatRootProps, 'onEvent'>;
 
-export const ChatContainer = forwardRef<HTMLDivElement, ChatContainerProps>((props, forwardedRef) => {
+export const ChatArticle = forwardRef<HTMLDivElement, ChatArticleProps>((props, forwardedRef) => {
   const { role, attendableId, subject: chat, space: spaceProp, companionTo, onEvent } = props;
   const parentId = attendableId ? getParentId(attendableId) : undefined;
   const space = spaceProp ?? getSpace(chat);
@@ -32,17 +33,17 @@ export const ChatContainer = forwardRef<HTMLDivElement, ChatContainerProps>((pro
   const runtime = useChatServices({ id: space?.id });
   const [online, setOnline] = useOnline();
   const { preset, ...chatProps } = usePresets(online);
-  const blueprintRegistry = useBlueprintRegistry();
+  const registry = useRegistry();
   const processor = useChatProcessor({
     space,
     chat,
     preset,
     runtime,
-    blueprintRegistry,
+    registry,
     settings,
   });
 
-  const registry = useCapability(Capabilities.AtomRegistry);
+  const atomRegistry = useCapability(Capabilities.AtomRegistry);
   const stateAtom = useCapability(AssistantCapabilities.State);
   const pendingSubmitted = useRef(false);
   useEffect(() => {
@@ -50,35 +51,47 @@ export const ChatContainer = forwardRef<HTMLDivElement, ChatContainerProps>((pro
       return;
     }
 
-    const state = registry.get(stateAtom);
+    const state = atomRegistry.get(stateAtom);
     const pendingPrompt = state.pendingPrompts[attendableId];
     if (pendingPrompt) {
       pendingSubmitted.current = true;
-      registry.update(stateAtom, (current) => {
+      atomRegistry.update(stateAtom, (current) => {
         const { [attendableId]: _, ...rest } = current.pendingPrompts;
         return { ...current, pendingPrompts: rest };
       });
       void processor.request({ message: pendingPrompt });
     }
-  }, [processor, attendableId, registry, stateAtom]);
+  }, [processor, attendableId, atomRegistry, stateAtom]);
 
   const feedTarget = chat?.feed.target;
-  const queue = space && feedTarget ? space.queues.get(Feed.getQueueDxn(feedTarget)!) : undefined;
+  const view = (chat?.view as Assistant.ChatView | undefined) ?? settings.chatView;
 
   if (!processor) {
     return null;
   }
 
   return (
-    <ChatComponent.Root db={space?.db} chat={chat} queue={queue} processor={processor} onEvent={onEvent}>
+    <ChatComponent.Root db={space?.db} chat={chat} feed={feedTarget} processor={processor} onEvent={onEvent}>
       <Panel.Root role={role} ref={forwardedRef}>
         <Panel.Toolbar className='bg-toolbar-surface'>
           <ChatComponent.Toolbar classNames='dx-document' attendableId={attendableId} companionTo={companionTo} />
         </Panel.Toolbar>
         <Panel.Content>
-          <ChatComponent.Viewport>
-            <ChatComponent.Thread />
-            <div role='none' className='dx-document p-4'>
+          <ChatComponent.Content>
+            <div className='dx-container relative'>
+              <ChatComponent.Thread viewType={view} />
+              {view !== 'summary' && (
+                <div className='absolute bottom-2 left-0 right-0'>
+                  <div className='dx-document px-4'>
+                    <ChatComponent.Status classNames='px-3 rounded-sm bg-group-surface' />
+                  </div>
+                </div>
+              )}
+            </div>
+            <div className='dx-document px-4 pb-4'>
+              <div className='flex flex-col items-center py-2 overflow-hidden'>
+                <ChatComponent.TaskList classNames='max-h-[120px] border border-separator rounded-sm text-description' />
+              </div>
               <ChatComponent.Prompt
                 {...chatProps}
                 outline
@@ -87,7 +100,7 @@ export const ChatContainer = forwardRef<HTMLDivElement, ChatContainerProps>((pro
                 onOnlineChange={setOnline}
               />
             </div>
-          </ChatComponent.Viewport>
+          </ChatComponent.Content>
         </Panel.Content>
       </Panel.Root>
     </ChatComponent.Root>

package/src/containers/ChatArticle/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { ChatArticle as default } from './ChatArticle';

package/src/containers/ChatCompanion/ChatCompanion.tsx

@@ -2,34 +2,32 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Array from 'effect/Array';
-import * as Function from 'effect/Function';
 import * as Option from 'effect/Option';
 import React, { forwardRef, useCallback, useMemo } from 'react';
 
-import { useCapabilities, useOperationInvoker } from '@dxos/app-framework/ui';
-import { AppCapabilities } from '@dxos/app-toolkit';
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { BlueprintsAnnotation } from '@dxos/app-toolkit';
 import { type AppSurface } 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/operations';
-import { useQuery } from '@dxos/react-client/echo';
+import { Blueprint } from '@dxos/compute';
+import { Entity, Filter, Obj, Ref, Type } from '@dxos/echo';
+import { SpaceOperation } from '@dxos/plugin-space';
+import { useQuery, useRegistry } from '@dxos/react-client/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
 
 import { type ChatEvent } from '#components';
-import { useBlueprintRegistry, useContextBinder } from '#hooks';
-import { AssistantOperation } from '#operations';
+import { useContextBinder } from '#hooks';
+import { AssistantOperation } from '#types';
 
-import ChatContainer from '../ChatContainer';
+import ChatArticle from '../ChatArticle';
 
 export type ChatCompanionProps = AppSurface.ArticleProps<Chat.Chat, {}, Obj.Unknown>;
 
 export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
   ({ role, subject: chat, companionTo, attendableId }, forwardedRef) => {
     const { invokePromise } = useOperationInvoker();
-    const blueprintRegistry = useBlueprintRegistry();
+    const registry = useRegistry();
     const space = getSpace(companionTo);
     const feedTarget = chat?.feed.target;
     const binder = useContextBinder(space, feedTarget);
@@ -41,7 +39,7 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
           return;
         }
 
-        if (event.type === 'submit' && !getSpace(chat)) {
+        if (event.type === 'submit' && !Obj.getDatabase(chat)) {
           await invokePromise(SpaceOperation.AddObject, {
             object: chat,
             target: space.db,
@@ -62,62 +60,43 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
       [chat, space, companionTo, invokePromise],
     );
 
-    const metadata = useCapabilities(AppCapabilities.Metadata);
-    const blueprintKeys = useMemo(
-      () =>
-        Function.pipe(
-          metadata,
-          Array.findFirst(
-            (
-              capability,
-            ): capability is {
-              id: string;
-              metadata: { blueprints?: string[] };
-            } => capability.id === Obj.getTypename(companionTo),
-          ),
-          Option.flatMap((c) => Option.fromNullable(c.metadata.blueprints)),
-          Option.getOrElse(() => [] as string[]),
-        ),
-      [metadata, companionTo],
-    );
+    const blueprintKeys = useMemo(() => {
+      const schema = companionTo ? Obj.getType(companionTo) : undefined;
+      if (!schema) {
+        return [] as string[];
+      }
+      return Option.getOrElse(() => [] as string[])(BlueprintsAnnotation.get(Type.getSchema(schema)));
+    }, [companionTo]);
     const existingBlueprints = useQuery(space?.db, Filter.type(Blueprint.Blueprint));
     const pluginBlueprints = useMemo(
-      () => existingBlueprints.filter((blueprint) => blueprintKeys.includes(blueprint.key)),
+      () =>
+        existingBlueprints.filter((blueprint) => {
+          const key = Obj.getMeta(blueprint).key;
+          return key !== undefined && blueprintKeys.includes(key);
+        }),
       [existingBlueprints, blueprintKeys],
     );
 
-    // Initialize related blueprints that are not already in the space.
-    useAsyncEffect(async () => {
-      if (!space) {
-        return;
-      }
-
-      // NOTE: This must be run instead of using the useQuery result to avoid duplicates.
-      const existingBlueprints = await space.db.query(Filter.type(Blueprint.Blueprint)).run();
-      for (const key of blueprintKeys) {
-        const existingBlueprint = existingBlueprints.find((blueprint) => blueprint.key === key);
-        if (existingBlueprint) {
-          continue;
-        }
-
-        const blueprint = blueprintRegistry.getByKey(key);
-        if (!blueprint) {
-          continue;
-        }
-
-        space.db.add(Obj.clone(blueprint, { deep: true }));
-      }
-    }, [space, blueprintRegistry, blueprintKeys]);
-
     useAsyncEffect(async () => {
       if (!binder?.isOpen) {
         return;
       }
 
-      if (pluginBlueprints.length > 0) {
-        await binder.bind({
-          blueprints: pluginBlueprints.map((blueprint) => Ref.make(blueprint)),
+      // Bind annotated blueprints: use key URI for registry blueprints (no DB clone needed).
+      if (blueprintKeys.length > 0) {
+        const registryKeys = blueprintKeys.filter((key) => {
+          const candidate = registry.list().find((e) => Entity.getMeta(e)?.key === key);
+          return candidate != null && Obj.instanceOf(Blueprint.Blueprint, candidate);
         });
+        // DB-forked blueprints (in space but not in registry).
+        const dbForks = pluginBlueprints.filter((bp) => !registryKeys.includes(Obj.getMeta(bp).key ?? ''));
+
+        if (registryKeys.length > 0) {
+          await binder.bind({ blueprints: registryKeys.map((key) => Ref.fromURI(Blueprint.registryURI(key))) });
+        }
+        if (dbForks.length > 0) {
+          await binder.bind({ blueprints: dbForks.map((blueprint) => Ref.make(blueprint)) });
+        }
       }
 
       if (Obj.instanceOf(Blueprint.Blueprint, companionTo)) {
@@ -125,10 +104,10 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
       } else {
         await binder.bind({ objects: [Ref.make(companionTo)] });
       }
-    }, [binder, companionTo, blueprintKeys]);
+    }, [binder, companionTo, pluginBlueprints]);
 
     return (
-      <ChatContainer
+      <ChatArticle
         role={role ?? 'article'}
         space={space}
         subject={chat}

package/src/containers/ChatDialog/ChatDialog.tsx

@@ -7,13 +7,14 @@ import React, { useCallback, useState } from 'react';
 import { useAtomCapability } from '@dxos/app-framework/ui';
 import { type Chat as ChatTypes } from '@dxos/assistant-toolkit';
 import { Obj } from '@dxos/echo';
+import { useRegistry } from '@dxos/react-client/echo';
 import { useTranslation } from '@dxos/react-ui';
 import { ChatDialog as NaturalChatDialog } from '@dxos/react-ui-chat';
 
 import { Chat, type ChatRootProps } from '#components';
-import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '#hooks';
+import { useChatProcessor, useChatServices, useOnline, usePresets } from '#hooks';
 import { meta } from '#meta';
-import { AssistantCapabilities } from '#types';
+import { type Assistant, AssistantCapabilities } from '#types';
 
 export type ChatDialogProps = {
   chat?: ChatTypes.Chat;
@@ -27,14 +28,8 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
   const runtime = useChatServices({ id: db?.spaceId });
   const [online, setOnline] = useOnline();
   const { preset, ...chatProps } = usePresets(online);
-  const blueprintRegistry = useBlueprintRegistry();
-  const processor = useChatProcessor({
-    chat,
-    preset,
-    runtime,
-    blueprintRegistry,
-    settings,
-  });
+  const registry = useRegistry();
+  const processor = useChatProcessor({ chat, preset, runtime, registry, settings });
 
   // TODO(burdon): Refocus when open.
   const [open, setOpen] = useState(true);
@@ -61,7 +56,7 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
       <NaturalChatDialog.Root open={open} expanded={expanded} onOpenChange={setOpen}>
         <NaturalChatDialog.Header title={t('assistant-dialog.title')} />
         <NaturalChatDialog.Content>
-          <Chat.Thread />
+          <Chat.Thread viewType={(chat.view as Assistant.ChatView | undefined) ?? settings.chatView} />
         </NaturalChatDialog.Content>
         <NaturalChatDialog.Footer classNames='p-1.5'>
           <Chat.Prompt {...chatProps} preset={preset?.id} online={online} onOnlineChange={setOnline} expandable />

package/src/containers/PlanArticle/PlanArticle.tsx

@@ -0,0 +1,33 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import React from 'react';
+
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { type Plan } from '@dxos/assistant-toolkit';
+import { Panel, ScrollArea, Toolbar } from '@dxos/react-ui';
+import { useAttention } from '@dxos/react-ui-attention';
+
+import { TaskList } from '#components';
+
+export type PlanArticleProps = AppSurface.ObjectArticleProps<Plan.Plan>;
+
+export const PlanArticle = ({ role, attendableId, subject }: PlanArticleProps) => {
+  const { hasAttention } = useAttention(attendableId);
+
+  return (
+    <Panel.Root role={role} classNames='dx-document'>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root disabled={!hasAttention} />
+      </Panel.Toolbar>
+      <Panel.Content asChild>
+        <ScrollArea.Root orientation='vertical'>
+          <ScrollArea.Viewport>
+            <TaskList plan={subject} />
+          </ScrollArea.Viewport>
+        </ScrollArea.Root>
+      </Panel.Content>
+    </Panel.Root>
+  );
+};

package/src/containers/PlanArticle/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export { PlanArticle as default } from './PlanArticle';