@dxos/plugin-assistant 0.10.0 → 0.11.0

package/src/capabilities/AssistantSurfaces.tsx

@@ -0,0 +1,86 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// Surface components that cannot be expressed as a `props` mapper, because they call hooks or compose.
+
+import React, { useEffect } from 'react';
+
+import { useSettingsState } from '@dxos/app-framework/ui';
+import { type AppCapabilities } from '@dxos/app-toolkit';
+import { useActiveSpace, useHomeVisibility } from '@dxos/app-toolkit/ui';
+import { getSpace } from '@dxos/client/echo';
+import { Instructions } from '@dxos/compute';
+import { InvocationTraceContainer } from '@dxos/devtools';
+import { Feed, Obj } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { type Space } from '@dxos/react-client/echo';
+import { Panel } from '@dxos/react-ui';
+
+import { AssistantSettings, SpaceHomeSuggestions, TracePanel, TriggerStatus } from '#containers';
+import { type Assistant } from '#types';
+
+export type AssistantSettingsSurfaceProps = {
+  subject: AppCapabilities.Settings;
+};
+
+export const AssistantSettingsSurface = ({ subject }: AssistantSettingsSurfaceProps) => {
+  const { settings, updateSettings } = useSettingsState<Assistant.Settings>(subject.atom);
+
+  return <AssistantSettings settings={settings} onSettingsChange={updateSettings} />;
+};
+
+export type SpaceHomeSuggestionsSurfaceProps = {
+  space: Space;
+};
+
+/** Suggestions are dismissible per space, so visibility is durable UI state rather than surface data. */
+export const SpaceHomeSuggestionsSurface = ({ space }: SpaceHomeSuggestionsSurfaceProps) => {
+  const { visible, hide } = useHomeVisibility(space, 'spaceHomeSuggestions');
+
+  return visible ? <SpaceHomeSuggestions space={space} onClose={hide} /> : null;
+};
+
+export type InvocationsSurfaceProps = {
+  role: string;
+  companionTo: Obj.Unknown;
+};
+
+/** Resolves the space's invocation-trace feed for the companion's subject. */
+export const InvocationsSurface = ({ role, companionTo }: InvocationsSurfaceProps) => {
+  const space = getSpace(companionTo);
+  const feed = space?.properties.invocationTraceFeed?.target;
+  const feedDXN = feed ? Feed.getFeedUri(feed) : undefined;
+  // TODO(wittjosiah): Support invocation filtering for prompts.
+  const target = Obj.instanceOf(Instructions.Instructions, companionTo) ? undefined : companionTo;
+
+  return (
+    <Panel.Root role={role} classNames='dx-document'>
+      <Panel.Content asChild>
+        <InvocationTraceContainer db={space?.db} feedDXN={feedDXN} target={target} detailAxis='block' />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+export const TracePanelSurface = () => {
+  const space = useActiveSpace();
+  useEffect(() => {
+    log('trace panel surface', { hasSpace: Boolean(space), spaceId: space?.id });
+  }, [space?.id]);
+
+  if (!space) {
+    return null;
+  }
+
+  return <TracePanel space={space} />;
+};
+
+export const TriggerStatusSurface = () => {
+  const space = useActiveSpace();
+  if (!space) {
+    return null;
+  }
+
+  return <TriggerStatus role='status-indicator' space={space} />;
+};

package/src/capabilities/agent-service.ts

@@ -5,10 +5,10 @@
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
+import { AgentService as AgentServiceRuntime } from '@dxos/agent-runtime';
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { AgentService, LayerSpec } from '@dxos/compute';
 import { ProcessManager } from '@dxos/compute-runtime';
-import { AgentService as AgentServiceRuntime } from '@dxos/functions-runtime';
 import { RoutineCapabilities } from '@dxos/plugin-routine';
 
 //

package/src/capabilities/app-graph-builder.ts

@@ -12,20 +12,20 @@ import {
   AppNode,
   AppNodeMatcher,
   AppSpace,
+  GraphPath,
   LayoutOperation,
-  Paths,
   TypeSection,
 } from '@dxos/app-toolkit';
 import { Chat, RunInstructions } from '@dxos/assistant-toolkit';
 import { isSpace } from '@dxos/client/echo';
-import { Instructions, Operation } from '@dxos/compute';
+import { Instructions, Operation, Project } from '@dxos/compute';
 import { Sequence } from '@dxos/conductor';
 import { Database, DXN, Filter, Obj, Query, type Ref, Type } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 import { ClientCapabilities } from '@dxos/plugin-client';
 import { GraphBuilder, Node, NodeMatcher } from '@dxos/plugin-graph';
 import { SpaceOperation } from '@dxos/plugin-space';
-import { linkedSegment } from '@dxos/react-ui-attention';
+import { Attention } from '@dxos/react-ui-attention';
 import { Position } from '@dxos/util';
 
 import { ASSISTANT_COMPANION_VARIANT, meta } from '#meta';
@@ -36,6 +36,23 @@ import { getChatsPath } from '../paths';
 /** Operation definitions to seed as `PersistentOperation` records for automation / triggers. */
 const computeOperationsToImport = [RunInstructions] as const;
 
+/**
+ * Chats belonging to the top-level Chats section: every chat minus the two kinds that already appear
+ * elsewhere in the tree. A chat sourcing a `CompanionTo` relation belongs to its primary object's
+ * companion panel; a chat parented to a `Project` is that project's navtree child (plugin-projects
+ * `projectChats`). Without the second exclusion a project chat appears twice.
+ *
+ * The project exclusion subtracts every project child rather than just chats — `children()` takes no
+ * type filter, and subtracting a non-chat from a chat-typed source is a no-op.
+ */
+export const standaloneChatsQuery = Query.without(
+  Query.without(
+    Query.select(Filter.type(Chat.Chat)),
+    Query.select(Filter.type(Chat.Chat)).sourceOf(Chat.CompanionTo).source(),
+  ),
+  Query.select(Filter.type(Project.Project)).children(),
+);
+
 /** Match ECHO objects that are NOT chats. */
 const whenNonChatObject = NodeMatcher.whenAll(
   NodeMatcher.whenEchoObject,
@@ -49,13 +66,13 @@ export default Capability.makeModule(
     const extensions = yield* Effect.all([
       // AI section group — created here so it shows only when the assistant plugin is active.
       GraphBuilder.createExtension({
-        id: Paths.GroupSegments.ai,
+        id: GraphPath.GroupSegments.ai,
         match: AppNodeMatcher.whenSpace,
         connector: (space) =>
           Effect.succeed([
             AppNode.makeGroup({
-              id: Paths.GroupSegments.ai,
-              type: Paths.GroupTypes.ai,
+              id: GraphPath.GroupSegments.ai,
+              type: GraphPath.GroupTypes.ai,
               label: ['nav-tree-group-ai.label', { ns: meta.profile.key }],
               space,
               position: 300,
@@ -155,7 +172,7 @@ export default Capability.makeModule(
 
             return [
               AppNode.makeCompanion({
-                id: linkedSegment(ASSISTANT_COMPANION_VARIANT),
+                variant: ASSISTANT_COMPANION_VARIANT,
                 label: ['assistant-chat.label', { ns: meta.profile.key }],
                 icon: 'ph--sparkle--regular',
                 data: chat,
@@ -174,7 +191,7 @@ export default Capability.makeModule(
         connector: () =>
           Effect.succeed([
             AppNode.makeCompanion({
-              id: 'invocations',
+              variant: 'invocations',
               label: ['invocations.label', { ns: meta.profile.key }],
               icon: 'ph--clock-countdown--regular',
               data: 'invocations',
@@ -188,7 +205,7 @@ export default Capability.makeModule(
         connector: () =>
           Effect.succeed([
             AppNode.makeDeckCompanion({
-              id: linkedSegment('trace'),
+              id: Attention.linkedSegment('trace'),
               label: ['trace.label', { ns: meta.profile.key }],
               icon: 'ph--line-segments--regular',
               data: 'trace',
@@ -197,15 +214,12 @@ export default Capability.makeModule(
           ]),
       }),
 
-      // Section node: standalone Chat.Chat objects per AI group (companions are excluded).
+      // Section node: standalone Chat.Chat objects per AI group (companions and project chats excluded).
       TypeSection.createTypeSectionExtension(Chat.Chat, {
-        // Exclude chats that are the source of a CompanionTo relation; those belong to
-        // their primary object's companion panel and should not appear in the top-level list.
-        query: Query.without(
-          Query.select(Filter.type(Chat.Chat)),
-          Query.select(Filter.type(Chat.Chat)).sourceOf(Chat.CompanionTo).source(),
-        ),
-        match: AppNodeMatcher.whenNavTreeGroup(Paths.GroupTypes.ai),
+        query: standaloneChatsQuery,
+        match: AppNodeMatcher.whenNavTreeGroup(GraphPath.GroupTypes.ai),
+        groupSegment: GraphPath.GroupSegments.ai,
+        urlKey: 'chat',
       }),
 
       // Create-chat action on the Chats section header.

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

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Registry } from '@effect-atom/atom-react';
+import { Atom, type Registry } from '@effect-atom/atom';
 import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';
 
@@ -18,9 +18,9 @@ import {
   DeckCapabilities,
   PLANK_COMPANION_TYPE,
   type StoredDeckState,
-  companionVariantAspect,
+  companionAspect,
 } from '@dxos/plugin-deck';
-import { getLinkedVariant } from '@dxos/react-ui-attention';
+import { Attention } from '@dxos/react-ui-attention';
 import { Position } from '@dxos/util';
 
 import { ASSISTANT_COMPANION_VARIANT } from '#meta';
@@ -40,8 +40,9 @@ export default Capability.makeModule(
     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.
+    // Project just the variant so a companion resize (same aspect) does not re-fire provisioning.
     const viewState = yield* Capability.get(AttentionCapabilities.ViewState);
-    const variantAtom = viewState.atom(companionVariantAspect, COMPANION_VIEW_STATE_CONTEXT);
+    const variantAtom = Atom.make((get) => get(viewState.atom(companionAspect, COMPANION_VIEW_STATE_CONTEXT)).variant);
 
     const plankSubs = new Map<string, () => void>();
 
@@ -97,13 +98,13 @@ export default Capability.makeModule(
     const provision = () => {
       const deckState: StoredDeckState = registry.get(deckStateAtom);
       const deck = deckState.decks[deckState.activeDeck];
-      if (!deck?.companionOpen) {
+      if (!deck?.companionPlanks.length) {
         unsubAllPlanks();
         return;
       }
 
-      const companionVariant = registry.get(variantAtom).variant;
-      const plankIds = new Set(deck.solo ? [deck.solo] : deck.active);
+      const companionVariant = registry.get(variantAtom);
+      const plankIds = new Set(deck.active);
 
       // Remove subscriptions for planks that are no longer active.
       for (const trackedId of plankSubs.keys()) {
@@ -126,7 +127,7 @@ export default Capability.makeModule(
           plankSubs.set(
             plankId,
             registry.subscribe(graph.connections(plankId, 'child'), () => {
-              if (provisionForPlank(plankId, registry.get(variantAtom).variant)) {
+              if (provisionForPlank(plankId, registry.get(variantAtom))) {
                 unsubPlank(plankId);
               }
             }),
@@ -170,11 +171,11 @@ const resolveEffectiveVariant = (
   }
 
   if (preferredVariant) {
-    const preferred = companions.find((companion) => getLinkedVariant(companion.id) === preferredVariant);
+    const preferred = companions.find((companion) => Attention.getLinkedVariant(companion.id) === preferredVariant);
     if (preferred) {
-      return getLinkedVariant(preferred.id);
+      return Attention.getLinkedVariant(preferred.id);
     }
   }
 
-  return getLinkedVariant(companions[0].id);
+  return Attention.getLinkedVariant(companions[0].id);
 };

package/src/capabilities/connector.ts

@@ -6,15 +6,15 @@ import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
 import { Capability } from '@dxos/app-framework';
-import { Obj, Ref } from '@dxos/echo';
+import { Format, Obj, Ref } from '@dxos/echo';
+import { AccessToken } from '@dxos/link';
 import { Connection, Connector, type CredentialForm } from '@dxos/plugin-connector';
-import { AccessToken } from '@dxos/types';
 
 import { ANTHROPIC_PROVIDER_ID, ANTHROPIC_SOURCE } from '../constants';
 
 /** API-key form for the Anthropic BYOK provider; key is best-effort validated against `/v1/models`. */
 const AnthropicTokenForm = Schema.Struct({
-  token: Schema.String.annotations({
+  token: Schema.String.pipe(Format.FormatAnnotation.set(Format.TypeFormat.Password)).annotations({
     title: 'API key',
     description: 'Your Anthropic API key — find it at https://console.anthropic.com/settings/keys.',
   }),

package/src/capabilities/edge-model-resolver.ts

@@ -5,6 +5,7 @@
 import * as AnthropicClient from '@effect/ai-anthropic/AnthropicClient';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
 
 import { AnthropicResolver } from '@dxos/ai/resolvers';
 import { Capability } from '@dxos/app-framework';
@@ -36,16 +37,18 @@ const edgeModelResolver = Capability.makeModule<[], EdgeModelResolverCapabilitie
       if (!edgeClient) {
         const [client] = manager.getAll(ClientCapabilities.Client);
         invariant(client, 'Client capability is required for edge AI requests.');
+        const [haloIdentity] = manager.getAll(ClientCapabilities.IdentityService);
+        invariant(haloIdentity, 'HALO identity capability is required for edge AI requests.');
         const edgeUrl = client.config.values.runtime?.services?.edge?.url;
         invariant(edgeUrl, 'EDGE services are not configured.');
         const created = new EdgeHttpClient(edgeUrl);
         const updateIdentity = () => {
-          if (client.halo.identity.get()) {
+          if (Option.isSome(haloIdentity.getSnapshot())) {
             created.setIdentity(createEdgeIdentity(client));
           }
         };
         updateIdentity();
-        identitySubscription = client.halo.identity.subscribe(updateIdentity);
+        identitySubscription = { unsubscribe: haloIdentity.subscribe(updateIdentity) };
         edgeClient = created;
       }
       return edgeClient;

package/src/capabilities/index.ts

@@ -16,7 +16,6 @@ export const AiService = Capability.lazy<AssistantPluginOptions | void, Capabili
 );
 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 SkillDefinition = Capability.lazy('SkillDefinition', () => import('./skill-definition'));
 export const CompanionChatProvisioner = Capability.lazy(
@@ -27,7 +26,6 @@ export const CreateObject = Capability.lazy('CreateObject', () => import('./crea
 export const EdgeModelResolver = Capability.lazy('EdgeModelResolver', () => import('./edge-model-resolver'));
 export const LocalModelResolver = Capability.lazy('LocalModelResolver', () => import('./local-model-resolver'));
 export const MarkdownExtension = Capability.lazy('MarkdownExtension', () => import('./markdown-extension'));
-export const Migrations = Capability.lazy('AssistantMigrations', () => import('./migrations'));
 export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
   'OperationHandler',
   () => import('./operation-handler'),

package/src/capabilities/react-surface.ts

@@ -0,0 +1,135 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import { type ComponentProps } from 'react';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface } from '@dxos/app-framework/ui';
+import { AppSurface } from '@dxos/app-toolkit/ui';
+import { Agent, Chat } from '@dxos/assistant-toolkit';
+import { Instructions } from '@dxos/compute';
+import { Sequence } from '@dxos/conductor';
+import { Obj } from '@dxos/echo';
+import { SpaceHomeContent, SpaceHomePinBottom } from '@dxos/plugin-space';
+import { Position } from '@dxos/util';
+
+import {
+  AgentArticle,
+  AgentProperties,
+  ChatArticle,
+  ChatCompanion,
+  ChatDialog,
+  IntegrationPrompt,
+  SpaceHomePrompt,
+} from '#containers';
+import { ASSISTANT_COMPANION_VARIANT, ASSISTANT_DIALOG, meta } from '#meta';
+import { ChatSurface } from '#types';
+
+import {
+  AssistantSettingsSurface,
+  InvocationsSurface,
+  SpaceHomeSuggestionsSurface,
+  TracePanelSurface,
+  TriggerStatusSurface,
+} from './AssistantSurfaces';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: 'pluginSettings',
+        filter: AppSurface.settings(AppSurface.Article, meta.profile.key),
+        component: AssistantSettingsSurface,
+        props: ({ data: { subject } }) => ({ subject }),
+      }),
+      Surface.create({
+        id: 'spaceHomePrompt',
+        filter: Surface.makeFilter(SpaceHomePinBottom),
+        component: SpaceHomePrompt,
+        props: ({ data: { space } }) => ({ space }),
+      }),
+      Surface.create({
+        id: 'spaceHomeSuggestions',
+        filter: Surface.makeFilter(SpaceHomeContent),
+        position: Position.last,
+        component: SpaceHomeSuggestionsSurface,
+        props: ({ data: { space } }) => ({ space }),
+      }),
+      Surface.create({
+        id: 'chat',
+        filter: AppSurface.object(
+          AppSurface.Article,
+          Chat.Chat,
+          (data) => data.variant !== ASSISTANT_COMPANION_VARIANT,
+        ),
+        component: ChatArticle,
+        props: ({ role, ref, data: { subject, attendableId } }) => ({ role, subject, attendableId, ref }),
+      }),
+      Surface.create({
+        id: 'agent',
+        filter: AppSurface.object(AppSurface.Article, Agent.Agent),
+        component: AgentArticle,
+        props: ({ role, data: { subject, attendableId } }) => ({ role, subject, attendableId }),
+      }),
+      Surface.create({
+        id: 'objectProperties',
+        filter: AppSurface.object(AppSurface.ObjectProperties, Agent.Agent),
+        component: AgentProperties,
+        props: ({ data: { subject } }) => ({ subject }),
+      }),
+      Surface.create({
+        id: 'companionChat',
+        filter: Surface.makeFilter(
+          AppSurface.Article,
+          (data) =>
+            Obj.isObject(data.companionTo) && (Obj.instanceOf(Chat.Chat, data.subject) || data.subject === null),
+        ),
+        component: ChatCompanion,
+        props: ({ role, ref, data: { subject, attendableId, companionTo } }) => ({
+          role,
+          subject,
+          attendableId,
+          companionTo,
+          ref,
+        }),
+      }),
+      Surface.create({
+        id: 'companionInvocations',
+        filter: AppSurface.allOf(
+          AppSurface.literal(AppSurface.Article, 'invocations'),
+          AppSurface.oneOf(
+            AppSurface.companion(AppSurface.Article, Sequence.Sequence),
+            AppSurface.companion(AppSurface.Article, Instructions.Instructions),
+          ),
+        ),
+        component: InvocationsSurface,
+        props: ({ role, data: { companionTo } }) => ({ role, companionTo }),
+      }),
+      Surface.create({
+        id: ASSISTANT_DIALOG,
+        filter: AppSurface.component<ComponentProps<typeof ChatDialog>>(AppSurface.Dialog, ASSISTANT_DIALOG),
+        component: ChatDialog,
+        props: ({ data: { props } }) => ({ ...props }),
+      }),
+      Surface.create({
+        id: 'trace',
+        filter: Surface.makeFilter(AppSurface.deckCompanion('trace')),
+        component: TracePanelSurface,
+      }),
+      Surface.create({
+        id: 'integrationPrompt',
+        filter: Surface.makeFilter(ChatSurface, (data) => data.role === 'integration-prompt'),
+        component: IntegrationPrompt,
+        // `data.data` is model-supplied JSON (untyped); narrow `service` before use.
+        props: ({ data }) => ({ service: typeof data.data?.service === 'string' ? data.data.service : undefined }),
+      }),
+      Surface.create({
+        id: 'triggerStatus',
+        filter: Surface.makeFilter(AppSurface.StatusIndicator),
+        component: TriggerStatusSurface,
+      }),
+    ]),
+  ),
+);

package/src/capabilities/skill-definition.ts

@@ -26,6 +26,8 @@ import {
   MemorySkill,
   PlanningHandlers,
   PlanningSkill,
+  ProjectHandlers,
+  ProjectSkill,
   SkillManagerHandlers,
   SkillManagerSkill,
   WebSearchHandlers,
@@ -53,6 +55,7 @@ const skillDefinition = () =>
     Capability.contributes(AppCapabilities.SkillDefinition, AgentWizardSkill),
     Capability.contributes(AppCapabilities.SkillDefinition, DelegationSkill),
     Capability.contributes(AppCapabilities.SkillDefinition, AlarmSkill),
+    Capability.contributes(AppCapabilities.SkillDefinition, ProjectSkill),
 
     Capability.contributes(Capabilities.OperationHandler, AgentHandlers),
     Capability.contributes(Capabilities.OperationHandler, AgentSkillHandlers),
@@ -63,6 +66,7 @@ const skillDefinition = () =>
     Capability.contributes(Capabilities.OperationHandler, DelegationHandlers),
     Capability.contributes(Capabilities.OperationHandler, PlanningHandlers),
     Capability.contributes(Capabilities.OperationHandler, AlarmHandlers),
+    Capability.contributes(Capabilities.OperationHandler, ProjectHandlers),
 
     // 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).

package/src/capabilities/standalone-chats-query.test.ts

@@ -0,0 +1,51 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { afterEach, beforeEach, describe, test } from 'vitest';
+
+import { Chat } from '@dxos/assistant-toolkit';
+import { Project } from '@dxos/compute';
+import { Feed, Obj, Ref, Relation } from '@dxos/echo';
+import { EchoTestBuilder } from '@dxos/echo-client/testing';
+
+import { standaloneChatsQuery } from './app-graph-builder';
+
+describe('standalone chats query', () => {
+  let builder: EchoTestBuilder;
+
+  beforeEach(async () => {
+    builder = await new EchoTestBuilder().open();
+  });
+
+  afterEach(async () => {
+    await builder.close();
+  });
+
+  test('excludes companion chats and project chats, keeping standalone ones', async ({ expect }) => {
+    const { db } = await builder.createDatabase({
+      types: [Chat.Chat, Chat.CompanionTo, Project.Project, Feed.Feed],
+    });
+
+    const makeChat = (name: string) => db.add(Chat.make({ name, feed: Ref.make(db.add(Feed.make())) }));
+
+    const standalone = makeChat('Standalone');
+
+    // Companion: sources a CompanionTo relation, so it belongs to its primary object's panel.
+    const companionSubject = db.add(Project.make({ name: 'Subject' }));
+    const companion = makeChat('Companion');
+    db.add(Relation.make(Chat.CompanionTo, { [Relation.Source]: companion, [Relation.Target]: companionSubject }));
+
+    // Project chat: parented to a project, so it is that project's navtree child.
+    const project = db.add(Project.make({ name: 'Project' }));
+    const projectChat = makeChat('Project chat');
+    Obj.setParent(projectChat, project);
+
+    await db.flush({ indexes: true });
+
+    const results = await db.query(standaloneChatsQuery).run();
+    expect(results.map((chat) => chat.id)).toEqual([standalone.id]);
+    expect(results.map((chat) => chat.id)).not.toContain(companion.id);
+    expect(results.map((chat) => chat.id)).not.toContain(projectChat.id);
+  });
+});

package/src/capabilities/state.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Atom } from '@effect-atom/atom-react';
+import { Atom } from '@effect-atom/atom';
 import * as Effect from 'effect/Effect';
 
 import { Capability } from '@dxos/app-framework';

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

@@ -5,14 +5,15 @@
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React from 'react';
 
-import { Agent, Plan } from '@dxos/assistant-toolkit';
+import { Agent } from '@dxos/assistant-toolkit';
+import { Instructions } from '@dxos/compute';
 import { Filter, Obj, Ref } from '@dxos/echo';
-import { useQuery } from '@dxos/react-client/echo';
+import { useQuery } from '@dxos/echo-react';
 import { useClientStory, withClientProvider } from '@dxos/react-client/testing';
 import { ObjectProperties } from '@dxos/react-ui-form';
 import { Loading, withLayout, withTheme } from '@dxos/react-ui/testing';
 import { Text } from '@dxos/schema';
-import { Organization } from '@dxos/types';
+import { Organization, Outline } from '@dxos/types';
 
 import { translations } from '#translations';
 
@@ -41,7 +42,7 @@ const meta = {
     withClientProvider({
       createIdentity: true,
       createSpace: true,
-      types: [Agent.Agent, Plan.Plan, Text.Text, Organization.Organization],
+      types: [Agent.Agent, Outline.Outline, Text.Text, Instructions.Instructions, Organization.Organization],
       onCreateSpace: async ({ space }) => {
         const organization = space.db.add(
           Obj.make(Organization.Organization, {
@@ -52,9 +53,7 @@ const meta = {
 
         space.db.add(
           Obj.make(Agent.Agent, {
-            instructions: Ref.make(Text.make()),
-            artifacts: [{ name: 'Organization', data: Ref.make(organization) }],
-            subscriptions: [],
+            instructions: Ref.make(Instructions.make({ text: '' })),
           }),
         );
       },