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

package/src/feed-logger.ts

@@ -5,9 +5,9 @@
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import { createFeedServiceLayer, type Space, getSpace } from '@dxos/client/echo';
+import { type Space, getSpace } from '@dxos/client/echo';
 import { Sequence, type SequenceEvent, type SequenceLogger } from '@dxos/conductor';
-import { Feed, Obj, Ref } from '@dxos/echo';
+import { Database, Feed, Obj, Ref } from '@dxos/echo';
 import { EffectEx } from '@dxos/effect';
 import { InvocationTraceEndEvent, InvocationTraceEventType, InvocationTraceStartEvent } from '@dxos/functions-runtime';
 import { TraceEvent } from '@dxos/functions-runtime';
@@ -18,7 +18,7 @@ import { type EntityId } from '@dxos/keys';
 export class QueueLogger implements SequenceLogger {
   private _space: Space;
   private _invocationTraceFeed: Feed.Feed;
-  private _feedServiceLayer: Layer.Layer<Feed.FeedService>;
+  private _feedServiceLayer: Layer.Layer<Database.Service>;
   /** Per-invocation trace feeds, keyed by invocationId. Created on `begin` and looked up for subsequent events. */
   private _invocationFeeds = new Map<EntityId, Feed.Feed>();
 
@@ -26,7 +26,7 @@ export class QueueLogger implements SequenceLogger {
     const space = getSpace(sequence);
     invariant(space, 'Space not found');
     this._space = space;
-    this._feedServiceLayer = createFeedServiceLayer(space.db);
+    this._feedServiceLayer = Database.layer(space.db);
 
     const existingFeedRef = this._space.properties.invocationTraceFeed;
 

package/src/functions/services.test.ts

@@ -6,12 +6,12 @@ import { describe, test } from 'vitest';
 
 import { LayoutOperation } from '@dxos/app-toolkit';
 import {
-  AgentBlueprintHandlers,
   AgentHandlers,
+  AgentSkillHandlers,
   AgentWizardHandlers,
-  BlueprintManagerHandlers,
   DatabaseHandlers,
   DelegationHandlers,
+  SkillManagerHandlers,
   WebSearchHandlers,
 } from '@dxos/assistant-toolkit';
 import { Operation, OperationHandlerSet } from '@dxos/compute';
@@ -22,8 +22,8 @@ import { AssistantOperationHandlerSet } from '#operations';
 const handlerSet = OperationHandlerSet.merge(
   AssistantOperationHandlerSet,
   AgentHandlers,
-  AgentBlueprintHandlers,
-  BlueprintManagerHandlers,
+  AgentSkillHandlers,
+  SkillManagerHandlers,
   DatabaseHandlers,
   WebSearchHandlers,
   AgentWizardHandlers,

package/src/hooks/index.ts

@@ -3,7 +3,7 @@
 //
 // TODO(wittjosiah): Factor hooks out of plugin-assistant into a standalone package.
 
-export * from './useBlueprintRegistry';
+export * from './useSkillRegistry';
 export * from './useChatKeymap';
 export * from './useChatProcessor';
 export * from './useChatServices';
@@ -13,10 +13,10 @@ export * from './useContextObjects';
 export { useDebug } from './useDebug';
 export * from './useFilteredTypes';
 export * from './useFlush';
-export * from './useOnline';
 export * from './usePresets';
 export * from './useReferencesProvider';
 export * from './useTraceMessages';
+export * from './useHomeSuggestions';
 export * from './useProcessEphemeralStatus';
 
 export { type AiChatProcessor } from '../processor';

package/src/hooks/useChatProcessor.ts

@@ -12,13 +12,11 @@ import { Capabilities } from '@dxos/app-framework';
 import { useCapability } from '@dxos/app-framework/ui';
 import { AiSession } from '@dxos/assistant';
 import { type Chat } from '@dxos/assistant-toolkit';
-import { Credential, ServiceResolver } from '@dxos/compute';
-import { Database, Feed, Ref, Registry } from '@dxos/echo';
-import { createFeedServiceLayer } from '@dxos/echo-client';
+import { AgentService, Credential, ServiceResolver } from '@dxos/compute';
+import { Database, Obj, Ref, Registry } from '@dxos/echo';
 import { EffectEx } from '@dxos/effect';
-import { AgentService } from '@dxos/functions-runtime';
 import { log } from '@dxos/log';
-import { type Space } from '@dxos/react-client/echo';
+import { type Space, useObject } from '@dxos/react-client/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
 
 import { type Assistant } from '#types';
@@ -47,22 +45,21 @@ export const useChatProcessor = ({
 }: UseChatProcessorProps): AiChatProcessor | undefined => {
   const observableRegistry = useContext(RegistryContext);
 
+  // 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);
+
   const [session, setSession] = useState<AiSession.Session>();
   useAsyncEffect(async () => {
-    if (!space || !chat) {
+    if (!space || !chat || !feed) {
       return;
     }
 
-    const feedTarget = chat.feed.target;
-    if (!feedTarget) {
-      return;
-    }
-    const feedServiceLayer = createFeedServiceLayer(space.db);
     const runtime = await EffectEx.runAndForwardErrors(
-      Effect.runtime<Feed.FeedService>().pipe(Effect.provide(feedServiceLayer)),
+      Effect.runtime<Database.Service>().pipe(Effect.provide(Database.layer(space.db))),
     );
     const session = new AiSession.Session({
-      feed: feedTarget,
+      feed,
       runtime,
       registry: observableRegistry,
     });
@@ -72,9 +69,8 @@ export const useChatProcessor = ({
       void session.close();
       setSession(undefined);
     };
-  }, [space, chat?.feed.target]);
+  }, [space, chat, feed]);
 
-  const feed = chat?.feed.target;
   const serviceResolver = useCapability(Capabilities.ServiceResolver);
 
   const processor = useMemo(() => {
@@ -85,7 +81,6 @@ export const useChatProcessor = ({
     const spaceLayer = ServiceResolver.provide(
       { space: space.id },
       Database.Service,
-      Feed.FeedService,
       Credential.CredentialsService,
       AiService.AiService,
       AgentService.AgentService,
@@ -99,6 +94,7 @@ export const useChatProcessor = ({
       observableRegistry,
       registry,
       model: preset?.model,
+      provider: preset?.provider,
     });
   }, [runtime, session, registry, preset, chat, feed, space?.id]);
 

package/src/hooks/useContextBinder.ts

@@ -7,8 +7,7 @@ import * as Effect from 'effect/Effect';
 import { useContext, useState } from 'react';
 
 import { AiContext } from '@dxos/assistant';
-import { Feed } from '@dxos/echo';
-import { createFeedServiceLayer } from '@dxos/echo-client';
+import { Database, Feed } from '@dxos/echo';
 import { EffectEx } from '@dxos/effect';
 import { type Space } from '@dxos/react-client/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
@@ -26,9 +25,8 @@ export const useContextBinder = (
       return;
     }
 
-    const feedServiceLayer = createFeedServiceLayer(space.db);
     const runtime = await EffectEx.runAndForwardErrors(
-      Effect.runtime<Feed.FeedService>().pipe(Effect.provide(feedServiceLayer)),
+      Effect.runtime<Database.Service>().pipe(Effect.provide(Database.layer(space.db))),
     );
     const binder = new AiContext.Binder({ feed, runtime, registry });
     await binder.open();

package/src/hooks/useDebug.ts

@@ -16,10 +16,10 @@ import { type AiChatProcessor } from '../processor';
 export const useDebug = ({ processor }: { processor: AiChatProcessor }) => {
   return useCallback(async () => {
     const objects = processor.context.getObjects();
-    const blueprints = processor.context.getBlueprints();
+    const skills = processor.context.getSkills();
     const system = await processor.getSystemPrompt();
     const tools = (await processor.getTools()) ?? {};
-    console.group('Chat', { objects, blueprints });
+    console.group('Chat', { objects, skills });
     try {
       console.log(trim`
         System Prompt:

package/src/hooks/useHomeSuggestions.ts

@@ -0,0 +1,55 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useMemo, useState } from 'react';
+
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { type Space } from '@dxos/react-client/echo';
+import { useAsyncEffect, useTranslation } from '@dxos/react-ui';
+
+import { meta } from '#meta';
+import { AssistantOperation } from '#types';
+
+const FALLBACK_SUGGESTION_KEYS = [
+  'space-home.suggestion-magazine.label',
+  'space-home.suggestion-spreadsheet.label',
+  'space-home.suggestion-kanban.label',
+] as const;
+
+/**
+ * Returns starter prompts for the space Home page. Returns undefined while the request is in flight
+ * so the section stays hidden until settled. On success yields generated prompts; on empty result or
+ * error falls back to the hardcoded defaults.
+ */
+export const useHomeSuggestions = (space?: Space): readonly string[] | undefined => {
+  const { t } = useTranslation(meta.profile.key);
+  const { invokePromise } = useOperationInvoker();
+  const fallbacks = useMemo(
+    () => FALLBACK_SUGGESTION_KEYS.map((key) => t(key, { year: new Date().getFullYear() })),
+    [t],
+  );
+  const [suggestions, setSuggestions] = useState<readonly string[] | undefined>(undefined);
+
+  useAsyncEffect(
+    async (controller) => {
+      setSuggestions(undefined);
+      if (!space) {
+        return;
+      }
+      const result = await invokePromise(
+        AssistantOperation.GenerateHomeSuggestions,
+        { db: space.db },
+        { spaceId: space.db.spaceId },
+      );
+      if (controller.signal.aborted) {
+        return;
+      }
+      const prompts = result.data?.prompts;
+      setSuggestions(prompts && prompts.length > 0 ? prompts : fallbacks);
+    },
+    [space, invokePromise],
+  );
+
+  return suggestions;
+};

package/src/hooks/usePresets.ts

@@ -2,32 +2,77 @@
 // Copyright 2025 DXOS.org
 //
 
+import { useAtomValue } from '@effect-atom/atom-react';
 import { useCallback, useEffect, useMemo, useState } from 'react';
 
-import { type ChatPresetProps } from '#types';
+import { Provider } from '@dxos/ai';
+import { useOptionalCapability } from '@dxos/app-framework/ui';
+import { EffectEx } from '@dxos/effect';
 
-import { type AiServicePreset, AiServicePresets } from '../processor';
+import { type Assistant, AssistantCapabilities, type ChatPresetProps, Ollama } from '#types';
+
+import { type AiServicePreset, defaultsKeyForProvider, presetsForProvider, resolveProvider } from '../processor';
 
 export type UsePresets = {
   preset: AiServicePreset | undefined;
 } & Pick<ChatPresetProps, 'presets' | 'onPresetChange'>;
 
-export const usePresets = (online: boolean): UsePresets => {
-  // TODO(burdon): Memo preset for provider.
+/**
+ * Resolves the chat model presets for the provider selected in settings ({@link Assistant.Settings.modelProvider}),
+ * defaulting the selection to the configured per-provider model.
+ */
+export const usePresets = (settings: Assistant.Settings): UsePresets => {
   const [preset, setPreset] = useState<AiServicePreset>();
-  const presets = useMemo(
-    () => AiServicePresets.filter((preset) => online === (preset.provider === 'dxos-remote')),
-    [online],
-  );
+
+  // The Ollama manager is the bundled sidecar (desktop only); its presence signals that the
+  // `built-in` provider (rather than an external Ollama server) is available.
+  const ollamaManager = useOptionalCapability(AssistantCapabilities.OllamaManager);
+
+  const provider = resolveProvider(settings.modelProvider, !!ollamaManager);
+  const defaultModel = settings.modelDefaults?.[defaultsKeyForProvider(provider)];
+
+  // Installed models reported by the bundled sidecar; used to offer only models actually present.
+  const localModels = useAtomValue(ollamaManager?.state ?? Ollama.emptyState);
+
+  // When the bundled sidecar is the active provider, list installed models in the background so the
+  // chat selector is populated without first opening settings. Idempotent: kicks off only from the
+  // idle state, so it spawns the sidecar once when local models are in use (not on every launch);
+  // settings remains the explicit path for retrying after a failure.
+  useEffect(() => {
+    if (provider === Provider.builtIn.id && ollamaManager && localModels.kind === 'idle') {
+      void EffectEx.runPromise(ollamaManager.refresh);
+    }
+  }, [provider, ollamaManager, localModels.kind]);
+
+  // Probe the external LM Studio server only when that provider is selected on desktop.
+  const lmStudioProbeUrl =
+    provider === Provider.lmStudio.id && ollamaManager ? `${Provider.lmStudio.endpoint}/v1/models` : undefined;
+  const lmStudioReachable = useEndpointReachable(lmStudioProbeUrl);
+
+  const presets = useMemo(() => {
+    const base = presetsForProvider(provider);
+    // Desktop LM Studio: only offer presets when the external server responds.
+    if (provider === Provider.lmStudio.id && ollamaManager) {
+      return lmStudioReachable ? base : [];
+    }
+    // Bundled sidecar: only offer models that are actually installed (matched by back-end pull tag).
+    if (provider === Provider.builtIn.id && ollamaManager) {
+      const installed = new Set(localModels.models.map((model) => model.name));
+      return base.filter((preset) => installed.has(preset.backend));
+    }
+    return base;
+  }, [provider, ollamaManager, lmStudioReachable, localModels]);
 
   const presetOptions = useMemo(
     () => presets.map(({ id, model, label }) => ({ id, label: label ?? model })),
     [presets],
   );
 
+  // Default to the provider's configured model, else the first available preset.
   useEffect(() => {
-    setPreset(presets[0]);
-  }, [presets]);
+    const configured = defaultModel ? presets.find((preset) => preset.model === defaultModel) : undefined;
+    setPreset(configured ?? presets[0]);
+  }, [presets, defaultModel]);
 
   const handlePresetChange = useCallback<NonNullable<ChatPresetProps['onPresetChange']>>(
     (id) => {
@@ -40,8 +85,32 @@ export const usePresets = (online: boolean): UsePresets => {
   );
 
   return {
-    preset: preset,
+    preset,
     presets: presetOptions,
     onPresetChange: handlePresetChange,
   };
 };
+
+/** Reactively reports whether an HTTP endpoint responds; `undefined` url disables the probe. */
+const useEndpointReachable = (url: string | undefined): boolean => {
+  const [reachable, setReachable] = useState(false);
+  useEffect(() => {
+    if (!url) {
+      setReachable(false);
+      return;
+    }
+    let active = true;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 1500);
+    fetch(url, { signal: controller.signal })
+      .then((response) => active && setReachable(response.ok))
+      .catch(() => active && setReachable(false))
+      .finally(() => clearTimeout(timer));
+    return () => {
+      active = false;
+      controller.abort();
+      clearTimeout(timer);
+    };
+  }, [url]);
+  return reachable;
+};

package/src/hooks/useProcessEphemeralStatus.ts

@@ -59,7 +59,7 @@ const resolveSubscribePids = (agentPid: Process.ID, processes: readonly Process.
 const attachActiveHandle = (
   processManager: ProcessManager.Manager,
   pid: Process.ID,
-): Effect.Effect<ProcessManager.Handle<any, any> | undefined> =>
+): Effect.Effect<ProcessManager.Handle<any, any, never> | undefined> =>
   Effect.gen(function* () {
     const maxAttempts = 15;
     for (let attempt = 0; attempt < maxAttempts; attempt++) {

package/src/hooks/useReferencesProvider.ts

@@ -20,7 +20,7 @@ export const useReferencesProvider = (space?: Space): ReferencesProvider | undef
     return {
       getReferences: async ({ query }) => {
         // TODO(burdon): Previously we filtered by types declared by the artifact definitions.
-        // const schemas = blueprints.map((blueprint) => blueprint.schema).flat();
+        // const schemas = skills.map((skill) => skill.schema).flat();
         // const objects = await space.db
         //   .query(Filter.or(...schemas.map((schema) => Filter.type(schema as Type.Schema))))
         //   .run();

package/src/hooks/useSkillRegistry.ts

@@ -0,0 +1,125 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useCallback, useEffect, useMemo, useState } from 'react';
+
+import { type AiContext } from '@dxos/assistant';
+import { Skill } from '@dxos/compute';
+import { type Database, Filter, Obj, Ref, type Registry } from '@dxos/echo';
+import { useQuery } from '@dxos/react-client/echo';
+import { distinctBy } from '@dxos/util';
+
+export const useSkills = ({ registry, db }: { registry?: Registry.Registry; db?: Database.Database }) => {
+  const [registrySkills, setRegistrySkills] = useState<Skill.Skill[]>(
+    () => registry?.query(Filter.type(Skill.Skill)).runSync() ?? [],
+  );
+
+  useEffect(() => {
+    if (!registry) {
+      setRegistrySkills([]);
+      return;
+    }
+    setRegistrySkills(registry.query(Filter.type(Skill.Skill)).runSync());
+    return registry.changed.on(() => {
+      setRegistrySkills(registry.query(Filter.type(Skill.Skill)).runSync());
+    });
+  }, [registry]);
+
+  const spaceSkills = useQuery(db, Filter.type(Skill.Skill));
+  return useMemo(() => {
+    const skills = distinctBy([...registrySkills, ...spaceSkills], (b) => Obj.getMeta(b).key);
+    skills.sort(({ name: a }, { name: b }) => a.localeCompare(b));
+    return skills;
+  }, [registrySkills, spaceSkills]);
+};
+
+/**
+ * Create reactive map of active skills (by key).
+ */
+export const useActiveSkills = ({ context }: { context?: AiContext.Binder }) => {
+  const [active, setActive] = useState<Map<string, Skill.Skill>>(new Map());
+
+  useEffect(() => {
+    if (!context) {
+      setActive(new Map());
+      return;
+    }
+
+    const updateActive = () => {
+      const skills = context.getSkills();
+      setActive(
+        new Map(
+          skills
+            .map((skill) => [Obj.getMeta(skill).key, skill] as const)
+            .filter((entry): entry is readonly [string, Skill.Skill] => entry[0] !== undefined),
+        ),
+      );
+    };
+
+    // Set initial value.
+    updateActive();
+
+    // Subscribe to changes.
+    return context.subscribeSkills(updateActive);
+  }, [context]);
+
+  return active;
+};
+
+// TODO(burdon): Move logic into binder.
+export const useSkillHandlers = ({
+  db,
+  context,
+  registry,
+}: {
+  db: Database.Database;
+  context?: AiContext.Binder;
+  registry?: Registry.Registry;
+}) => {
+  const onUpdateSkill = useCallback(
+    async (key: string, checked: boolean) => {
+      if (!context) {
+        return;
+      }
+
+      if (checked) {
+        // Check if the skill is in the registry — if so, bind via its key URI directly
+        // (no DB clone needed). Fall back to an existing DB copy for user-forked skills.
+        const registrySkill = registry
+          ?.query(Filter.type(Skill.Skill))
+          .runSync()
+          .find((b) => Obj.getMeta(b).key === key);
+
+        if (registrySkill) {
+          await context.bind({ skills: [Ref.fromURI(Skill.registryURI(key))] });
+        } else {
+          // User-forked skill (in DB but not in registry): bind via DB ref.
+          const objects = await db.query(Filter.type(Skill.Skill)).run();
+          const storedSkill = objects.find((skill) => Obj.getMeta(skill).key === key);
+          if (storedSkill) {
+            await context.bind({ skills: [Ref.make(storedSkill)] });
+          }
+        }
+      } else {
+        // Unbind: try registry ref first, then DB ref.
+        const registrySkill = registry
+          ?.query(Filter.type(Skill.Skill))
+          .runSync()
+          .find((b) => Obj.getMeta(b).key === key);
+        if (registrySkill) {
+          await context.unbind({ skills: [Ref.fromURI(Skill.registryURI(key))] });
+        } else {
+          const objects = await db.query(Filter.type(Skill.Skill)).run();
+          const storedSkill = objects.find((skill) => Obj.getMeta(skill).key === key);
+          if (storedSkill) {
+            await context.unbind({ skills: [Ref.make(storedSkill)] });
+          }
+        }
+      }
+    },
+    [db, context, registry],
+  );
+
+  return { onUpdateSkill };
+};

package/src/index.ts

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './blueprints';
+export * from './skills';
 export * from './meta';
 export * from './paths';
 export * from './types';

package/src/operations/create-chat.ts

@@ -6,14 +6,13 @@ import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { AiContext } from '@dxos/assistant';
-import { Chat, DatabaseBlueprint, AgentWizardBlueprint } from '@dxos/assistant-toolkit';
-import { Blueprint, Operation } from '@dxos/compute';
-import { Feed, Obj, Ref } from '@dxos/echo';
-import { createFeedServiceLayer } from '@dxos/echo-client';
+import { AgentWizardSkill, AlarmSkill, Chat, DatabaseSkill } from '@dxos/assistant-toolkit';
+import { Operation, Skill } from '@dxos/compute';
+import { Database, Feed, Obj, Ref } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 import { ClientCapabilities } from '@dxos/plugin-client';
 
-import { AssistantBlueprint } from '#blueprints';
+import { AssistantSkill } from '#skills';
 import { AssistantOperation } from '#types';
 
 const handler: Operation.WithHandler<typeof AssistantOperation.CreateChat> = AssistantOperation.CreateChat.pipe(
@@ -30,21 +29,21 @@ const handler: Operation.WithHandler<typeof AssistantOperation.CreateChat> = Ass
         space.db.add(chat);
       }
 
-      // Dynamic import to avoid circular dependency with the barrel that also exports BlueprintManagerHandlers.
-      const { BlueprintManagerBlueprint } = yield* Effect.promise(() => import('@dxos/assistant-toolkit'));
+      // Dynamic import to avoid circular dependency with the barrel that also exports SkillManagerHandlers.
+      const { SkillManagerSkill } = yield* Effect.promise(() => import('@dxos/assistant-toolkit'));
 
-      const feedServiceLayer = createFeedServiceLayer(space.db);
-      const runtime = yield* Effect.runtime<Feed.FeedService>().pipe(Effect.provide(feedServiceLayer));
+      const runtime = yield* Effect.runtime<Database.Service>().pipe(Effect.provide(Database.layer(space.db)));
       const binder = new AiContext.Binder({ feed, runtime, registry });
 
-      // Bind default blueprints via registry refs — no DB clone needed since the ECHO ref
+      // Bind default skills via registry refs — no DB clone needed since the ECHO ref
       // resolver already spans the hypergraph registry.
       yield* Effect.promise(() =>
         binder.use((b: AiContext.Binder) =>
           b.bind({
-            blueprints: [AssistantBlueprint, DatabaseBlueprint, AgentWizardBlueprint, BlueprintManagerBlueprint].map(
-              ({ key }) => Ref.fromURI(Blueprint.registryURI(key)),
+            skills: [AssistantSkill, DatabaseSkill, AgentWizardSkill, SkillManagerSkill, AlarmSkill].map(({ key }) =>
+              Ref.fromURI(Skill.registryURI(key)),
             ),
+            objects: [Ref.make(chat)],
           }),
         ),
       );

package/src/operations/fork-chat.ts

@@ -5,12 +5,11 @@
 import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
-import { Paths, LayoutOperation } from '@dxos/app-toolkit';
+import { LayoutOperation, Paths } from '@dxos/app-toolkit';
 import { AiContext, SessionLink } from '@dxos/assistant';
 import { Chat } from '@dxos/assistant-toolkit';
 import { Operation } from '@dxos/compute';
 import { Database, Feed, Filter, Obj, Ref } from '@dxos/echo';
-import { createFeedServiceLayer } from '@dxos/echo-client';
 import { invariant } from '@dxos/invariant';
 import { ClientCapabilities } from '@dxos/plugin-client';
 import { SpaceOperation } from '@dxos/plugin-space';
@@ -22,18 +21,15 @@ const handler: Operation.WithHandler<typeof AssistantOperation.ForkChat> = Assis
   Operation.withHandler(
     Effect.fnUntraced(function* ({ chat, companionTo }) {
       const { db } = yield* Database.Service;
-      const sourceFeed = chat.feed.target;
-      invariant(sourceFeed, 'Chat feed not found.');
+      const sourceFeed = yield* Database.load(chat.feed);
 
       const client = yield* Capability.get(ClientCapabilities.Client);
       const space = client.spaces.get(db.spaceId);
       invariant(space, 'Space not found.');
 
-      const feedServiceLayer = createFeedServiceLayer(space.db);
+      const dbLayer = Database.layer(space.db);
 
-      const messages = yield* Feed.runQuery(sourceFeed, Filter.type(Message.Message)).pipe(
-        Effect.provide(feedServiceLayer),
-      );
+      const messages = yield* Feed.query(sourceFeed, Filter.type(Message.Message)).run.pipe(Effect.provide(dbLayer));
 
       // Sort chronologically to find the last message.
       const sorted = messages
@@ -46,8 +42,7 @@ const handler: Operation.WithHandler<typeof AssistantOperation.ForkChat> = Assis
         db,
         name: sourceName ? `${sourceName} (fork)` : undefined,
       });
-      const newFeed = newChat.feed.target;
-      invariant(newFeed, 'New chat feed not found.');
+      const newFeed = yield* Database.load(newChat.feed);
 
       if (sorted.length > 0) {
         const lastMessage = sorted[sorted.length - 1];
@@ -58,32 +53,32 @@ const handler: Operation.WithHandler<typeof AssistantOperation.ForkChat> = Assis
             feedRef: Ref.make(sourceFeed),
             messageId: lastMessage.id,
           }),
-        ]).pipe(Effect.provide(feedServiceLayer));
+        ]).pipe(Effect.provide(dbLayer));
       }
 
-      // Copy source chat's blueprint and object bindings to the new feed.
+      // Copy source chat's skill and object bindings to the new feed.
       // Sort chronologically so add/remove events are applied in the correct order.
-      const sourceBindings = (yield* Feed.runQuery(sourceFeed, Filter.type(AiContext.Binding)).pipe(
-        Effect.provide(feedServiceLayer),
+      const sourceBindings = (yield* Feed.query(sourceFeed, Filter.type(AiContext.Binding)).run.pipe(
+        Effect.provide(dbLayer),
       )).filter(Obj.instanceOf(AiContext.Binding));
 
       if (sourceBindings.length > 0) {
         // Reduce binding events to the final active set.
-        const blueprintRefMap = new Map<string, Ref.Ref<any>>();
+        const skillRefMap = new Map<string, Ref.Ref<any>>();
         const objectRefMap = new Map<string, Ref.Ref<any>>();
         for (const binding of sourceBindings) {
-          binding.blueprints.added.forEach((ref: Ref.Ref<any>) => blueprintRefMap.set(ref.uri, ref));
-          binding.blueprints.removed.forEach((ref: Ref.Ref<any>) => blueprintRefMap.delete(ref.uri));
+          binding.skills.added.forEach((ref: Ref.Ref<any>) => skillRefMap.set(ref.uri, ref));
+          binding.skills.removed.forEach((ref: Ref.Ref<any>) => skillRefMap.delete(ref.uri));
           binding.objects.added.forEach((ref: Ref.Ref<any>) => objectRefMap.set(ref.uri, ref));
           binding.objects.removed.forEach((ref: Ref.Ref<any>) => objectRefMap.delete(ref.uri));
         }
 
         yield* Feed.append(newFeed, [
           Obj.make(AiContext.Binding, {
-            blueprints: { added: Array.from(blueprintRefMap.values()), removed: [] },
+            skills: { added: Array.from(skillRefMap.values()), removed: [] },
             objects: { added: Array.from(objectRefMap.values()), removed: [] },
           }),
-        ]).pipe(Effect.provide(feedServiceLayer));
+        ]).pipe(Effect.provide(dbLayer));
       }
 
       if (companionTo) {