@dxos/plugin-assistant 0.8.4-main.9735255 → 0.8.4-main.abd8ff62ef

package/src/containers/AgentArticle/index.ts

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

package/src/containers/AgentProperties/AgentProperties.stories.tsx

@@ -0,0 +1,101 @@
+//
+// 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 { Plan, Agent } from '@dxos/assistant-toolkit';
+import { Obj, Ref } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { AutomationPlugin } from '@dxos/plugin-automation';
+import { ClientPlugin } from '@dxos/plugin-client';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { corePlugins } from '@dxos/plugin-testing';
+import { Filter, useQuery, useSpaces } from '@dxos/react-client/echo';
+import { Button } from '@dxos/react-ui';
+import { ObjectProperties } from '@dxos/react-ui-form';
+import { Loading, withLayout } from '@dxos/react-ui/testing';
+import { Text } from '@dxos/schema';
+import { Organization } from '@dxos/types';
+
+import { translations } from '#translations';
+
+import { AssistantPlugin } from '../../AssistantPlugin';
+import { AgentProperties } from './AgentProperties';
+
+type DefaultStoryProps = {};
+
+const DefaultStory = (_: DefaultStoryProps) => {
+  const [space] = useSpaces();
+  const [agent] = useQuery(space?.db, Filter.type(Agent.Agent));
+  if (!agent) {
+    return <Loading />;
+  }
+
+  return (
+    <ObjectProperties object={agent}>
+      <AgentProperties role='object-properties' subject={agent} />
+      <Button
+        classNames='mt-form-gap'
+        onClick={() => {
+          log.info('agent', { agent, instructions: agent.instructions.target });
+        }}
+      >
+        Debug
+      </Button>
+    </ObjectProperties>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-assistant/containers/AgentProperties',
+  render: DefaultStory,
+  decorators: [
+    withLayout({ layout: 'column' }),
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          types: [Agent.Agent, Plan.Plan, Text.Text, Organization.Organization],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* initializeIdentity(client);
+              const [space] = client.spaces.get();
+              yield* Effect.promise(() => space.waitUntilReady());
+
+              const organization = space.db.add(
+                Obj.make(Organization.Organization, {
+                  name: 'Acme Corp',
+                  description: 'Sample organization for the story.',
+                }),
+              );
+
+              space.db.add(
+                Obj.make(Agent.Agent, {
+                  instructions: Ref.make(Text.make()),
+                  plan: Ref.make(Plan.makePlan({ tasks: [] })),
+                  artifacts: [{ name: 'Organization', data: Ref.make(organization) }],
+                  subscriptions: [],
+                }),
+              );
+            }),
+        }),
+        AutomationPlugin(),
+        AssistantPlugin(),
+      ],
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<DefaultStoryProps>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/containers/AgentProperties/AgentProperties.tsx

@@ -0,0 +1,127 @@
+//
+// 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 { useCapability } from '@dxos/app-framework/ui';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Agent, SyncTriggers } from '@dxos/assistant-toolkit';
+import { Operation } from '@dxos/compute';
+import { DXN, Obj, Ref } from '@dxos/echo';
+import { AtomObj } from '@dxos/echo-atom';
+import { log } from '@dxos/log';
+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';
+
+export type AgentPropertiesProps = AppSurface.ObjectPropertiesProps<Agent.Agent>;
+
+export const AgentProperties = ({ subject: agent }: AgentPropertiesProps) => {
+  const { t } = useTranslation(meta.id);
+  const db = Obj.getDatabase(agent);
+
+  // TODO(burdon): Factor out (separate component from container)?
+  const computeRuntime = useCapability(AutomationCapabilities.ComputeRuntime);
+  useEffect(() => {
+    if (!db) {
+      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));
+      });
+    });
+  }, [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))),
+            );
+
+            return selectedSubscriptions;
+          }),
+        ),
+      [agent, subscribedObjects],
+    ),
+  );
+
+  // Create/remove agent subscription.
+  const handleSubscriptionChange = useCallback(
+    (object: Obj.Unknown, checked: boolean) => {
+      Obj.update(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>
+  );
+};

package/src/containers/AgentProperties/index.ts

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

package/src/containers/BlueprintArticle/BlueprintArticle.tsx

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { type Blueprint } from '@dxos/compute';
+import { Panel, Toolbar } from '@dxos/react-ui';
+import { useAttention } from '@dxos/react-ui-attention';
+
+import { TemplateEditor } from '#components';
+
+export type BlueprintArticleProps = AppSurface.ObjectArticleProps<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,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { BlueprintArticle as default } from './BlueprintArticle';

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

@@ -5,63 +5,43 @@
 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 { Blueprint } from '@dxos/blueprints';
+import { useCapabilities, useOperationInvoker } from '@dxos/app-framework/ui';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Chat } from '@dxos/assistant-toolkit';
 import { getSpace } from '@dxos/client/echo';
+import { Blueprint } from '@dxos/compute';
 import { Filter, Obj, Ref } from '@dxos/echo';
-import { SpaceOperation } from '@dxos/plugin-space/types';
+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 = AppSurface.ArticleProps<Chat.Chat, {}, Obj.Unknown>;
 
 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 binder = useContextBinder(chatQueue);
+    const feedTarget = chat?.feed.target;
+    const binder = useContextBinder(space, feedTarget);
 
-    // 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 +49,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 +62,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 +105,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]);
 
@@ -149,9 +129,10 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
 
     return (
       <ChatContainer
-        role={role}
+        role={role ?? 'article'}
         space={space}
         subject={chat}
+        attendableId={attendableId}
         companionTo={companionTo}
         onEvent={handleEvent}
         ref={forwardedRef}
@@ -159,5 +140,3 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
     );
   },
 );
-
-export default ChatCompanion;

package/src/containers/ChatCompanion/index.ts

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

package/src/containers/ChatContainer/ChatContainer.tsx

@@ -0,0 +1,105 @@
+//
+// 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 AppSurface } 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 { type Assistant, AssistantCapabilities, type ChatType } from '#types';
+
+export type ChatContainerProps = (
+  | AppSurface.ObjectArticleProps<ChatType.Chat | undefined>
+  | AppSurface.ObjectSectionProps<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;
+  const view = (chat?.view as Assistant.ChatView | undefined) ?? settings.chatView;
+
+  if (!processor) {
+    return null;
+  }
+
+  return (
+    <ChatComponent.Root db={space?.db} chat={chat} feed={queue} 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.Content>
+            <div role='none' className='dx-container relative'>
+              <ChatComponent.Thread viewType={view} />
+              {view !== 'summary' && (
+                <div role='none' className='absolute bottom-2 left-0 right-0'>
+                  <div role='none' className='dx-document px-4'>
+                    <ChatComponent.Status classNames='px-3 rounded-sm bg-group-surface' />
+                  </div>
+                </div>
+              )}
+            </div>
+            <div role='none' className='dx-document px-4 pb-4'>
+              <ChatComponent.Prompt
+                {...chatProps}
+                outline
+                preset={preset?.id}
+                online={online}
+                onOnlineChange={setOnline}
+              />
+            </div>
+          </ChatComponent.Content>
+        </Panel.Content>
+      </Panel.Root>
+    </ChatComponent.Root>
+  );
+});

package/src/containers/ChatContainer/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { ChatContainer as default } from './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 { type Assistant, AssistantCapabilities } from '#types';
 
 export type ChatDialogProps = {
-  chat?: Assistant.Chat;
+  chat?: ChatTypes.Chat;
 };
 
 export const ChatDialog = ({ chat }: ChatDialogProps) => {
@@ -24,17 +24,11 @@ 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,
-    blueprintRegistry,
-    settings,
-  });
+  const processor = useChatProcessor({ chat, preset, runtime, blueprintRegistry, settings });
 
   // TODO(burdon): Refocus when open.
   const [open, setOpen] = useState(true);
@@ -59,9 +53,9 @@ 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 />
+          <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 />
@@ -70,5 +64,3 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
     </Chat.Root>
   );
 };
-
-export default ChatDialog;

package/src/containers/ChatDialog/index.ts

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

package/src/containers/RoutineArticle/RoutineArticle.tsx

@@ -0,0 +1,59 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useMemo } from 'react';
+
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { AgentPrompt } from '@dxos/assistant-toolkit';
+import { type Routine } from '@dxos/compute';
+import { Operation } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { useComputeRuntimeCallback } from '@dxos/plugin-automation/hooks';
+import { Panel, Toolbar, useTranslation } from '@dxos/react-ui';
+import { useAttention } from '@dxos/react-ui-attention';
+
+import { TemplateEditor } from '#components';
+import { meta } from '#meta';
+
+export type RoutineArticleProps = AppSurface.ObjectArticleProps<Routine.Routine>;
+
+export const RoutineArticle = ({ role, attendableId, subject }: RoutineArticleProps) => {
+  const { t } = useTranslation(meta.id);
+  const { hasAttention } = useAttention(attendableId);
+  const db = Obj.getDatabase(subject);
+
+  const inputData = useMemo<Operation.Definition.Input<typeof AgentPrompt> | undefined>(
+    () =>
+      subject && db
+        ? {
+            prompt: db.makeRef(Obj.getDXN(subject)),
+            input: {},
+          }
+        : undefined,
+    [subject, db],
+  );
+
+  const handleRun = useComputeRuntimeCallback(
+    db?.spaceId,
+    () => {
+      invariant(inputData);
+      return Operation.invoke(AgentPrompt, inputData);
+    },
+    [inputData],
+  );
+
+  return (
+    <Panel.Root role={role} className='dx-document'>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root disabled={!hasAttention} onClick={handleRun}>
+          <Toolbar.IconButton iconOnly icon='ph--play--regular' label={t('run-prompt.label')} onClick={handleRun} />
+        </Toolbar.Root>
+      </Panel.Toolbar>
+      <Panel.Content asChild>
+        <TemplateEditor id={subject.id} template={subject.instructions} />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};

package/src/containers/RoutineArticle/index.ts

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