@dxos/plugin-routine 0.10.0 → 0.11.1

package/src/capabilities/trigger-runtime-controller.test.ts

@@ -6,9 +6,9 @@ import * as Effect from 'effect/Effect';
 import { describe, test } from 'vitest';
 
 import { ServiceResolver } from '@dxos/compute';
+import { TriggerDispatcher } from '@dxos/compute-runtime';
 import { Feed, Obj } from '@dxos/echo';
 import { EffectEx } from '@dxos/effect';
-import { TriggerDispatcher } from '@dxos/functions-runtime';
 import type { SpaceId } from '@dxos/keys';
 import { ClientCapabilities, ClientEvents } from '@dxos/plugin-client';
 import { ClientPlugin, initializeIdentity } from '@dxos/plugin-client/testing';
@@ -30,7 +30,7 @@ const getDispatcher = (harness: Awaited<ReturnType<typeof createComposerTestApp>
   );
 
 describe('TriggerRuntimeController', () => {
-  test('toggles the per-space TriggerDispatcher as computeEnvironment changes', async ({ expect }) => {
+  test('toggles the per-space TriggerDispatcher as triggersDisabled changes', async ({ expect }) => {
     await using harness = await createComposerTestApp({
       plugins: [ClientPlugin({ types: [Feed.Feed] }), RoutinePlugin()],
     });
@@ -51,36 +51,30 @@ describe('TriggerRuntimeController', () => {
       immediate: true,
     });
     try {
-      // Default `computeEnvironment` is `local`, so the controller should
+      // `triggersDisabled` is unset by default, so the controller should
       // start the dispatcher shortly after the space becomes ready.
       await expect.poll(() => harness.registry.get(dispatcher.state).enabled, { timeout: 5_000 }).toBe(true);
 
-      // `disabled` → dispatcher should stop.
+      // `triggersDisabled = true` → dispatcher should stop.
       Obj.update(personalSpace.properties, (properties) => {
-        properties.computeEnvironment = 'disabled';
+        properties.triggersDisabled = true;
       });
       await expect.poll(() => harness.registry.get(dispatcher.state).enabled, { timeout: 5_000 }).toBe(false);
 
-      // Back to `local` → dispatcher should start again.
+      // Back to enabled → dispatcher should start again.
       Obj.update(personalSpace.properties, (properties) => {
-        properties.computeEnvironment = 'local';
+        properties.triggersDisabled = false;
       });
       await expect.poll(() => harness.registry.get(dispatcher.state).enabled, { timeout: 5_000 }).toBe(true);
 
-      // `edge` → dispatcher should stop (triggers run on the edge instead).
-      Obj.update(personalSpace.properties, (properties) => {
-        properties.computeEnvironment = 'edge';
-      });
-      await expect.poll(() => harness.registry.get(dispatcher.state).enabled, { timeout: 5_000 }).toBe(false);
-
       // The atom subscription should have witnessed every transition.
-      expect(observedStates).toEqual(expect.arrayContaining([true, false, true, false]));
+      expect(observedStates).toEqual(expect.arrayContaining([true, false, true]));
     } finally {
       unsubscribe();
     }
   });
 
-  test('does not re-issue start when computeEnvironment is reasserted to the same value', async ({ expect }) => {
+  test('does not re-issue start when triggersDisabled is reasserted to the same value', async ({ expect }) => {
     await using harness = await createComposerTestApp({
       plugins: [ClientPlugin({ types: [Feed.Feed] }), RoutinePlugin()],
     });
@@ -94,11 +88,11 @@ describe('TriggerRuntimeController', () => {
 
     await expect.poll(() => harness.registry.get(dispatcher.state).enabled, { timeout: 5_000 }).toBe(true);
 
-    // Writing the same `local` value should be a no-op: the controller
-    // dedupes via its `lastEnvironment` tracker so the dispatcher stays
+    // Writing the same enabled state should be a no-op: the controller
+    // dedupes via its `lastDisabled` tracker so the dispatcher stays
     // running without an intervening stop/start flicker.
     Obj.update(personalSpace.properties, (properties) => {
-      properties.computeEnvironment = 'local';
+      properties.triggersDisabled = false;
     });
     // Give any spurious transition a chance to land before we check.
     await new Promise((resolve) => setTimeout(resolve, 100));

package/src/capabilities/trigger-runtime-controller.ts

@@ -6,10 +6,9 @@ import * as Effect from 'effect/Effect';
 import * as Fiber from 'effect/Fiber';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
-import { type ComputeEnvironment } from '@dxos/client-protocol';
 import { ServiceResolver } from '@dxos/compute';
+import { TriggerDispatcher } from '@dxos/compute-runtime';
 import { Obj } from '@dxos/echo';
-import { TriggerDispatcher } from '@dxos/functions-runtime';
 import { type SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { ClientCapabilities } from '@dxos/plugin-client';
@@ -18,30 +17,28 @@ import { type Space } from '@dxos/react-client/echo';
 //
 // Capability Module
 //
-// Watches `space.properties.computeEnvironment` for every space and toggles
+// Watches `space.properties.triggersDisabled` for every space and toggles
 // the per-space {@link TriggerDispatcher} accordingly:
 //
-//   - `local`              → `dispatcher.start()`
-//   - `edge` / `disabled`  → `dispatcher.stop()`
+//   - disabled (`true`)        → `dispatcher.stop()`
+//   - enabled (unset/`false`)  → `dispatcher.start()`
 //
-// Replaces the in-line watcher that used to live inside the removed
-// `compute-runtime.ts` per-space layer. The dispatcher itself is now
-// contributed unconditionally via `TriggerDispatcherSpec` in `layer-specs.ts`,
-// so this capability is only responsible for driving its lifecycle.
+// Per-trigger local/edge routing is handled by the trigger's `remote` flag
+// (the dispatcher skips remote triggers); this space-wide flag is only the
+// kill-switch for local execution. The dispatcher itself is contributed
+// unconditionally via `TriggerDispatcherSpec` in `layer-specs.ts`, so this
+// capability is only responsible for driving its lifecycle.
 //
 
-/** Trigger execution location the dispatcher should run locally. */
-const LOCAL_ENVIRONMENT: ComputeEnvironment = 'local';
-
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
     const client = yield* Capability.get(ClientCapabilities.Client);
     const runtime = yield* Capability.get(Capabilities.ProcessManagerRuntime);
 
-    /** Per-space property-subscription unsubscribe, last-seen environment, and in-flight transition fiber. */
+    /** Per-space property-subscription unsubscribe, last-seen disabled state, and in-flight transition fiber. */
     type Tracker = {
       unsubscribe: () => void;
-      lastEnvironment?: ComputeEnvironment;
+      lastDisabled?: boolean;
       inFlight?: Fiber.RuntimeFiber<unknown, unknown>;
     };
     const trackers = new Map<SpaceId, Tracker>();
@@ -49,31 +46,31 @@ export default Capability.makeModule(
     /**
      * Resolve the per-space `TriggerDispatcher` from the process-manager
      * runtime and invoke `start()` / `stop()` according to the requested
-     * environment. Returns a fiber so the caller can cancel a pending
+     * disabled state. Returns a fiber so the caller can cancel a pending
      * transition when a new one supersedes it.
      */
-    const transition = (spaceId: SpaceId, environment: ComputeEnvironment) =>
+    const transition = (spaceId: SpaceId, disabled: boolean) =>
       runtime.runFork(
         Effect.gen(function* () {
           const dispatcher = yield* TriggerDispatcher;
-          yield* environment === LOCAL_ENVIRONMENT ? dispatcher.start() : dispatcher.stop();
+          yield* disabled ? dispatcher.stop() : dispatcher.start();
         }).pipe(
           Effect.provide(ServiceResolver.provide({ space: spaceId }, TriggerDispatcher)),
           Effect.tapErrorCause((cause) =>
-            Effect.sync(() => log.warn('trigger dispatcher transition failed', { spaceId, environment, cause })),
+            Effect.sync(() => log.warn('trigger dispatcher transition failed', { spaceId, disabled, cause })),
           ),
         ),
       );
 
-    const apply = (tracker: Tracker, spaceId: SpaceId, environment: ComputeEnvironment): void => {
-      if (tracker.lastEnvironment === environment) {
+    const apply = (tracker: Tracker, spaceId: SpaceId, disabled: boolean): void => {
+      if (tracker.lastDisabled === disabled) {
         return;
       }
-      tracker.lastEnvironment = environment;
+      tracker.lastDisabled = disabled;
       if (tracker.inFlight) {
         runtime.runFork(Fiber.interrupt(tracker.inFlight));
       }
-      tracker.inFlight = transition(spaceId, environment);
+      tracker.inFlight = transition(spaceId, disabled);
     };
 
     const install = (space: Space): void => {
@@ -94,9 +91,9 @@ export default Capability.makeModule(
           if (trackers.get(space.id) !== tracker) {
             return;
           }
-          const readEnvironment = (): ComputeEnvironment => space.properties.computeEnvironment ?? LOCAL_ENVIRONMENT;
-          tracker.unsubscribe = Obj.subscribe(space.properties, () => apply(tracker, space.id, readEnvironment()));
-          apply(tracker, space.id, readEnvironment());
+          const readDisabled = (): boolean => space.properties.triggersDisabled ?? false;
+          tracker.unsubscribe = Obj.subscribe(space.properties, () => apply(tracker, space.id, readDisabled()));
+          apply(tracker, space.id, readDisabled());
         })
         .catch((err) => log.catch(err));
     };

package/src/commands/trigger/create/{queue.ts → feed.ts}

@@ -20,7 +20,7 @@ import { EID } from '@dxos/keys';
 import { Enabled, Feed, Input } from '../options';
 import { printTrigger, promptForSchemaInput, selectFeed, selectFunction } from '../util';
 
-export const queue = Command.make(
+export const feed = Command.make(
   'feed',
   {
     spaceId: Common.spaceId.pipe(Options.optional),

package/src/commands/trigger/create/index.ts

@@ -4,11 +4,11 @@
 
 import * as Command from '@effect/cli/Command';
 
-import { queue } from './queue';
+import { feed } from './feed';
 import { subscription } from './subscription';
 import { timer } from './timer';
 
 export const create = Command.make('create').pipe(
   Command.withDescription('Create a trigger.'),
-  Command.withSubcommands([subscription, timer, queue]),
+  Command.withSubcommands([subscription, timer, feed]),
 );

package/src/commands/trigger/update/{queue.ts → feed.ts}

@@ -19,7 +19,7 @@ import { EID, type EntityId } from '@dxos/keys';
 import { Enabled, Feed, Input, TriggerId } from '../options';
 import { printTrigger, promptForSchemaInput, selectFeed, selectFunction, selectTrigger } from '../util';
 
-export const queue = Command.make(
+export const feed = Command.make(
   'feed',
   {
     spaceId: Common.spaceId.pipe(Options.optional),

package/src/commands/trigger/update/index.ts

@@ -4,11 +4,11 @@
 
 import * as Command from '@effect/cli/Command';
 
-import { queue } from './queue';
+import { feed } from './feed';
 import { subscription } from './subscription';
 import { timer } from './timer';
 
 export const update = Command.make('update').pipe(
   Command.withDescription('Update a trigger.'),
-  Command.withSubcommands([subscription, timer, queue]),
+  Command.withSubcommands([subscription, timer, feed]),
 );

package/src/commands/trigger/util.ts

@@ -13,8 +13,7 @@ import * as SchemaAST from 'effect/SchemaAST';
 
 import { FormBuilder } from '@dxos/cli-util';
 import { Operation, Trigger } from '@dxos/compute';
-// eslint-disable-next-line unused-imports/no-unused-imports
-import { Annotation, Database, Entity, Feed, Filter, Obj, Query, type QueryAST, Ref, Scope, Type } from '@dxos/echo';
+import { Annotation, Database, Entity, Feed, Filter, Obj, Query, Ref, Scope, Type } from '@dxos/echo';
 import { SchemaEx } from '@dxos/effect';
 import { DXN } from '@dxos/keys';
 import { FeedAnnotation } from '@dxos/schema';

package/src/components/InstructionsEditor/InstructionsEditor.stories.tsx

@@ -7,7 +7,8 @@ import React from 'react';
 
 import { Instructions, Skill } from '@dxos/compute';
 import { Filter, Ref } from '@dxos/echo';
-import { type Space, useQuery } from '@dxos/react-client/echo';
+import { useQuery } from '@dxos/echo-react';
+import { type Space } from '@dxos/react-client/echo';
 import { useClientStory, withClientProvider } from '@dxos/react-client/testing';
 import { Loading, withLayout, withTheme } from '@dxos/react-ui/testing';
 import { Text } from '@dxos/schema';
@@ -49,7 +50,7 @@ export default meta;
 
 type Story = StoryObj<typeof meta>;
 
-/** A routine with no skills or context objects: the form shows empty add affordances. */
+/** A routine with no skills: the form shows an empty add affordance. */
 export const Default: Story = {
   decorators: [
     withSeededSpace((space) => {
@@ -58,12 +59,12 @@ export const Default: Story = {
   ],
 };
 
-/** A routine seeded with a context object: the Objects field renders the populated ref slot. */
-export const WithObject: Story = {
+/** A routine seeded with a skill: the Skills field renders the populated ref slot. */
+export const WithSkill: Story = {
   decorators: [
     withSeededSpace((space) => {
-      const subject = space.db.add(Text.make({ content: 'Meeting notes' }));
-      space.db.add(Instructions.make({ name: 'Summarize notes', objects: [Ref.make(subject)] }));
+      const skill = space.db.add(Skill.make({ key: 'org.dxos.test.summarize', name: 'Summarize' }));
+      space.db.add(Instructions.make({ name: 'Summarize notes', skills: [Ref.make(skill)] }));
     }),
   ],
 };

package/src/components/InstructionsEditor/InstructionsEditor.tsx

@@ -12,50 +12,62 @@ import { Form } from '@dxos/react-ui-form';
 
 const INSTRUCTIONS_SCHEMA = Type.getSchema(Instructions.Instructions);
 
-// Owned-routine action fields surfaced for editing — the prompt text, the agent's `skills`,
-// and the context `objects` bound to its session at run. All live on the Instructions schema,
-// so a single form edits them together.
-const INSTRUCTIONS_FIELDS = new Set(['text', 'skills', 'objects']);
+// Owned-routine action fields surfaced by default — the prompt text and the agent's `skills`. The
+// context `objects` are excluded here so a routine form doesn't show a second, divergent list beside
+// its owning subject; a surface that owns the context concern (e.g. a project's Context section)
+// opts in via `fields`.
+const DEFAULT_FIELDS: readonly string[] = ['text', 'skills'];
 
 export type InstructionsEditorProps = {
-  db?: Database.Database;
+  db?: Database.Database; // TODO(burdon): Should not be optional if instructions are not.
   instructions: Instructions.Instructions;
   readonly?: boolean;
+  /** Instructions schema fields rendered AND written back; others are left untouched. */
+  fields?: readonly string[];
 };
 
 /**
- * Sub-form: edits the owned Instructions in place — its `text` (Markdown), `skills`, and the
- * context `objects` bound to its session at run, all fields of the Instructions schema. A bare Form.Root +
- * FieldSet (no Viewport) keeps these fields left-aligned with the sibling general/action forms; the
- * rendered fields are written back so selections persist to the instructions.
+ * Sub-form: edits the owned Instructions in place — by default its `text` (Markdown) and `skills`,
+ * both fields of the Instructions schema. A bare Form.Root + FieldSet (no Viewport) keeps these
+ * fields left-aligned with the sibling general/action forms; only the rendered fields are written
+ * back so a partial editor never clobbers the rest of the object.
  */
-export const InstructionsEditor = ({ db: dbProp, instructions, readonly }: InstructionsEditorProps) => {
+export const InstructionsEditor = ({
+  db: dbProp,
+  instructions,
+  readonly,
+  fields = DEFAULT_FIELDS,
+}: InstructionsEditorProps) => {
   // A draft routine is not yet attached to a database, so fall back to the explicit `db` for ref queries.
   const db = dbProp ?? Obj.getDatabase(instructions);
 
-  // `objects` is optional; normalize to an array so the ref-array field renders its add affordance.
   const defaultValues = useMemo<Partial<Instructions.Instructions>>(
-    () => ({ ...Obj.getSnapshot(instructions), objects: instructions.objects ? [...instructions.objects] : [] }),
+    () => ({ ...Obj.getSnapshot(instructions) }),
     [instructions],
   );
 
+  const fieldSet = useMemo(() => new Set(fields), [fields]);
   const handleValuesChanged = useCallback(
     (values: Partial<Instructions.Instructions>, { isValid }: { isValid: boolean }) => {
-      // Skip while invalid (e.g. an empty ref slot just added by a skills/objects array field) so a
-      // partial selection isn't persisted; the write lands once the slot is filled.
+      // Skip while invalid (e.g. an empty ref slot just added by the skills array field) so a partial
+      // selection isn't persisted; the write lands once the slot is filled.
       if (!isValid) {
         return;
       }
 
       Obj.update(instructions, (instructions) => {
-        if (values.text) {
+        if (fieldSet.has('text') && values.text) {
           instructions.text = values.text;
         }
-        instructions.skills = [...(values.skills ?? [])];
-        instructions.objects = [...(values.objects ?? [])];
+        if (fieldSet.has('skills')) {
+          instructions.skills = [...(values.skills ?? [])];
+        }
+        if (fieldSet.has('objects')) {
+          instructions.objects = [...(values.objects ?? [])];
+        }
       });
     },
-    [instructions],
+    [instructions, fieldSet],
   );
 
   return (
@@ -68,7 +80,7 @@ export const InstructionsEditor = ({ db: dbProp, instructions, readonly }: Instr
       getOptions={getRefOptions}
       onValuesChanged={handleValuesChanged}
     >
-      <Form.FieldSet filter={(props) => props.filter((prop) => INSTRUCTIONS_FIELDS.has(prop.name.toString()))} />
+      <Form.FieldSet filter={(props) => props.filter((prop) => fieldSet.has(prop.name.toString()))} />
     </Form.Root>
   );
 };

package/src/components/RoutineCard/RoutineCard.stories.tsx

@@ -0,0 +1,95 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React from 'react';
+
+import { Instructions, Routine, Trigger } from '@dxos/compute';
+import { Filter, Query } from '@dxos/echo';
+import { useQuery } from '@dxos/echo-react';
+import { type Space } from '@dxos/react-client/echo';
+import { useClientStory, withClientProvider } from '@dxos/react-client/testing';
+import { Card } from '@dxos/react-ui';
+import { Loading, withLayout, withTheme } from '@dxos/react-ui/testing';
+import { Text } from '@dxos/schema';
+
+import { translations } from '#translations';
+
+import { makeRoutine } from '../../util';
+import { RoutineCard } from './RoutineCard';
+
+const types = [Routine.Routine, Instructions.Instructions, Trigger.Trigger, Text.Text];
+
+const DefaultStory = () => {
+  const { space } = useClientStory();
+  const [routine] = useQuery(space?.db, Filter.type(Routine.Routine));
+  if (!space || !routine) {
+    return <Loading />;
+  }
+
+  // The surface host supplies Card.Root and the header; RoutineCard emits only the body.
+  return (
+    <Card.Root fullWidth>
+      <Card.Header>
+        <Card.Title>{routine.name ?? 'Untitled'}</Card.Title>
+      </Card.Header>
+      <RoutineCard subject={routine} />
+    </Card.Root>
+  );
+};
+
+const withSeededRoutine = ({ name, spec, enabled }: { name?: string; spec?: Trigger.Spec; enabled?: boolean } = {}) =>
+  withClientProvider({
+    createIdentity: true,
+    createSpace: true,
+    types,
+    onCreateSpace: async ({ space }: { space: Space }) => {
+      space.db.add(
+        makeRoutine({
+          name,
+          instructions: Instructions.make({ text: 'Summarize the day.' }),
+          trigger: Trigger.make({ spec, enabled }),
+        }),
+      );
+    },
+  });
+
+const meta = {
+  title: 'plugins/plugin-routine/components/RoutineCard',
+  render: DefaultStory,
+  decorators: [withTheme(), withLayout({ layout: 'column' })],
+  parameters: {
+    translations,
+  },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+/** An active scheduled routine: the schedule summary, with the green check marking it switched on. */
+export const Default: Story = {
+  decorators: [withSeededRoutine({ name: 'Daily Digest', spec: Trigger.specTimer('0 9 * * *'), enabled: true })],
+};
+
+/** The same routine switched off: same summary, no check. */
+export const Inactive: Story = {
+  decorators: [withSeededRoutine({ name: 'Daily Digest', spec: Trigger.specTimer('0 9 * * *') })],
+};
+
+/** A non-timer trigger has no parameters worth summarizing, so the kind description stands in. */
+export const QueryTrigger: Story = {
+  decorators: [
+    withSeededRoutine({
+      name: 'Watch tasks',
+      spec: Trigger.specSubscription(Query.select(Filter.type(Text.Text))),
+      enabled: true,
+    }),
+  ],
+};
+
+/** A freshly created (blank-template) routine: the body prompts for a trigger. */
+export const NoTrigger: Story = {
+  decorators: [withSeededRoutine()],
+};

package/src/components/RoutineCard/RoutineCard.tsx

@@ -0,0 +1,60 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import React from 'react';
+
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { type Routine, type Trigger } from '@dxos/compute';
+import { useObject } from '@dxos/echo-react';
+import { Card, Icon, useTranslation } from '@dxos/react-ui';
+
+import { meta } from '#meta';
+
+import { cronToSchedule, describeSchedule } from '../Schedule';
+
+export type RoutineCardProps = AppSurface.ObjectCardProps<Routine.Routine>;
+
+/**
+ * Compact preview of a {@link Routine.Routine}: when it runs. Rendered into the
+ * `AppSurface.CardContent` slot — Card.Root is supplied by the surface host (the project article's
+ * gallery, popovers, related-objects), so this emits Card.Body only. Without it a routine falls back
+ * to the generic form preview, which renders its `spec`/`triggers` internals rather than a summary.
+ */
+export const RoutineCard = ({ subject }: RoutineCardProps) => {
+  const { t } = useTranslation(meta.profile.key);
+  const [routine] = useObject(subject);
+  // MVP enforces at most one trigger; the summary describes it.
+  const [trigger] = useObject(routine.triggers.at(0));
+
+  // Active means the same thing as in the routines list: a trigger exists and is switched on.
+  const active = trigger?.enabled === true;
+
+  return (
+    <Card.Body>
+      <Card.Row>
+        {/* The gutter is reserved either way so the summary stays aligned across cards. */}
+        <Card.Block>{active && <Icon icon='ph--check-circle--regular' classNames='text-green-text' />}</Card.Block>
+        <Card.Text variant='description' classNames='line-clamp-2'>
+          {describeTrigger(trigger?.spec, t)}
+        </Card.Text>
+      </Card.Row>
+    </Card.Body>
+  );
+};
+
+RoutineCard.displayName = 'RoutineCard';
+
+/**
+ * The same sentence the trigger editor shows above the schedule picker. Non-timer kinds have no
+ * parameters worth summarizing, so they reuse the kind description from the trigger-kind picker.
+ */
+const describeTrigger = (spec: Trigger.Spec | undefined, t: (key: string) => string): string => {
+  if (!spec) {
+    return t('add-trigger-first.message');
+  }
+
+  return spec.kind === 'timer'
+    ? describeSchedule(cronToSchedule(spec.cron))
+    : t(`trigger-kind.${spec.kind}.description`);
+};

package/src/components/{MasterDetail → RoutineCard}/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2026 DXOS.org
 //
 
-export * from './MasterDetail';
+export * from './RoutineCard';