@dxos/plugin-automation 0.8.4-main.c85a9c8dae → 0.8.4-main.d9fc60f731

package/src/components/TriggerEditor/TriggerEditor.tsx

@@ -2,12 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Option from 'effect/Option';
+import * as Record from 'effect/Record';
 import React, { useCallback, useMemo } from 'react';
 
+import { Operation, Script, Trigger } from '@dxos/compute';
 import { ComputeGraph } from '@dxos/conductor';
-import { DXN, type Database, Obj, type Query } from '@dxos/echo';
-import { Function, Script, Trigger } from '@dxos/functions';
-import { Filter, Ref, useQuery } from '@dxos/react-client/echo';
+import { Annotation, type Database, Entity, Feed, Filter, Obj, Query, Ref, Scope, Type } from '@dxos/echo';
+import { DXN, EID } from '@dxos/keys';
+import { useQuery } from '@dxos/react-client/echo';
 import { Input } from '@dxos/react-ui';
 import { QueryForm, type QueryFormProps } from '@dxos/react-ui-components';
 import {
@@ -22,6 +25,7 @@ import {
 
 import { FunctionInputEditor } from './FunctionInputEditor';
 import { SpecSelector } from './SpecSelector';
+import { getOperationUri } from './util';
 
 type TriggerFormSchema = ExcludeId<typeof Trigger.Trigger>;
 
@@ -36,22 +40,18 @@ export type TriggerEditorProps = {
   Pick<FormRootProps<TriggerFormSchema>, 'onSave' | 'onCancel'>;
 
 export const TriggerEditor = ({ db, types, tags, readonlySpec, trigger, ...formProps }: TriggerEditorProps) => {
-  const fieldMap = useCustomInputs({
-    db,
-    types,
-    tags,
-    readonlySpec,
-  });
+  const fieldMap = useCustomInputs({ db, types, tags, readonlySpec });
 
   const handleValuesChanged = useCallback(
     (newValues: Partial<TriggerFormSchema>) => {
-      Obj.change(trigger, (t) => {
-        Object.assign(t, newValues);
+      Obj.update(trigger, (trigger) => {
+        Object.assign(trigger, newValues);
       });
     },
     [trigger],
   );
 
+  const triggerSchema = useMemo(() => omitId(Trigger.Trigger), []);
   const defaultValues = useMemo(() => {
     const { id: _, ...values } = trigger;
     return values;
@@ -60,9 +60,9 @@ export const TriggerEditor = ({ db, types, tags, readonlySpec, trigger, ...formP
   return (
     <Form.Root<TriggerFormSchema>
       {...formProps}
-      schema={omitId(Trigger.Trigger)}
-      defaultValues={defaultValues}
       db={db}
+      schema={triggerSchema}
+      defaultValues={defaultValues}
       fieldMap={fieldMap}
       onValuesChanged={handleValuesChanged}
     >
@@ -82,9 +82,14 @@ type UseCustomInputsProps = {
 } & Pick<QueryFormProps, 'types' | 'tags'>;
 
 const useCustomInputs = ({ db, readonlySpec, types, tags }: UseCustomInputsProps): FormFieldMap => {
-  const functions = useQuery(db, Filter.type(Function.Function));
+  const functions = useQuery(
+    db,
+    Query.select(Filter.type(Operation.PersistentOperation)).from(Scope.space(), Scope.registry()),
+  );
+
   const workflows = useQuery(db, Filter.type(ComputeGraph));
   const scripts = useQuery(db, Filter.type(Script.Script));
+  const feeds = useQuery(db, Filter.type(Feed.Feed));
 
   return useMemo(
     (): FormFieldMap => ({
@@ -93,17 +98,17 @@ const useCustomInputs = ({ db, readonlySpec, types, tags }: UseCustomInputsProps
         const getValue = useCallback(() => {
           const formValue = props.getValue();
           if (Ref.isRef(formValue)) {
-            return formValue.dxn.toString() as string;
+            return formValue.uri;
           }
           return undefined;
         }, [props]);
 
         const handleOnValueChange = useCallback(
-          (_type: any, dxnString: string) => {
-            const dxn = DXN.parse(dxnString);
-            if (dxn) {
-              const ref = Ref.fromDXN(dxn);
-              props.onValueChange(props.type, ref);
+          (_type: any, uriString: string) => {
+            // Function references are either an EID (space-resident) or a key DXN (registry).
+            const uri = EID.tryParse(uriString) ?? (DXN.isDXN(uriString) ? uriString : undefined);
+            if (uri) {
+              props.onValueChange(props.type, Ref.fromURI(uri));
             }
           },
           [props.type, props.onValueChange],
@@ -122,6 +127,36 @@ const useCustomInputs = ({ db, readonlySpec, types, tags }: UseCustomInputsProps
       // Spec selector.
       'spec.kind': (props) => <SpecSelector {...props} readonly={readonlySpec} />,
 
+      // Feed selector with parent labels.
+      'spec.feed': (props) => {
+        const getValue = useCallback(() => {
+          const formValue = props.getValue();
+          if (Ref.isRef(formValue)) {
+            return formValue.uri.toString() as string;
+          }
+          return undefined;
+        }, [props]);
+
+        const handleOnValueChange = useCallback(
+          (_type: any, dxnString: string) => {
+            const uri = EID.tryParse(dxnString);
+            if (uri) {
+              props.onValueChange(props.type, Ref.fromURI(uri));
+            }
+          },
+          [props.type, props.onValueChange],
+        );
+
+        return (
+          <SelectField
+            {...props}
+            getValue={getValue as any}
+            onValueChange={handleOnValueChange}
+            options={getFeedOptions(feeds)}
+          />
+        );
+      },
+
       // TODO(wittjosiah): Copied from ViewEditor.
       // Query input editor.
       'spec.query': (props) => {
@@ -141,15 +176,75 @@ const useCustomInputs = ({ db, readonlySpec, types, tags }: UseCustomInputsProps
       // Function input editor.
       input: (props) => <FunctionInputEditor {...props} functions={functions} db={db} />,
     }),
-    [workflows, scripts, functions, readonlySpec],
+    [workflows, scripts, functions, feeds, readonlySpec],
   );
 };
 
+const getObjectIconProps = (object: Entity.Unknown): { icon?: string; iconHue?: string } => {
+  const type = Entity.getType(object);
+  const schema = type ? Type.getSchema(type) : undefined;
+  const annotation = schema ? Option.getOrUndefined(Annotation.IconAnnotation.get(schema)) : undefined;
+  return annotation ? { icon: annotation.icon, iconHue: annotation.hue } : {};
+};
+
 const getWorkflowOptions = (graphs: ComputeGraph[]) => {
-  return graphs.map((graph) => ({ label: `compute-${graph.id}`, value: `dxn:echo:@:${graph.id}` }));
+  return graphs.map((graph) => ({
+    label: `compute-${graph.id}`,
+    value: Obj.getURI(graph),
+    ...getObjectIconProps(graph),
+  }));
 };
 
-const getFunctionOptions = (scripts: Script.Script[], functions: Function.Function[]) => {
-  const getLabel = (fn: Function.Function) => scripts.find((s) => fn.source?.target?.id === s.id)?.name ?? fn.name;
-  return functions.map((fn) => ({ label: getLabel(fn), value: `dxn:echo:@:${fn.id}` }));
+const getFunctionOptions = (scripts: Script.Script[], functions: Operation.PersistentOperation[]) => {
+  const getLabel = (fn: Operation.PersistentOperation) =>
+    scripts.find((s) => fn.source?.target?.id === s.id)?.name ?? fn.name;
+  return functions.map((fn) => {
+    const { icon: schemaIcon, iconHue } = getObjectIconProps(fn);
+    return {
+      label: getLabel(fn),
+      value: getOperationUri(fn),
+      icon: fn.icon ?? schemaIcon,
+      iconHue,
+    };
+  });
+};
+
+const getFeedDisplayName = (feed: Feed.Feed): string =>
+  Entity.getLabel(feed) ?? feed.name ?? Entity.getTypename(feed) ?? 'Feed';
+
+const computeRefRole = (entity: Feed.Feed): string | undefined => {
+  const parent = Obj.getParent(entity);
+  if (!parent) {
+    return undefined;
+  }
+  for (const key of Record.keys(parent)) {
+    if (Ref.isRef(parent[key]) && parent[key].target?.id === entity.id) {
+      return `$.${key}`;
+    }
+  }
+  return undefined;
+};
+
+const getFeedOptions = (feeds: Feed.Feed[]) => {
+  return feeds.map((feed) => {
+    const parent = Obj.getParent(feed);
+    const displayObject = parent ?? feed;
+    const role = computeRefRole(feed);
+
+    if (parent) {
+      return {
+        label: Entity.getLabel(parent) ?? Entity.getTypename(parent) ?? 'Parent',
+        secondaryLabel: role ?? getFeedDisplayName(feed),
+        value: Obj.getURI(feed),
+        ...getObjectIconProps(displayObject),
+      };
+    }
+
+    return {
+      label: getFeedDisplayName(feed),
+      secondaryLabel: role,
+      value: Obj.getURI(feed),
+      ...getObjectIconProps(displayObject),
+    };
+  });
 };

package/src/components/TriggerEditor/util.ts

@@ -0,0 +1,51 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Operation } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
+import { DXN, EID, type URI } from '@dxos/keys';
+
+/**
+ * Reference URI for an operation. Registry operations (no owning database) are referenced by
+ * their versioned key DXN so they resolve via the operation registry; space-resident operations
+ * are referenced by their EID.
+ */
+// TODO(wittjosiah): There should be a generic & consistent way to get the dxn uri for entities if its available.
+export const getOperationUri = (fn: Operation.PersistentOperation): URI.URI => {
+  if (Obj.getDatabase(fn) === undefined) {
+    const key = Operation.getKey(fn);
+    const version = Operation.getVersion(fn);
+    const dxn = key ? DXN.tryMake(version ? `dxn:${key}:${version}` : `dxn:${key}`) : undefined;
+    if (dxn) {
+      return dxn;
+    }
+  }
+
+  return Obj.getURI(fn);
+};
+
+/**
+ * Resolve an operation from a list by its reference URI (an EID for space-resident operations,
+ * or a versioned key DXN for registry operations).
+ */
+export const findOperationByUri = (
+  functions: readonly Operation.PersistentOperation[],
+  uri: URI.URI,
+): Operation.PersistentOperation | undefined => {
+  const eid = EID.tryParse(uri);
+  if (eid) {
+    const entityId = EID.getEntityId(eid);
+    return entityId ? functions.find((fn) => fn.id === entityId) : undefined;
+  }
+
+  if (DXN.isDXN(uri)) {
+    const key = DXN.getName(uri);
+    const version = DXN.getVersion(uri);
+    return functions.find(
+      (fn) => Operation.getKey(fn) === key && (version === undefined || Operation.getVersion(fn) === version),
+    );
+  }
+
+  return undefined;
+};

package/src/containers/AutomationSettings/AutomationSettings.tsx

@@ -4,24 +4,28 @@
 
 import React from 'react';
 
+import { AppSurface } from '@dxos/app-toolkit/ui';
 import { useTranslation } from '@dxos/react-ui';
 import { Settings } from '@dxos/react-ui-form';
 
+import { meta } from '#meta';
+
 import { AutomationPanel, type AutomationPanelProps } from '../../components/AutomationPanel';
-import { meta } from '../../meta';
-import { TriggersSettings } from '../TriggerSettings/TriggerSettings';
+import { TriggersSettings } from '../TriggerSettings';
+
+export type AutomationSettingsProps = AppSurface.SpaceArticleProps<Omit<AutomationPanelProps, 'space'>>;
 
-export const AutomationSettings = (props: AutomationPanelProps) => {
+export const AutomationSettings = (props: AutomationSettingsProps) => {
   const { t } = useTranslation(meta.id);
   return (
-    <Settings.Root>
+    <Settings.Viewport>
       <Settings.Section
-        title={t('automation verbose label', { ns: meta.id })}
-        description={t('automation description', { ns: meta.id })}
+        title={t('automation-verbose.label', { ns: meta.id })}
+        description={t('automation.description', { ns: meta.id })}
       >
         <AutomationPanel {...props} />
-        <TriggersSettings db={props.space.db} />
+        <TriggersSettings space={props.space} />
       </Settings.Section>
-    </Settings.Root>
+    </Settings.Viewport>
   );
 };

package/src/containers/AutomationSettings/index.ts

@@ -2,6 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-import { AutomationSettings } from './AutomationSettings';
-
-export default AutomationSettings;
+export { AutomationSettings as default } from './AutomationSettings';

package/src/containers/FunctionsContainer/FunctionsContainer.tsx

@@ -4,30 +4,30 @@
 
 import React from 'react';
 
-import { type Space } from '@dxos/react-client/echo';
+import { AppSurface } from '@dxos/app-toolkit/ui';
 import { useTranslation } from '@dxos/react-ui';
 import { Settings } from '@dxos/react-ui-form';
 
-import { FunctionsPanel } from '../../components/FunctionsPanel';
-import { FunctionsRegistry } from '../../components/FunctionsRegistry';
-import { meta } from '../../meta';
+import { meta } from '#meta';
 
-export const FunctionsContainer = ({ space }: { space: Space }) => {
+import { FunctionsPanel, FunctionsRegistry } from '../../components';
+
+export const FunctionsContainer = ({ space }: AppSurface.SpaceArticleProps) => {
   const { t } = useTranslation(meta.id);
   return (
-    <Settings.Root>
+    <Settings.Viewport>
       <Settings.Section
-        title={t('functions verbose label', { ns: meta.id })}
-        description={t('functions description', { ns: meta.id })}
+        title={t('functions-verbose.label', { ns: meta.id })}
+        description={t('functions.description', { ns: meta.id })}
       >
         <FunctionsPanel space={space} />
       </Settings.Section>
       <Settings.Section
-        title={t('functions registry verbose label', { ns: meta.id })}
-        description={t('functions registry description', { ns: meta.id })}
+        title={t('functions-registry-verbose.label', { ns: meta.id })}
+        description={t('functions-registry.description', { ns: meta.id })}
       >
         <FunctionsRegistry space={space} />
       </Settings.Section>
-    </Settings.Root>
+    </Settings.Viewport>
   );
 };

package/src/containers/FunctionsContainer/index.ts

@@ -2,6 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-import { FunctionsContainer } from './FunctionsContainer';
-
-export default FunctionsContainer;
+export { FunctionsContainer as default } from './FunctionsContainer';

package/src/containers/TriggerSettings/TriggerSettings.tsx

@@ -4,23 +4,45 @@
 
 import React from 'react';
 
-import { type Database } from '@dxos/echo';
-import { Input, useTranslation } from '@dxos/react-ui';
+import { type ComputeEnvironment } from '@dxos/client-protocol';
+import { useObject } from '@dxos/echo-react';
+import { type Space } from '@dxos/react-client/echo';
+import { DropdownMenu, IconButton, useTranslation } from '@dxos/react-ui';
 import { Settings } from '@dxos/react-ui-form';
 
-import { useTriggerRuntimeControls } from '../../hooks';
-import { meta } from '../../meta';
+import { meta } from '#meta';
 
-export const TriggersSettings = ({ db }: { db: Database.Database }) => {
-  const { state, start, stop } = useTriggerRuntimeControls(db);
-  const isRunning = state?.enabled ?? false;
+export const TriggersSettings = ({ space }: { space: Space }) => {
   const { t } = useTranslation(meta.id);
+  const [properties, changeProperties] = useObject(space.properties);
+  const selected = properties.computeEnvironment ?? 'local';
+
+  const handleUpdate = (option: ComputeEnvironment) => {
+    changeProperties((draft) => {
+      draft.computeEnvironment = option;
+    });
+  };
 
   return (
     <div className='grid grid-cols-1 md:grid-cols-[1fr_min-content]'>
-      <Settings.ItemInput title={t('runtime label')} description={t('runtime description')}>
-        <Input.Switch classNames='justify-self-end' checked={isRunning} onCheckedChange={isRunning ? stop : start} />
-      </Settings.ItemInput>
+      <Settings.Item title={t('runtime.label')} description={t('runtime.description')}>
+        <DropdownMenu.Root>
+          <DropdownMenu.Trigger asChild>
+            <IconButton iconEnd icon='ph--caret-down--regular' size={4} label={t(`runtime.${selected}.label`)} />
+          </DropdownMenu.Trigger>
+          <DropdownMenu.Portal>
+            <DropdownMenu.Content side='bottom'>
+              <DropdownMenu.Viewport>
+                <DropdownMenu.Item onClick={() => handleUpdate('disabled')}>
+                  {t(`runtime.disabled.label`)}
+                </DropdownMenu.Item>
+                <DropdownMenu.Item onClick={() => handleUpdate('local')}>{t(`runtime.local.label`)}</DropdownMenu.Item>
+                <DropdownMenu.Item onClick={() => handleUpdate('edge')}>{t(`runtime.edge.label`)}</DropdownMenu.Item>
+              </DropdownMenu.Viewport>
+            </DropdownMenu.Content>
+          </DropdownMenu.Portal>
+        </DropdownMenu.Root>
+      </Settings.Item>
     </div>
   );
 };

package/src/containers/TriggerSettings/index.ts

@@ -2,6 +2,5 @@
 // Copyright 2025 DXOS.org
 //
 
-import { TriggersSettings } from './TriggerSettings';
-
-export default TriggersSettings;
+export { TriggersSettings } from './TriggerSettings';
+export { TriggersSettings as default } from './TriggerSettings';

package/src/hooks/index.ts

@@ -2,5 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './useComputeRuntimeCallback';
+// TODO(wittjosiah): Factor out.
+export * from './useEdgeTriggersDispatcherStatus';
 export * from './useTriggerRuntimeControls';

package/src/hooks/useEdgeTriggersDispatcherStatus.ts

@@ -0,0 +1,78 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useEffect, useMemo, useState } from 'react';
+
+import { Context } from '@dxos/context';
+import { type TriggersDispatcherStatus } from '@dxos/edge-client';
+import { FunctionsServiceClient } from '@dxos/functions-runtime/edge';
+import { type SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { useClient } from '@dxos/react-client';
+import { useIdentity } from '@dxos/react-client/halo';
+
+const POLL_INTERVAL_MS = 5_000;
+
+export type EdgeTriggersDispatcherStatusState = {
+  status: TriggersDispatcherStatus | undefined;
+  error: boolean;
+  loading: boolean;
+};
+
+/**
+ * Polls Edge TriggersDispatcher status for a space while enabled.
+ * Uses {@link FunctionsServiceClient} so requests are authenticated like other edge trigger calls.
+ */
+export const useEdgeTriggersDispatcherStatus = (
+  spaceId: SpaceId | undefined,
+  enabled: boolean,
+): EdgeTriggersDispatcherStatusState => {
+  const client = useClient();
+  const identity = useIdentity();
+  const functionsServiceClient = useMemo(() => FunctionsServiceClient.fromClient(client), [client]);
+  const [status, setStatus] = useState<TriggersDispatcherStatus | undefined>();
+  const [error, setError] = useState(false);
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    if (!enabled || !spaceId || !identity) {
+      setStatus(undefined);
+      setError(false);
+      setLoading(false);
+      return;
+    }
+
+    let cancelled = false;
+
+    const fetchStatus = async () => {
+      try {
+        setLoading(true);
+        const result = await functionsServiceClient.getTriggersDispatcherStatus(Context.default(), spaceId);
+        if (!cancelled) {
+          setStatus(result);
+          setError(false);
+        }
+      } catch (err) {
+        log.catch(err);
+        if (!cancelled) {
+          setError(true);
+        }
+      } finally {
+        if (!cancelled) {
+          setLoading(false);
+        }
+      }
+    };
+
+    void fetchStatus();
+    const interval = setInterval(() => void fetchStatus(), POLL_INTERVAL_MS);
+
+    return () => {
+      cancelled = true;
+      clearInterval(interval);
+    };
+  }, [enabled, functionsServiceClient, identity, spaceId]);
+
+  return { status, error, loading };
+};

package/src/hooks/useTriggerRuntimeControls.ts

@@ -7,13 +7,12 @@ import type * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import { useEffect, useState } from 'react';
 
-import { type Database, Filter } from '@dxos/echo';
-import { Trigger } from '@dxos/functions';
+import { useSpaceCallback } from '@dxos/app-framework/ui';
+import { Trigger } from '@dxos/compute';
+import { type Database, Filter, Query } from '@dxos/echo';
 import { TriggerDispatcher, type TriggerDispatcherState } from '@dxos/functions-runtime';
 import { useQuery } from '@dxos/react-client/echo';
 
-import { useComputeRuntimeCallback } from './useComputeRuntimeCallback';
-
 interface TriggerRuntimeControls {
   triggers: Trigger.Trigger[];
 
@@ -24,12 +23,16 @@ interface TriggerRuntimeControls {
 }
 
 export const useTriggerRuntimeControls = (db: Database.Database | undefined): TriggerRuntimeControls => {
-  const triggers = useQuery(db, Filter.type(Trigger.Trigger));
+  const triggers = useQuery(
+    db,
+    Query.select(Filter.type(Trigger.Trigger)).debugLabel('plugin-automation.useTriggerRuntimeControls'),
+  );
 
   const [dispatcher, setDispatcher] = useState<Context.Tag.Service<TriggerDispatcher> | undefined>(undefined);
 
-  const init = useComputeRuntimeCallback(
+  const init = useSpaceCallback(
     db?.spaceId,
+    [TriggerDispatcher],
     Effect.fnUntraced(function* () {
       const dispatcher = yield* TriggerDispatcher;
       setDispatcher(dispatcher);
@@ -42,16 +45,18 @@ export const useTriggerRuntimeControls = (db: Database.Database | undefined): Tr
 
   const state = useAtomValue(dispatcher?.state ?? Atom.make(undefined));
 
-  const start = useComputeRuntimeCallback(
+  const start = useSpaceCallback(
     db?.spaceId,
+    [TriggerDispatcher],
     Effect.fnUntraced(function* () {
       const dispatcher = yield* TriggerDispatcher;
       yield* dispatcher.start();
     }),
   );
 
-  const stop = useComputeRuntimeCallback(
+  const stop = useSpaceCallback(
     db?.spaceId,
+    [TriggerDispatcher],
     Effect.fnUntraced(function* () {
       const dispatcher = yield* TriggerDispatcher;
       yield* dispatcher.stop();

package/src/index.ts

@@ -2,9 +2,5 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './components';
 export * from './meta';
-export * from './hooks';
 export * from './types';
-
-export * from './AutomationPlugin';

package/src/meta.ts

@@ -2,16 +2,36 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Plugin } from '@dxos/app-framework';
+import { Plugin } from '@dxos/app-framework';
+import { DXN } from '@dxos/keys';
 import { trim } from '@dxos/util';
 
-export const meta: Plugin.Meta = {
-  id: 'dxos.org/plugin/automation',
+export const meta = Plugin.makeMeta({
+  key: DXN.make('org.dxos.plugin.automation'),
   name: 'Automation',
+  author: 'DXOS',
   description: trim`
-    Workflow automation engine that triggers custom actions based on object events and conditions.
-    Create automated pipelines that respond to changes and streamline repetitive tasks.
+    Event-driven workflow automation engine for DXOS Composer.
+    Triggers connect ECHO objects, timer schedules, incoming feeds (email, webhook), and data
+    subscriptions to persistent compute functions — enabling automated pipelines that react to
+    changes in real time without manual intervention.
+
+    Each trigger references a PersistentOperation (a compiled function derived from a Script or
+    a visual ComputeGraph workflow) and carries optional structured input forwarded at invocation.
+    A per-space TriggerDispatcher manages execution: running locally in the browser when
+    computeEnvironment is "local", or delegating to the DXOS edge for server-side reliability.
+
+    The AutomationPanel settings surface lets users create, configure, enable, disable, and
+    force-run triggers from within any space. The TriggerEditor form supports all spec kinds —
+    timer (cron), feed, subscription, email, and webhook — with a query builder for
+    subscription-type triggers and a structured input editor for passing data to functions.
+
+    Operation handlers and blueprints contributed by any plugin in the application are
+    automatically merged and made available to every space's OperationRegistry, so new
+    capabilities registered by other plugins become instantly invocable from automation triggers.
   `,
-  icon: 'ph--robot--regular',
+  icon: 'ph--atom--regular',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-automation',
-};
+  spec: 'PLUGIN.mdl',
+  tags: ['system'],
+});