@dxos/plugin-assistant 0.9.0 → 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

@@ -4,7 +4,6 @@
 
 import { Capability } from '@dxos/app-framework';
 import type { OperationHandlerSet } from '@dxos/compute';
-import { AutomationCapabilities } from '@dxos/plugin-automation';
 
 import type { AssistantPluginOptions } from '#types';
 
@@ -15,18 +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'));
-// Explicit annotation: the contributed capability type references `Template` from @dxos/plugin-automation,
-// so the inferred lazy type needs annotating to stay portable (TS2883).
-export const AutomationTemplates: Capability.LazyCapability<
-  void,
-  Capability.Capability<typeof AutomationCapabilities.Template>[]
-> = Capability.lazy('AutomationTemplates', () => import('./automation-templates'));
-export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));
+export const NavigationResolver = Capability.lazy('NavigationResolver', () => import('./navigation-resolver'));
+export const AutomationTemplates = Capability.lazy('AutomationTemplates', () => import('./automation-templates'));
+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';
 
@@ -17,7 +16,11 @@ export default Capability.makeModule(
     const capabilities = yield* Capability.Service;
 
     return Capability.contributes(MarkdownCapabilities.ExtensionProvider, [
-      ({ document: doc }) => {
+      ({ document: doc, viewMode }) => {
+        if (viewMode === 'source') {
+          return undefined;
+        }
+
         if (!doc) {
           return undefined;
         }
@@ -31,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,50 +8,63 @@ 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 { 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(
     Capability.contributes(Capabilities.ReactSurface, [
       Surface.create({
         id: 'pluginSettings',
-        filter: AppSurface.settings(AppSurface.Article, meta.id),
+        filter: AppSurface.settings(AppSurface.Article, meta.profile.key),
         component: ({ data: { subject } }) => {
           const { settings, updateSettings } = useSettingsState<Assistant.Settings>(subject.atom);
           return <AssistantSettings settings={settings} onSettingsChange={updateSettings} />;
         },
       }),
+      Surface.create({
+        id: 'spaceHomePrompt',
+        filter: Surface.makeFilter(SpaceHomePinBottom),
+        component: ({ data }) => <SpaceHomePrompt space={data.space} />,
+      }),
+      Surface.create({
+        id: 'spaceHomeSuggestions',
+        filter: Surface.makeFilter(SpaceHomeContent),
+        position: Position.last,
+        component: ({ data }) => <SpaceHomeSuggestions space={data.space} />,
+      }),
       Surface.create({
         id: 'chat',
-        role: 'article',
-        filter: (data): data is { attendableId: string; subject: Chat.Chat; variant: undefined } =>
-          typeof data.attendableId === 'string' &&
-          Obj.instanceOf(Chat.Chat, data.subject) &&
-          data.variant !== ASSISTANT_COMPANION_VARIANT,
+        filter: AppSurface.object(
+          AppSurface.Article,
+          Chat.Chat,
+          (data) => data.variant !== ASSISTANT_COMPANION_VARIANT,
+        ),
         component: ({ data, role, ref }) => {
           return <ChatArticle role={role} subject={data.subject} attendableId={data.attendableId} ref={ref} />;
         },
@@ -64,17 +77,17 @@ export default Capability.makeModule(() =>
         ),
       }),
       Surface.create({
-        id: 'agentProperties',
+        id: 'objectProperties',
         filter: AppSurface.object(AppSurface.ObjectProperties, Agent.Agent),
         component: ({ data }) => <AgentProperties subject={data.subject} />,
       }),
       Surface.create({
         id: 'companionChat',
-        role: 'article',
-        filter: (data): data is { subject: Chat.Chat | null; attendableId: string; companionTo: Obj.Unknown } =>
-          typeof data.attendableId === 'string' &&
-          Obj.isObject(data.companionTo) &&
-          (Obj.instanceOf(Chat.Chat, data.subject) || data.subject === null),
+        filter: Surface.makeFilter(
+          AppSurface.Article,
+          (data) =>
+            Obj.isObject(data.companionTo) && (Obj.instanceOf(Chat.Chat, data.subject) || data.subject === null),
+        ),
         component: ({ data: { subject, attendableId, companionTo }, role, ref }) => (
           <ChatCompanion
             role={role}
@@ -87,40 +100,29 @@ export default Capability.makeModule(() =>
       }),
       Surface.create({
         id: 'companionInvocations',
-        role: 'article',
-        filter: (data): data is { companionTo: Sequence.Sequence } =>
-          (Obj.instanceOf(Sequence.Sequence, data.companionTo) || Obj.instanceOf(Routine.Routine, data.companionTo)) &&
-          data.subject === 'invocations',
+        filter: AppSurface.allOf(
+          AppSurface.literal(AppSurface.Article, 'invocations'),
+          AppSurface.oneOf(
+            AppSurface.companion(AppSurface.Article, Sequence.Sequence),
+            AppSurface.companion(AppSurface.Article, Instructions.Instructions),
+          ),
+        ),
         component: ({ data, role }) => {
           const space = getSpace(data.companionTo);
           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'>
-              <Panel.Content asChild>
+              <Panel.Content>
                 <InvocationTraceContainer db={space?.db} feedDXN={feedDXN} target={target} detailAxis='block' />
               </Panel.Content>
             </Panel.Root>
           );
         },
       }),
-      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),
@@ -135,7 +137,7 @@ export default Capability.makeModule(() =>
       }),
       Surface.create({
         id: 'trace',
-        filter: AppSurface.literal(Surface.makeType<{ subject: string }>('deck-companion--trace'), 'trace'),
+        filter: Surface.makeFilter(AppSurface.deckCompanion('trace')),
         component: () => {
           const space = useActiveSpace();
           useEffect(() => {
@@ -149,9 +151,18 @@ 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',
-        role: 'status-indicator',
+        filter: Surface.makeFilter(AppSurface.StatusIndicator),
         component: () => {
           const space = useActiveSpace();
           if (!space) {
@@ -161,14 +172,6 @@ export default Capability.makeModule(() =>
           return <TriggerStatus role='status-indicator' space={space} />;
         },
       }),
-      Surface.create({
-        id: 'prompts',
-        filter: AppSurface.subject(
-          Surface.makeType<{ subject: Obj.Any; attendableId: string }>('prompts'),
-          Obj.isObject,
-        ),
-        component: ({ data }) => <RoutineList subject={data.subject} />,
-      }),
     ]),
   ),
 );

package/src/capabilities/settings.ts

@@ -14,7 +14,7 @@ import { Assistant, AssistantCapabilities } from '#types';
 export default Capability.makeModule(() =>
   Effect.sync(() => {
     const settingsAtom = createKvsStore({
-      key: meta.id,
+      key: meta.profile.key,
       schema: Assistant.Settings,
       defaultValue: () => ({}),
     });
@@ -22,7 +22,7 @@ export default Capability.makeModule(() =>
     return [
       Capability.contributes(AssistantCapabilities.Settings, settingsAtom),
       Capability.contributes(AppCapabilities.Settings, {
-        prefix: meta.id,
+        prefix: meta.profile.key,
         schema: Assistant.Settings,
         atom: settingsAtom,
       }),

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

@@ -17,7 +17,7 @@ export default Capability.makeModule(() =>
     // NOTE: This needs to be a chat object rather than a string id to avoid a query race.
     // TODO(wittjosiah): Handle serialization and hydration for this so it can be cached.
     const stateAtom = createKvsStore({
-      key: meta.id,
+      key: meta.profile.key,
       schema: AssistantCapabilities.StateSchema,
       defaultValue: () => ({
         currentChat: {},
@@ -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/AgentProperties/AgentProperties.tsx

@@ -21,7 +21,7 @@ export type AgentPropertiesProps = {
 };
 
 export const AgentProperties = ({ agent }: AgentPropertiesProps) => {
-  const { t } = useTranslation(meta.id);
+  const { t } = useTranslation(meta.profile.key);
   const db = Obj.getDatabase(agent);
 
   // Build a filter matching objects of any schema annotated as a feed.