@dxos/assistant-toolkit 0.9.1-staging.ee54ba693a → 0.11.0

package/src/skills/agent/operations/relay.ts

@@ -0,0 +1,124 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as LanguageModel from '@effect/ai/LanguageModel';
+import * as Prompt from '@effect/ai/Prompt';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { AiService } from '@dxos/ai';
+import { Operation } from '@dxos/compute';
+import { getSession } from '@dxos/compute/AgentService';
+import { Database, Obj } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { trim } from '@dxos/util';
+
+import { Agent, Chat } from '../../../types';
+import { Relay } from './definitions';
+
+/**
+ * The relay pattern (plugin-projects PLAN.md phase C): one trigger per subscribed feed runs this
+ * relay, which qualifies the event with a cheap model and, when relevant, forwards it onto the
+ * chat's durable session (the process input queue) — multiplexing and filtering in one construct,
+ * with no intermediate staging feed.
+ */
+const handler: Operation.WithHandler<typeof Relay> = Relay.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(
+      function* ({ chat: chatRef, event, prompt, qualify }) {
+        if (!event && !prompt) {
+          return yield* Effect.die(new Error('Relay requires an event or a prompt.'));
+        }
+        const chat = yield* Database.load(chatRef).pipe(
+          Effect.catchTag('EntityNotFoundError', () => Effect.die(new Error('Unable to load relay chat.'))),
+        );
+
+        if (event && (qualify ?? true)) {
+          // Fail open (matching the prompt's "if unsure, return true"): a malformed model reply
+          // forwards the event rather than silently dropping it.
+          const relevant = yield* qualifyEvent(chat, event).pipe(
+            Effect.retry({ times: 1 }),
+            Effect.catchAll((error) =>
+              Effect.sync(() => {
+                log.warn('relay qualification failed; forwarding event', { error });
+                return true;
+              }),
+            ),
+          );
+          if (!relevant) {
+            return;
+          }
+        }
+
+        const feed = yield* Database.load(chat.feed).pipe(
+          Effect.catchTag('EntityNotFoundError', () => Effect.die(new Error('Unable to load relay chat feed.'))),
+        );
+        // The durable session recovers steering from its spawn annotation; passing the ref here
+        // keeps the reuse identity honest (a repointed ref respawns the process).
+        const session = yield* getSession(feed, { instructions: chat.instructions });
+        const content = prompt ?? JSON.stringify(event);
+        yield* session.submitPrompt([{ _tag: 'text', text: content, disposition: 'synthetic' }]);
+      },
+      Effect.provide(AiService.model('com.anthropic.model.claude-sonnet-4-6.default')),
+    ),
+  ),
+  Operation.opaqueHandler,
+);
+
+/** Cheap-model relevance check, ported from the retired Qualifier's prompt (chat-centric per phase B). */
+const qualifyEvent = (chat: Chat.Chat, event: unknown) =>
+  Effect.gen(function* () {
+    const agent = yield* Agent.loadForChat(chat);
+    const instructions = chat.instructions
+      ? yield* Database.load(chat.instructions).pipe(Effect.orElseSucceed(() => undefined))
+      : undefined;
+    const instructionsText = instructions
+      ? yield* Database.load(instructions.text).pipe(
+          Effect.map((doc) => doc.content),
+          Effect.catchTag('EntityNotFoundError', () => Effect.succeed('')),
+        )
+      : '';
+    const checklistText = yield* Chat.formatChecklist(chat);
+
+    const { value } = yield* Effect.scoped(
+      LanguageModel.generateObject({
+        schema: Schema.Struct({
+          isRelevant: Schema.Boolean,
+        }),
+        prompt: Prompt.fromMessages([
+          Prompt.systemMessage({
+            content: trim`
+              You are a qualifying agent that determines if the event is relevant to the agent.
+              Respond with true if the event is relevant to the agent, false otherwise.
+              If you are not sure, return true.
+              The qualified events will be forwarded to the larger agent that will process them.
+              <agent id="${agent ? Obj.getURI(agent) : 'unknown'}" name="${agent?.name ?? ''}">
+                <instructions>
+                ${instructionsText}
+                </instructions>
+                <checklist>
+                  ${checklistText}
+                </checklist>
+              </agent>
+            `,
+          }),
+          Prompt.userMessage({
+            content: [
+              Prompt.makePart('text', {
+                text: trim`
+                  <event>
+                    ${JSON.stringify(event, null, 2)}
+                  </event>
+                `,
+              }),
+            ],
+          }),
+        ]),
+      }),
+    );
+
+    return value.isRelevant;
+  });
+
+export default handler;

package/src/skills/agent/skill.ts

@@ -5,8 +5,6 @@
 import { Skill, Template } from '@dxos/compute';
 import { trim } from '@dxos/util';
 
-import { AddArtifact } from './operations/definitions';
-
 const SKILL_KEY = 'org.dxos.skill.agent';
 
 /**
@@ -21,10 +19,9 @@ const make = () =>
       source: trim`
         You work on an agent. Each agent has instructions - the goal of the agent.
         The agent plan shows the current progress of the agent.
-        Agent has a number of associated artifacts you can read/write.
-        You can edit them if necessary.
-
-        IMPORTANT: When creating a new artifact, always add it to the agent using the add-artifact function.
+        Durable work products belong to the agent's project: when you create an object the agent
+        should keep, file it into the project's artifacts (the add-artifact tool of the Project
+        skill) rather than leaving it loose in the space.
 
         {{#with agent}}
         <agent id="{{id}}" name="{{name}}">
@@ -34,14 +31,6 @@ const make = () =>
           <plan>
             {{plan}}
           </plan>
-
-          <artifacts>
-          {{#each artifacts}}
-            <artifact type="{{type}}" dxn="{{dxn}}">
-              {{name}}
-            </artifact>
-          {{/each}}
-          </artifacts>
         </agent>
         {{/with}}
       `,
@@ -53,7 +42,6 @@ const make = () =>
         },
       ],
     }),
-    tools: Skill.toolDefinitions({ operations: [AddArtifact] }),
   });
 
 const skill: Skill.Definition = {

package/src/skills/agent-wizard/operations/create-agent.ts

@@ -9,7 +9,7 @@ import { Obj, Ref } from '@dxos/echo';
 
 import { Agent } from '../../../types';
 import { AgentSkill } from '../../agent';
-import { CreateAgent, SyncTriggers } from './definitions';
+import { CreateAgent, SyncAutomation } from './definitions';
 
 export default CreateAgent.pipe(
   Operation.withHandler(
@@ -19,11 +19,11 @@ export default CreateAgent.pipe(
           name,
           instructions,
           skills: yield* Effect.forEach(skills, (key) => Skill.upsert(key).pipe(Effect.map(Ref.make), Effect.orDie)),
-          subscriptions,
         },
         Obj.clone(AgentSkill.make()),
       );
-      yield* Operation.invoke(SyncTriggers, { agent: Ref.make(agent) });
+      // Subscriptions compile straight to Routines (the agent stores no automation fields).
+      yield* Operation.invoke(SyncAutomation, { agent: Ref.make(agent), subscriptions });
       return agent;
     }),
   ),

package/src/skills/agent-wizard/operations/definitions.ts

@@ -48,18 +48,33 @@ export const CreateAgent = Operation.make({
   services: [Registry.Service, Database.Service],
 });
 
-export const SyncTriggers = Operation.make({
+export const SyncAutomation = Operation.make({
   meta: {
     key: DXN.make('org.dxos.function.agent.syncTriggers'),
-    name: 'Sync triggers',
+    name: 'Sync automation',
     description:
-      'Synchronizes triggers with the agent: subscriptions, cron, filter-events, and enabled (copied to every trigger). Call after editing those fields.',
+      'Compiles the agent automation config (subscriptions, optional cron) into Routines that relay events onto the agent session. Recreates everything, so call with the FULL desired config after any change; enabled is copied from the agent onto every trigger.',
     icon: 'ph--arrows-clockwise--regular',
   },
   input: Schema.Struct({
     agent: Ref.Ref(Agent.Agent).annotations({
-      description: 'The agent whose triggers should be synced.',
+      description: 'The agent whose automation should be synced.',
     }),
+    subscriptions: Schema.optional(
+      Schema.Array(Ref.Ref(Obj.Unknown)).annotations({
+        description: 'The objects to subscribe to (e.g. mailboxes); each compiles to a feed-triggered routine.',
+      }),
+    ),
+    cron: Schema.optional(
+      Schema.String.annotations({
+        description: 'Cron expression for a scheduled wake routine.',
+      }),
+    ),
+    qualify: Schema.optional(
+      Schema.Boolean.annotations({
+        description: 'Run the cheap-model relevance filter on subscription events (default true).',
+      }),
+    ),
   }),
   output: Schema.Void,
   services: [Database.Service],

package/src/skills/agent-wizard/operations/index.ts

@@ -9,5 +9,5 @@ export * as AgentWizardOperations from './definitions';
 export const AgentWizardHandlers = OperationHandlerSet.lazy(
   () => import('./create-agent'),
   () => import('./agent-rules'),
-  () => import('./sync-triggers'),
+  () => import('./sync-automation'),
 );

package/src/skills/agent-wizard/operations/sync-automation.test.ts

@@ -0,0 +1,103 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { Operation, Routine, Trigger } from '@dxos/compute';
+import { Database, Filter, Obj, Query, Ref } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { invariant } from '@dxos/invariant';
+import { EntityId } from '@dxos/keys';
+
+import { OperationTestLayer } from '../../../testing';
+import { Agent } from '../../../types';
+import { Relay } from '../../agent/operations/definitions';
+import AgentSkillDef from '../../agent/skill';
+import { AgentWizardOperations } from '../index';
+
+EntityId.dangerouslyDisableRandomness();
+
+describe('SyncAutomation', () => {
+  const skill = AgentSkillDef.make();
+
+  it.effect(
+    'cron creates a timer routine that relays into the agent session',
+    Effect.fnUntraced(
+      function* (_) {
+        const cron = '*/5 * * * *';
+        const agent = yield* Agent.makeInitialized(
+          { name: 'Scheduled agent', instructions: 'A scheduled agent that runs on a timer.' },
+          skill,
+        );
+        yield* Database.flush();
+
+        yield* Operation.invoke(AgentWizardOperations.SyncAutomation, { agent: Ref.make(agent), cron });
+
+        const triggers = yield* Database.query(
+          Query.select(Filter.type(Trigger.Trigger)).debugLabel('assistant-toolkit.sync-automation.timer'),
+        ).run;
+        const timerTriggers = triggers.filter(
+          (trigger) => trigger.spec?.kind === 'timer' && trigger.spec.cron === cron,
+        );
+        expect(timerTriggers).toHaveLength(1);
+
+        const timerTrigger = timerTriggers[0];
+        expect(timerTrigger.enabled).toBe(true);
+
+        // The timer routine relays a synthetic wake prompt into the agent's durable session.
+        invariant(timerTrigger.runnable);
+        const operation = yield* Database.load(timerTrigger.runnable);
+        invariant(Obj.instanceOf(Operation.PersistentOperation, operation));
+        expect(Obj.getMeta(operation).key).toBe(Relay.meta.key);
+
+        // The trigger is wrapped in a user-facing Routine aggregate.
+        const routines = yield* Database.query(
+          Query.select(Filter.type(Routine.Routine)).debugLabel('assistant-toolkit.sync-automation.timer-routine'),
+        ).run;
+        expect(routines).toHaveLength(1);
+        expect(routines[0].triggers.map((ref) => ref.uri)).toContain(Ref.make(timerTrigger).uri);
+      },
+      Effect.provide(OperationTestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.effect(
+    'copies enabled from the agent onto every trigger',
+    Effect.fnUntraced(
+      function* (_) {
+        const cron = '0 9 * * *';
+        const agent = yield* Agent.makeInitialized(
+          { name: 'Toggle agent', instructions: 'Test enabled propagation.', enabled: false },
+          skill,
+        );
+        yield* Database.flush();
+
+        yield* Operation.invoke(AgentWizardOperations.SyncAutomation, { agent: Ref.make(agent), cron });
+
+        const triggers = yield* Database.query(
+          Query.select(Filter.type(Trigger.Trigger)).debugLabel('assistant-toolkit.sync-automation.toggle'),
+        ).run;
+        // `every` is vacuously true on an empty array; assert the triggers exist first.
+        expect(triggers.length).toBeGreaterThan(0);
+        expect(triggers.every((trigger) => trigger.enabled === false)).toBe(true);
+
+        Obj.update(agent, (agent) => {
+          agent.enabled = true;
+        });
+        yield* Database.flush();
+        yield* Operation.invoke(AgentWizardOperations.SyncAutomation, { agent: Ref.make(agent), cron });
+
+        const triggersAfter = yield* Database.query(
+          Query.select(Filter.type(Trigger.Trigger)).debugLabel('assistant-toolkit.sync-automation.after'),
+        ).run;
+        expect(triggersAfter).toHaveLength(triggers.length);
+        expect(triggersAfter.every((trigger) => trigger.enabled === true)).toBe(true);
+      },
+      Effect.provide(OperationTestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});

package/src/skills/agent-wizard/operations/sync-automation.ts

@@ -0,0 +1,205 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Operation, Routine, Trigger } from '@dxos/compute';
+import { Database, Feed, Filter, Obj, Ref, Type } from '@dxos/echo';
+import { FeedAnnotation } from '@dxos/schema';
+
+import { Agent } from '../../../types';
+import { SyncAutomation } from './definitions';
+
+export default SyncAutomation.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ agent: agentRef, subscriptions, cron, qualify }) {
+      const agent = yield* Database.load(agentRef);
+      yield* syncAgentAutomation(agent, { subscriptions, cron, qualify: qualify ?? true });
+    }),
+  ),
+);
+
+/**
+ * Foreign key {@link AGENT_TRIGGER_EXTENSION_KEY} => <agent id : EntityId>.
+ */
+const AGENT_TRIGGER_EXTENSION_KEY = 'org.dxos.extension.AgentTrigger';
+
+/**
+ * Foreign key {@link AGENT_TRIGGER_TARGET_EXTENSION_KEY} => <dxn string of subscription target>.
+ */
+const AGENT_TRIGGER_TARGET_EXTENSION_KEY = 'org.dxos.extension.AgentTriggerTarget';
+
+/** Reads a feed-annotated object's `feed` ref without assuming its schema shape. */
+const getFeedRef = (obj: Obj.Unknown): Ref.Ref<Obj.Unknown> | undefined => {
+  if (!('feed' in obj)) {
+    return undefined;
+  }
+  const candidate = obj.feed;
+  // The target is type-checked after loading (`Obj.instanceOf(Feed.Feed, …)`), so the ref stays untyped here.
+  return Ref.isRef(candidate) ? candidate : undefined;
+};
+
+/** Checks if an object's schema has the FeedAnnotation. */
+const hasFeedAnnotation = (obj: Obj.Unknown): boolean => {
+  const type = Obj.getType(obj);
+  if (!type) {
+    return false;
+  }
+  const annotation = FeedAnnotation.get(Type.getSchema(type));
+  return Option.isSome(annotation) && annotation.value === true;
+};
+
+export type AutomationConfig = {
+  /** Omitted (vs empty) leaves existing subscription routines untouched. */
+  subscriptions?: readonly Ref.Ref<Obj.Unknown>[];
+  /** Omitted leaves an existing schedule routine untouched; empty string removes it. */
+  cron?: string;
+  /** Run the cheap-model relevance check before forwarding subscription events. */
+  qualify: boolean;
+};
+
+/** A schedule routine's target key is `timer:<cron>`; subscription keys are the target's URI. */
+const isTimerKey = (id: string | undefined): boolean => id?.startsWith('timer:') ?? false;
+
+const targetKeyOf = (entity: Obj.Unknown): string | undefined =>
+  Obj.getMeta(entity).keys.find((key) => key.source === AGENT_TRIGGER_TARGET_EXTENSION_KEY)?.id;
+
+/**
+ * Compiles the agent's automation config into Routines whose triggers run the Relay: the relay
+ * qualifies each event with a cheap model and forwards relevant ones onto the chat's durable
+ * session. Re-running deletes and recreates the categories present in the config.
+ */
+export const syncAgentAutomation = (
+  agent: Agent.Agent,
+  config: AutomationConfig,
+): Effect.Effect<void, never, Database.Service> =>
+  Effect.gen(function* () {
+    // Resolve the chat before the destructive phase: a transient resolution gap must not wipe
+    // existing automation without recreating it.
+    const chat = yield* Agent.loadChat(agent);
+    if (!chat) {
+      return;
+    }
+    const chatRef = Ref.make(chat);
+
+    const triggers = yield* Database.query(
+      Filter.foreignKeys(Trigger.Trigger, [{ source: AGENT_TRIGGER_EXTENSION_KEY, id: agent.id }]),
+    ).run;
+    const routines = yield* Database.query(
+      Filter.foreignKeys(Routine.Routine, [{ source: AGENT_TRIGGER_EXTENSION_KEY, id: agent.id }]),
+    ).run;
+
+    // Reconcile per category: only the categories present in the config are recreated, so a
+    // subscriptions-only update (e.g. a UI toggle) cannot silently drop the schedule routine.
+    // Recreation keeps operation, concurrency, and enabled in sync when the config changes.
+    const shouldRemove = (entity: Obj.Unknown): boolean => {
+      const timer = isTimerKey(targetKeyOf(entity));
+      return timer ? config.cron !== undefined : config.subscriptions !== undefined;
+    };
+    for (const trigger of triggers.filter(shouldRemove)) {
+      yield* Database.remove(trigger);
+    }
+    for (const routine of routines.filter(shouldRemove)) {
+      yield* Database.remove(routine);
+    }
+
+    const triggersEnabled = agent.enabled ?? true;
+
+    // Lazy import to avoid circular dependency issues.
+    const { Relay } = yield* Effect.promise(() => import('../../agent/operations/definitions'));
+
+    const makeRoutine = (options: {
+      name: string;
+      targetKey: string;
+      spec: Trigger.Trigger['spec'];
+      input: Record<string, unknown>;
+      concurrency?: number;
+    }): Effect.Effect<void, never, Database.Service> =>
+      Effect.gen(function* () {
+        const keys = [
+          { source: AGENT_TRIGGER_EXTENSION_KEY, id: agent.id },
+          { source: AGENT_TRIGGER_TARGET_EXTENSION_KEY, id: options.targetKey },
+        ];
+        const runnable = yield* Database.add(Operation.serialize(Relay));
+        const trigger = yield* Database.add(
+          Trigger.make({
+            [Obj.Parent]: agent,
+            [Obj.Meta]: { keys },
+            enabled: triggersEnabled,
+            spec: options.spec,
+            runnable: Ref.make(runnable),
+            input: options.input,
+            ...(options.concurrency !== undefined ? { concurrency: options.concurrency } : {}),
+          }),
+        );
+        // The Routine is the user-facing aggregate (action + trigger), shared with projects.
+        yield* Database.add(
+          Obj.make(Routine.Routine, {
+            [Obj.Parent]: agent,
+            [Obj.Meta]: { keys },
+            name: options.name,
+            spec: { kind: 'runnable', runnable: Ref.make(runnable) },
+            triggers: [Ref.make(trigger)],
+          }),
+        );
+      });
+
+    for (const subscription of config.subscriptions ?? []) {
+      const targetOption = yield* Database.load(subscription).pipe(
+        Effect.map(Option.some),
+        Effect.catchTag('EntityNotFoundError', () => Effect.succeed(Option.none())),
+      );
+      if (Option.isNone(targetOption)) {
+        continue;
+      }
+      const target = targetOption.value;
+
+      let feedObj: Feed.Feed | undefined;
+      if (Obj.instanceOf(Feed.Feed, target)) {
+        feedObj = target;
+      } else if (hasFeedAnnotation(target)) {
+        const feedRef = getFeedRef(target);
+        feedObj = feedRef
+          ? Option.getOrUndefined(
+              yield* Database.load(feedRef).pipe(
+                Effect.map(Option.some),
+                Effect.catchTag('EntityNotFoundError', () => Effect.succeed(Option.none())),
+              ),
+            )
+          : undefined;
+      }
+
+      if (!feedObj || !Obj.instanceOf(Feed.Feed, feedObj) || !Feed.getFeedUri(feedObj)) {
+        continue;
+      }
+
+      yield* makeRoutine({
+        name: `${agent.name ?? 'Agent'} — ${Obj.getLabel(target) ?? 'subscription'}`,
+        targetKey: subscription.uri,
+        spec: Trigger.specFeed(feedObj),
+        input: {
+          chat: chatRef,
+          event: '{{event}}',
+          ...(config.qualify ? {} : { qualify: false }),
+        },
+        concurrency: config.qualify ? 5 : undefined,
+      });
+    }
+
+    // Timer wake: a synthetic prompt through the same relay path (no event, so no qualification).
+    if (config.cron) {
+      yield* makeRoutine({
+        name: `${agent.name ?? 'Agent'} — schedule`,
+        targetKey: `timer:${config.cron}`,
+        spec: Trigger.specTimer(config.cron),
+        input: {
+          chat: chatRef,
+          prompt: 'Scheduled wake: continue your instructions and review outstanding work.',
+        },
+      });
+    }
+
+    yield* Database.flush();
+  });

package/src/skills/agent-wizard/skill.ts

@@ -5,7 +5,7 @@
 import { Skill, Template } from '@dxos/compute';
 import { trim } from '@dxos/util';
 
-import { AgentRules, CreateAgent, SyncTriggers } from './operations/definitions';
+import { AgentRules, CreateAgent, SyncAutomation } from './operations/definitions';
 
 const SKILL_KEY = 'org.dxos.skill.agentWizard';
 
@@ -17,7 +17,7 @@ const make = () =>
   Skill.make({
     key: SKILL_KEY,
     name: 'Agent Wizard',
-    description: 'Help the user create a new agent (subscriptions, optional cron timer, sync-triggers after edits).',
+    description: 'Help the user create a new agent (subscriptions and optional cron compile to routines).',
     agentCanEnable: true,
     instructions: Template.make({
       source: trim`
@@ -26,22 +26,21 @@ const make = () =>
         Agents are goal oriented and autonomously driven.
         Each agent has instructions - the goal of the agent.
         The instructions also typically describe what actions to perform in reaction to events (emails).
-        The agent has a number of associated artifacts to work with.
-        Agents can subscribe to emails.
+        Agents can subscribe to emails, and durable work products belong to a project's artifacts.
 
-        Agents have a \`cron\` field: when set, the agent runs on a timer on that schedule (standard cron syntax).
-        Use \`cron\` when the user wants the agent to run periodically (e.g. "every morning", "once a day", "every 5 minutes").
-        Examples: \`0 9 * * *\` for daily at 09:00, or \`*/5 * * * *\` for every 5 minutes.
-        Timer triggers bypass the qualifier and invoke the agent worker directly on the schedule.
+        Automation (subscriptions and an optional cron schedule) is compiled into routines, not stored
+        on the agent: pass subscriptions when creating the agent, and use the sync-automation tool with
+        the FULL desired config to change automation later (a cron expression schedules periodic wakes,
+        e.g. \`0 9 * * *\` for daily at 09:00; \`enabled\` on the agent is applied to every trigger).
 
         The agent itself is an ECHO object and can be edited like any other object using the database skill.
         You can edit the agent's instructions, name, and other properties directly.
-        If you edit the agent's \`enabled\` field, \`filterEvents\` field, subscriptions array, or \`cron\` field, you MUST call the sync-triggers function afterward to synchronize the triggers (\`enabled\` is applied to all triggers).
+        If you edit the agent's \`enabled\` field, you MUST call sync-automation afterward so triggers pick it up.
 
         IMPORTANT: Before attempting to create an agent call the [agent-rules] tool to get the rules for creating an agent.
       `,
     }),
-    tools: Skill.toolDefinitions({ operations: [AgentRules, CreateAgent, SyncTriggers] }),
+    tools: Skill.toolDefinitions({ operations: [AgentRules, CreateAgent, SyncAutomation] }),
   });
 
 const skill: Skill.Definition = {

package/src/skills/alarm/skill.test.ts

@@ -6,11 +6,11 @@ import { describe, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 import * as Either from 'effect/Either';
 
+import { AgentService } from '@dxos/agent-runtime';
+import { AssistantTestLayer } from '@dxos/agent-runtime/testing';
 import { Operation, Skill } from '@dxos/compute';
 import { Feed, Obj } from '@dxos/echo';
 import { TestHelpers } from '@dxos/effect/testing';
-import { AgentService } from '@dxos/functions-runtime';
-import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 import { EntityId } from '@dxos/keys';
 import { Organization } from '@dxos/types';
 

package/src/skills/browser/skill.test.ts

@@ -5,19 +5,19 @@
 import { describe, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 
+import { AgentService } from '@dxos/agent-runtime';
+import { AssistantTestLayerWithTriggers } from '@dxos/agent-runtime/testing';
 import { MemoizedAiService } from '@dxos/ai/testing';
+import { WithProperties } from '@dxos/app-toolkit/testing';
 import { SpaceProperties } from '@dxos/client-protocol';
 import { OperationHandlerSet, Skill } from '@dxos/compute';
 import { Collection, Database, Feed, Query } from '@dxos/echo';
 import { TestHelpers } from '@dxos/effect/testing';
-import { AgentService } from '@dxos/functions-runtime';
-import { AssistantTestLayerWithTriggers } from '@dxos/functions-runtime/testing';
 import { EntityId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { MarkdownSkill } from '@dxos/plugin-markdown';
 import { Markdown } from '@dxos/plugin-markdown';
 import { MarkdownOperationHandlerSet } from '@dxos/plugin-markdown/plugin';
-import { WithProperties } from '@dxos/plugin-markdown/testing';
 import { Person } from '@dxos/types';
 
 import { DatabaseHandlers, DatabaseSkill } from '../database';
@@ -34,7 +34,7 @@ const TestLayer = AssistantTestLayerWithTriggers({
 });
 
 // NOTE: Not run by default since it acceses internet.
-describe('Browser', { tags: ['llm'] }, () => {
+describe('Browser', { tags: ['manual'] }, () => {
   it.effect(
     'scrape effect blog',
     Effect.fnUntraced(