@dxos/plugin-assistant 0.9.1-main.c7dcc2e112 → 0.9.1-staging.ee54ba693a

package/src/capabilities/companion-chat-provisioner.ts

@@ -12,9 +12,16 @@ import { AppCapabilities } from '@dxos/app-toolkit';
 import { Chat } from '@dxos/assistant-toolkit';
 import { Obj } from '@dxos/echo';
 import { log } from '@dxos/log';
-import { DeckCapabilities, PLANK_COMPANION_TYPE, type StoredDeckState } from '@dxos/plugin-deck';
+import { AttentionCapabilities } from '@dxos/plugin-attention';
+import {
+  COMPANION_VIEW_STATE_CONTEXT,
+  DeckCapabilities,
+  PLANK_COMPANION_TYPE,
+  type StoredDeckState,
+  companionVariantAspect,
+} from '@dxos/plugin-deck';
 import { getLinkedVariant } from '@dxos/react-ui-attention';
-import { byPosition } from '@dxos/util';
+import { Position } from '@dxos/util';
 
 import { ASSISTANT_COMPANION_VARIANT } from '#meta';
 import { AssistantCapabilities, AssistantOperation } from '#types';
@@ -31,6 +38,10 @@ export default Capability.makeModule(
     const deckStateAtom = yield* Capability.get(DeckCapabilities.State);
     const cacheAtom = yield* Capability.get(AssistantCapabilities.CompanionChatCache);
     const stateAtom = yield* Capability.get(AssistantCapabilities.State);
+    // The selected companion variant moved off deck state into a global view-state aspect; read and
+    // observe it directly so a tab switch (which no longer touches deck state) still re-provisions.
+    const viewState = yield* Capability.get(AttentionCapabilities.ViewState);
+    const variantAtom = viewState.atom(companionVariantAspect, COMPANION_VIEW_STATE_CONTEXT);
 
     const plankSubs = new Map<string, () => void>();
 
@@ -91,6 +102,7 @@ export default Capability.makeModule(
         return;
       }
 
+      const companionVariant = registry.get(variantAtom).variant;
       const plankIds = new Set(deck.solo ? [deck.solo] : deck.active);
 
       // Remove subscriptions for planks that are no longer active.
@@ -101,18 +113,20 @@ export default Capability.makeModule(
       }
 
       for (const plankId of plankIds) {
-        const resolved = provisionForPlank(plankId, deck.companionVariant);
+        const resolved = provisionForPlank(plankId, companionVariant);
 
         if (resolved) {
           // Already provisioned — no need to watch connections.
           unsubPlank(plankId);
         } else if (!plankSubs.has(plankId)) {
           // Not yet resolved — subscribe to child connections so we re-try
-          // when graph builder extensions add companion nodes (after expand).
+          // when graph builder extensions add companion nodes (after expand). This subscription
+          // outlives the current `provision()` run, so re-read the latest variant at callback time
+          // rather than closing over the one captured here.
           plankSubs.set(
             plankId,
             registry.subscribe(graph.connections(plankId, 'child'), () => {
-              if (provisionForPlank(plankId, deck.companionVariant)) {
+              if (provisionForPlank(plankId, registry.get(variantAtom).variant)) {
                 unsubPlank(plankId);
               }
             }),
@@ -125,11 +139,13 @@ export default Capability.makeModule(
 
     const unsub1 = registry.subscribe(deckStateAtom, provision);
     const unsub2 = registry.subscribe(stateAtom, provision);
+    const unsub3 = registry.subscribe(variantAtom, provision);
 
     return Capability.contributes(Capabilities.Null, null, () =>
       Effect.sync(() => {
         unsub1();
         unsub2();
+        unsub3();
         unsubAllPlanks();
       }),
     );
@@ -147,7 +163,7 @@ const resolveEffectiveVariant = (
 ): string | undefined => {
   const companions = Graph.getConnections(graph, plankId, 'child')
     .filter((node) => node.type === PLANK_COMPANION_TYPE)
-    .toSorted((a, b) => byPosition(a.properties, b.properties));
+    .toSorted((a, b) => Position.compare(a.properties, b.properties));
 
   if (companions.length === 0) {
     return undefined;

package/src/capabilities/{integration-provider.ts → connector.ts}

@@ -7,11 +7,7 @@ import * as Schema from 'effect/Schema';
 
 import { Capability } from '@dxos/app-framework';
 import { Obj, Ref } from '@dxos/echo';
-import {
-  type CredentialForm,
-  Integration,
-  IntegrationProvider as IntegrationProviderCapability,
-} from '@dxos/plugin-integration';
+import { Connection, Connector, type CredentialForm } from '@dxos/plugin-connector';
 import { AccessToken } from '@dxos/types';
 
 import { ANTHROPIC_PROVIDER_ID, ANTHROPIC_SOURCE } from '../constants';
@@ -56,25 +52,24 @@ const credentialForm: CredentialForm<Schema.Schema.Type<typeof AnthropicTokenFor
   defaultValues: { token: '' },
   // Validates before the dialog closes so 401/403 errors are shown inline.
   onValidate: ({ values }) => validateAnthropicKey(values.token.trim()),
-  onSubmit: ({ values, provider }) =>
+  onSubmit: ({ values, connector }) =>
     Effect.sync(() => {
       const accessToken = Obj.make(AccessToken.AccessToken, {
         source: ANTHROPIC_SOURCE,
         token: values.token.trim(),
       });
-      const integration = Obj.make(Integration.Integration, {
-        name: provider.label ?? 'Anthropic',
-        providerId: provider.id,
+      const connection = Obj.make(Connection.Connection, {
+        name: connector.label ?? 'Anthropic',
+        connectorId: connector.id,
         accessToken: Ref.make(accessToken),
-        targets: [],
       });
-      return { kind: 'complete' as const, accessToken, integration };
+      return { kind: 'complete' as const, accessToken, connection };
     }),
 };
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
-    return Capability.contributes(IntegrationProviderCapability, [
+    return Capability.contributes(Connector, [
       {
         id: ANTHROPIC_PROVIDER_ID,
         source: ANTHROPIC_SOURCE,

package/src/capabilities/create-object.ts

@@ -5,11 +5,11 @@
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import { Capability, Capabilities } from '@dxos/app-framework';
-import { Agent, AgentBlueprint, Chat } from '@dxos/assistant-toolkit';
-import { Blueprint, Operation, Routine, ServiceResolver } from '@dxos/compute';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Agent, AgentSkill, Chat } from '@dxos/assistant-toolkit';
+import { Operation, ServiceResolver, Skill } from '@dxos/compute';
 import { Sequence } from '@dxos/conductor';
-import { Database, Feed, Obj, Type } from '@dxos/echo';
+import { Database, Obj, Type } from '@dxos/echo';
 import { SpaceCapabilities, SpaceOperation } from '@dxos/plugin-space';
 
 import { AssistantOperation } from '#types';
@@ -30,34 +30,19 @@ export default Capability.makeModule(
             return yield* Operation.invoke(SpaceOperation.AddObject, {
               object,
               target: options.target,
-              hidden: true,
               targetNodeId: options.targetNodeId ?? getChatsPath(options.db.spaceId),
             });
           }),
       }),
       Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
-        id: Type.getTypename(Blueprint.Blueprint),
-        inputSchema: AssistantOperation.BlueprintForm,
+        id: Type.getTypename(Skill.Skill),
+        inputSchema: AssistantOperation.SkillForm,
         createObject: (props, options) =>
           Effect.gen(function* () {
-            const object = Blueprint.make(props);
+            const object = Skill.make(props);
             return yield* Operation.invoke(SpaceOperation.AddObject, {
               object,
               target: options.target,
-              hidden: true,
-              targetNodeId: options.targetNodeId,
-            });
-          }),
-      }),
-      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
-        id: Type.getTypename(Routine.Routine),
-        createObject: (props, options) =>
-          Effect.gen(function* () {
-            const object = Routine.make(props);
-            return yield* Operation.invoke(SpaceOperation.AddObject, {
-              object,
-              target: options.target,
-              hidden: true,
               targetNodeId: options.targetNodeId,
             });
           }),
@@ -70,7 +55,6 @@ export default Capability.makeModule(
             return yield* Operation.invoke(SpaceOperation.AddObject, {
               object,
               target: options.target,
-              hidden: true,
               targetNodeId: options.targetNodeId,
             });
           }),
@@ -79,17 +63,16 @@ export default Capability.makeModule(
         id: Type.getTypename(Agent.Agent),
         createObject: (props, options) =>
           Effect.gen(function* () {
-            const object = yield* Agent.makeInitialized({ name: '', instructions: '' }, AgentBlueprint.make());
+            const object = yield* Agent.makeInitialized({ name: '', instructions: '' }, AgentSkill.make());
 
             return yield* Operation.invoke(SpaceOperation.AddObject, {
               object,
               target: options.target,
-              hidden: true,
               targetNodeId: options.targetNodeId,
             });
           }).pipe(
             Effect.provide(
-              ServiceResolver.provide({ space: options.db.spaceId }, Database.Service, Feed.FeedService).pipe(
+              ServiceResolver.provide({ space: options.db.spaceId }, Database.Service).pipe(
                 Layer.provide(Capability.asLayer(Capabilities.ServiceResolver, ServiceResolver.ServiceResolver)),
               ),
             ),

package/src/capabilities/index.ts

@@ -14,13 +14,11 @@ export const AiService = Capability.lazy<AssistantPluginOptions | void, Capabili
   'AiService',
   () => import('./ai-service'),
 );
-export const IntegrationProvider = Capability.lazy(
-  'AnthropicIntegrationProvider',
-  () => import('./integration-provider'),
-);
+export const Connector = Capability.lazy('AnthropicConnector', () => import('./connector'));
 export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));
+export const NavigationResolver = Capability.lazy('NavigationResolver', () => import('./navigation-resolver'));
 export const AutomationTemplates = Capability.lazy('AutomationTemplates', () => import('./automation-templates'));
-export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));
+export const SkillDefinition = Capability.lazy('SkillDefinition', () => import('./skill-definition'));
 export const CompanionChatProvisioner = Capability.lazy(
   'CompanionChatProvisioner',
   () => import('./companion-chat-provisioner'),

package/src/capabilities/markdown-extension.ts

@@ -7,8 +7,7 @@ import * as Effect from 'effect/Effect';
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { Obj } from '@dxos/echo';
 import { MarkdownCapabilities } from '@dxos/plugin-markdown/types';
-
-import { AssistantOperation } from '#types';
+import { RoutineOperation } from '@dxos/plugin-routine/types';
 
 import { promptRunExtension } from '../extensions';
 
@@ -35,7 +34,7 @@ export default Capability.makeModule(
 
         return promptRunExtension({
           onRun: (promptText) => {
-            void invokePromise(AssistantOperation.RunPromptInNewChat, { db, prompt: promptText });
+            void invokePromise(RoutineOperation.RunPromptInNewChat, { db, instructions: promptText });
           },
         });
       },

package/src/capabilities/navigation-resolver.ts

@@ -0,0 +1,20 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities, Paths, TypeSection } from '@dxos/app-toolkit';
+import { Chat } from '@dxos/assistant-toolkit';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return [
+      Capability.contributes(
+        AppCapabilities.NavigationPathResolver,
+        TypeSection.createTypeSectionPathResolver(Chat.Chat, { groupId: Paths.GroupSegments.ai }),
+      ),
+    ];
+  }),
+);

package/src/capabilities/react-surface.tsx

@@ -8,35 +8,33 @@ import React, { type ComponentProps, useEffect } from 'react';
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { Surface, useSettingsState } from '@dxos/app-framework/ui';
 import { AppSurface, useActiveSpace } from '@dxos/app-toolkit/ui';
-import { Chat, Agent, Plan } from '@dxos/assistant-toolkit';
+import { Agent, Chat, Plan } from '@dxos/assistant-toolkit';
 import { getSpace } from '@dxos/client/echo';
-import { Blueprint, Routine } from '@dxos/compute';
+import { Instructions } from '@dxos/compute';
 import { Sequence } from '@dxos/conductor';
 import { InvocationTraceContainer } from '@dxos/devtools';
 import { Feed, Obj } from '@dxos/echo';
 import { log } from '@dxos/log';
 import { SpaceHomeContent, SpaceHomePinBottom } from '@dxos/plugin-space';
-import { Prompts } from '@dxos/plugin-space';
 import { Panel } from '@dxos/react-ui';
+import { Position } from '@dxos/util';
 
-import { AssistantSettings } from '#components';
 import {
-  BlueprintArticle,
-  ChatCompanion,
-  ChatArticle,
-  ChatDialog,
   AgentArticle,
   AgentProperties,
+  AssistantSettings,
+  ChatArticle,
+  ChatCompanion,
+  ChatDialog,
+  IntegrationPrompt,
   PlanArticle,
-  RoutineArticle,
-  RoutineList,
   SpaceHomePrompt,
   SpaceHomeSuggestions,
   TracePanel,
   TriggerStatus,
 } from '#containers';
 import { ASSISTANT_COMPANION_VARIANT, ASSISTANT_DIALOG, meta } from '#meta';
-import { type Assistant } from '#types';
+import { type Assistant, ChatSurface } from '#types';
 
 export default Capability.makeModule(() =>
   Effect.succeed(
@@ -57,7 +55,7 @@ export default Capability.makeModule(() =>
       Surface.create({
         id: 'spaceHomeSuggestions',
         filter: Surface.makeFilter(SpaceHomeContent),
-        position: 'last',
+        position: Position.last,
         component: ({ data }) => <SpaceHomeSuggestions space={data.space} />,
       }),
       Surface.create({
@@ -106,7 +104,7 @@ export default Capability.makeModule(() =>
           AppSurface.literal(AppSurface.Article, 'invocations'),
           AppSurface.oneOf(
             AppSurface.companion(AppSurface.Article, Sequence.Sequence),
-            AppSurface.companion(AppSurface.Article, Routine.Routine),
+            AppSurface.companion(AppSurface.Article, Instructions.Instructions),
           ),
         ),
         component: ({ data, role }) => {
@@ -114,7 +112,7 @@ export default Capability.makeModule(() =>
           const feed = space?.properties.invocationTraceFeed?.target;
           const feedDXN = feed ? Feed.getQueueUri(feed) : undefined;
           // TODO(wittjosiah): Support invocation filtering for prompts.
-          const target = Obj.instanceOf(Routine.Routine, data.companionTo) ? undefined : data.companionTo;
+          const target = Obj.instanceOf(Instructions.Instructions, data.companionTo) ? undefined : data.companionTo;
 
           return (
             <Panel.Root role={role} className='dx-document'>
@@ -125,20 +123,6 @@ export default Capability.makeModule(() =>
           );
         },
       }),
-      Surface.create({
-        id: 'blueprint',
-        filter: AppSurface.object(AppSurface.Article, Blueprint.Blueprint),
-        component: ({ data, role }) => (
-          <BlueprintArticle role={role} subject={data.subject} attendableId={data.attendableId} />
-        ),
-      }),
-      Surface.create({
-        id: 'prompt',
-        filter: AppSurface.object(AppSurface.Article, Routine.Routine),
-        component: ({ data, role }) => (
-          <RoutineArticle role={role} subject={data.subject} attendableId={data.attendableId} />
-        ),
-      }),
       Surface.create({
         id: 'plan',
         filter: AppSurface.object(AppSurface.Article, Plan.Plan),
@@ -167,6 +151,15 @@ export default Capability.makeModule(() =>
           return <TracePanel space={space} />;
         },
       }),
+      Surface.create({
+        id: 'integrationPrompt',
+        filter: Surface.makeFilter(ChatSurface, (data) => data.role === 'integration-prompt'),
+        component: ({ data }) => {
+          // `data.data` is model-supplied JSON (untyped); narrow `service` before use.
+          const service = typeof data.data?.service === 'string' ? data.data.service : undefined;
+          return <IntegrationPrompt service={service} />;
+        },
+      }),
       Surface.create({
         id: 'triggerStatus',
         filter: Surface.makeFilter(AppSurface.StatusIndicator),
@@ -179,11 +172,6 @@ export default Capability.makeModule(() =>
           return <TriggerStatus role='status-indicator' space={space} />;
         },
       }),
-      Surface.create({
-        id: 'prompts',
-        filter: AppSurface.subject(Prompts, Obj.isObject),
-        component: ({ data }) => <RoutineList subject={data.subject} />,
-      }),
     ]),
   ),
 );

package/src/capabilities/skill-definition.ts

@@ -0,0 +1,72 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import {
+  AgentHandlers,
+  AgentSkill,
+  AgentSkillHandlers,
+  AgentWizardHandlers,
+  AgentWizardSkill,
+  AlarmHandlers,
+  AlarmSkill,
+  AutomationSkill,
+  BrowserSkill,
+  ConnectorsSkill,
+  DatabaseHandlers,
+  DatabaseSkill,
+  DelegationHandlers,
+  DelegationSkill,
+  DiscordSkill,
+  LinearSkill,
+  MemorySkill,
+  PlanningHandlers,
+  PlanningSkill,
+  SkillManagerHandlers,
+  SkillManagerSkill,
+  WebSearchHandlers,
+  WebSearchSkill,
+  makeDelegationStrategy,
+} from '@dxos/assistant-toolkit';
+import { RoutineCapabilities } from '@dxos/plugin-routine';
+
+import { AssistantSkill } from '#skills';
+
+const skillDefinition = () =>
+  Effect.succeed([
+    Capability.contributes(AppCapabilities.SkillDefinition, AssistantSkill),
+    Capability.contributes(AppCapabilities.SkillDefinition, BrowserSkill),
+    Capability.contributes(AppCapabilities.SkillDefinition, ConnectorsSkill),
+    Capability.contributes(AppCapabilities.SkillDefinition, DatabaseSkill),
+    Capability.contributes(AppCapabilities.SkillDefinition, WebSearchSkill),
+    Capability.contributes(AppCapabilities.SkillDefinition, DiscordSkill),
+    Capability.contributes(AppCapabilities.SkillDefinition, LinearSkill),
+    Capability.contributes(AppCapabilities.SkillDefinition, AgentSkill),
+    Capability.contributes(AppCapabilities.SkillDefinition, PlanningSkill),
+    Capability.contributes(AppCapabilities.SkillDefinition, MemorySkill),
+    Capability.contributes(AppCapabilities.SkillDefinition, AutomationSkill),
+    Capability.contributes(AppCapabilities.SkillDefinition, SkillManagerSkill),
+    Capability.contributes(AppCapabilities.SkillDefinition, AgentWizardSkill),
+    Capability.contributes(AppCapabilities.SkillDefinition, DelegationSkill),
+    Capability.contributes(AppCapabilities.SkillDefinition, AlarmSkill),
+
+    Capability.contributes(Capabilities.OperationHandler, AgentHandlers),
+    Capability.contributes(Capabilities.OperationHandler, AgentSkillHandlers),
+    Capability.contributes(Capabilities.OperationHandler, SkillManagerHandlers),
+    Capability.contributes(Capabilities.OperationHandler, DatabaseHandlers),
+    Capability.contributes(Capabilities.OperationHandler, WebSearchHandlers),
+    Capability.contributes(Capabilities.OperationHandler, AgentWizardHandlers),
+    Capability.contributes(Capabilities.OperationHandler, DelegationHandlers),
+    Capability.contributes(Capabilities.OperationHandler, PlanningHandlers),
+    Capability.contributes(Capabilities.OperationHandler, AlarmHandlers),
+
+    // Run the conversational agent as a supervisor: delegate in-progress plan tasks to sub-agents
+    // and fold their results back into the conversation (consumed by the AgentService LayerSpec).
+    Capability.contributes(RoutineCapabilities.AgentDelegationStrategy, makeDelegationStrategy()),
+  ]);
+
+export default skillDefinition;

package/src/capabilities/state.ts

@@ -27,9 +27,16 @@ export default Capability.makeModule(() =>
 
     const companionChatCacheAtom = Atom.make<Record<string, Obj.Unknown | undefined>>({}).pipe(Atom.keepAlive);
 
+    const homeSuggestionsCacheAtom = createKvsStore({
+      key: `${meta.profile.key}.home-suggestions`,
+      schema: AssistantCapabilities.HomeSuggestionsCacheSchema,
+      defaultValue: () => ({}),
+    });
+
     return [
       Capability.contributes(AssistantCapabilities.State, stateAtom),
       Capability.contributes(AssistantCapabilities.CompanionChatCache, companionChatCacheAtom),
+      Capability.contributes(AssistantCapabilities.HomeSuggestionsCache, homeSuggestionsCacheAtom),
     ];
   }),
 );

package/src/components/AgentProperties/AgentProperties.stories.tsx

@@ -5,7 +5,7 @@
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React from 'react';
 
-import { Plan, Agent } from '@dxos/assistant-toolkit';
+import { Agent, Plan } from '@dxos/assistant-toolkit';
 import { Filter, Obj, Ref } from '@dxos/echo';
 import { useQuery } from '@dxos/react-client/echo';
 import { useClientStory, withClientProvider } from '@dxos/react-client/testing';
@@ -53,7 +53,6 @@ const meta = {
         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: [],
           }),

package/src/components/Chat/Chat.tsx

@@ -2,16 +2,17 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Atom } from '@effect-atom/atom';
 import { useAtomValue } from '@effect-atom/atom-react';
 import * as Array from 'effect/Array';
 import * as Option from 'effect/Option';
 import React, { type PropsWithChildren, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
-import { Agent, Plan } from '@dxos/assistant-toolkit';
+import { Plan } from '@dxos/assistant-toolkit';
 import { Event } from '@dxos/async';
 import { getSpace } from '@dxos/client/echo';
-import { type Database, type Feed, Filter, Obj, Query } from '@dxos/echo';
-import { useQuery } from '@dxos/react-client/echo';
+import { type Database, Filter, Obj, Query } from '@dxos/echo';
+import { useObject, useQuery } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
 import { Button, Toast, composable, composableProps, useTranslation } from '@dxos/react-ui';
 import { type MarkdownStreamController } from '@dxos/react-ui-markdown';
@@ -38,7 +39,6 @@ import { type ChatEvent } from './events';
 
 type ChatRootProps = PropsWithChildren<
   Pick<ChatContextValue, 'chat' | 'processor'> & {
-    feed?: Feed.Feed;
     /** Fallback database when the chat is transient (not yet persisted). */
     db?: Database.Database;
     onEvent?: (event: ChatEvent) => void;
@@ -50,7 +50,7 @@ type ChatRootProps = PropsWithChildren<
   }
 >;
 
-const ChatRoot = ({ children, chat, feed, processor, db: dbFallback, onEvent, onSubmit, ...props }: ChatRootProps) => {
+const ChatRoot = ({ children, chat, processor, db: dbFallback, onEvent, onSubmit, ...props }: ChatRootProps) => {
   const [debug, setDebug] = useState(false);
   const streaming = useAtomValue(processor.streaming);
   const active = useAtomValue(processor.active);
@@ -60,6 +60,10 @@ const ChatRoot = ({ children, chat, feed, processor, db: dbFallback, onEvent, on
   // the message query and context controls operate before the chat is persisted.
   const db = (chat && Obj.getDatabase(chat)) || dbFallback;
 
+  // Reactive subscription — re-renders when the feed ref resolves. Direct `.target` reads are not reactive.
+  const [feedSnapshot] = useObject(chat?.feed);
+  const feed = Obj.getReactiveOrUndefined(feedSnapshot);
+
   // Event sink.
   const event = useMemo(() => new Event<ChatEvent>(), []);
 
@@ -334,13 +338,27 @@ type ChatTaskListProps = {
 
 const ChatTaskList = composable<HTMLDivElement, ChatTaskListProps>(({ plan: planProp, ...props }, forwardedRef) => {
   const { chat } = useChatContext(CHAT_TASK_LIST_NAME);
-  const parent = chat ? Obj.getParent(chat) : undefined;
-  const agent = parent && Obj.instanceOf(Agent.Agent, parent) ? parent : undefined;
-  const plan = planProp ?? agent?.plan.target;
+
+  const plan = useAtomValue(
+    useMemo(
+      () =>
+        Atom.make(
+          (get) =>
+            planProp ??
+            Option.fromNullable(chat).pipe(
+              Option.map((_) => get(Obj.atom(_))),
+              Option.flatMapNullable((_) => _?.plan?.atom),
+              Option.map(get),
+              Option.getOrUndefined,
+            ),
+        ),
+      [chat, planProp],
+    ),
+  );
   const space = chat ? getSpace(chat) : undefined;
   const traceMessages = useTraceMessages(space);
   const conversationId = chat?.feed?.target?.id;
-  if (!plan) {
+  if (!plan || !(plan.tasks?.length ?? 0)) {
     return null;
   }
 
@@ -372,4 +390,4 @@ export const Chat = {
   TaskList: ChatTaskList,
 };
 
-export type { ChatRootProps, ChatToolbarProps, ChatContentProps, ChatPromptProps, ChatThreadProps, ChatEvent };
+export type { ChatContentProps, ChatEvent, ChatPromptProps, ChatRootProps, ChatThreadProps, ChatToolbarProps };

package/src/components/Chat/events.ts

@@ -61,10 +61,4 @@ export type ChatEvent =
     }
   | {
       type: 'thread-close';
-    }
-  | {
-      type: 'record-start';
-    }
-  | {
-      type: 'record-stop';
     };