@dxos/plugin-assistant 0.8.4-main.fcfe5033a5 → 0.8.4-staging.60fe92afc8

package/src/operations/update-chat-name.ts

@@ -7,25 +7,20 @@ import * as Prompt from '@effect/ai/Prompt';
 import * as Effect from 'effect/Effect';
 
 import { AiPreprocessor, AiService } from '@dxos/ai';
+import { Operation } from '@dxos/compute';
 import { Database, Feed, Filter, Obj } from '@dxos/echo';
 import { log } from '@dxos/log';
-import { Operation } from '@dxos/operation';
 import { Message } from '@dxos/types';
 import { trim } from '@dxos/util';
 
-import { UpdateChatName } from './definitions';
+import { AssistantOperation } from '#types';
 
-const handler: Operation.WithHandler<typeof UpdateChatName> = UpdateChatName.pipe(
+const handler: Operation.WithHandler<typeof AssistantOperation.UpdateChatName> = AssistantOperation.UpdateChatName.pipe(
   Operation.withHandler(
     Effect.fnUntraced(
-      function* ({ chat }) {
+      function* ({ chat, prompt: initialPrompt }) {
         log.info('updating chat name', { chat });
 
-        const feed = yield* Database.load(chat.feed);
-        const history = yield* Feed.runQuery(feed, Filter.type(Message.Message));
-
-        log.info('history', { history: history.length });
-
         const system = trim`
           It is extremely important that you respond only with the title and nothing else.
           Do not use markdown or other formatting.
@@ -35,25 +30,34 @@ const handler: Operation.WithHandler<typeof UpdateChatName> = UpdateChatName.pip
           Fishing Trip
           </example_reply>
         `;
-        const prompt = 'Suggest a name for this chat';
 
-        const historyPrompt = yield* AiPreprocessor.preprocessPrompt(history, {
-          system,
-          cacheControl: 'ephemeral',
-        });
-
-        const response = yield* LanguageModel.generateText({
-          prompt: Prompt.merge(historyPrompt, prompt),
-        });
+        let namePrompt: Prompt.Prompt;
+        if (initialPrompt) {
+          // Use the provided prompt text directly; the feed may not have messages yet.
+          namePrompt = Prompt.setSystem(
+            Prompt.make(`User's first message: "${initialPrompt}"\n\nSuggest a name for this chat.`),
+            system,
+          );
+        } else {
+          const feed = yield* Database.load(chat.feed);
+          const history = yield* Feed.runQuery(feed, Filter.type(Message.Message));
+          log.info('history', { history: history.length });
+          const historyPrompt = yield* AiPreprocessor.preprocessPrompt(history, {
+            system,
+            cacheControl: 'ephemeral',
+          });
+          namePrompt = Prompt.merge(historyPrompt, 'Suggest a name for this chat');
+        }
 
+        const response = yield* LanguageModel.generateText({ prompt: namePrompt });
         const newName = response.text.replaceAll(/[^a-zA-Z0-9\s]/g, '').trim();
 
-        Obj.change(chat, (chat) => {
+        Obj.update(chat, (chat) => {
           chat.name = newName;
         });
         log.info('chat name updated', { chat, newName: chat.name });
       },
-      Effect.provide(AiService.model('@anthropic/claude-haiku-4-5')),
+      Effect.provide(AiService.model('ai.claude.model.claude-haiku-4-5')),
     ),
   ),
 );

package/src/paths.ts

@@ -0,0 +1,10 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { createTypeSectionPaths } from '@dxos/app-toolkit';
+import { Chat } from '@dxos/assistant-toolkit';
+
+const { getSectionPath: getChatsPath, getObjectPath: getChatPath } = createTypeSectionPaths(Chat.Chat);
+
+export { getChatsPath, getChatPath };

package/src/plugin.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Plugin } from '@dxos/app-framework';
+
+import { meta } from './meta';
+
+export const AssistantPlugin = Plugin.lazy(meta, () => import('#plugin'));
+
+export { AssistantOperationHandlerSet } from './operations';

package/src/processor/presets.ts

@@ -19,50 +19,54 @@ export type AiServicePreset = {
 };
 
 const createModelLabel = (model: ModelName) => {
-  const parts = model.split('/');
+  const parts = model.split('.');
   return parts[parts.length - 1];
 };
 
 // TODO(burdon): Users should be able to create and edit presets.
 export const AiServicePresets: AiServicePreset[] = [
+  // Sonnet is first so it is the default selection.
   {
     provider: 'dxos-remote' as const,
-    model: '@anthropic/claude-opus-4-6' as const,
+    model: 'ai.claude.model.claude-sonnet-4-6' as const,
+    label: 'Claude Sonnet',
   },
   {
     provider: 'dxos-remote' as const,
-    model: '@anthropic/claude-sonnet-4-5' as const,
+    model: 'ai.claude.model.claude-opus-4-8' as const,
+    label: 'Claude Opus',
   },
   {
     provider: 'dxos-remote' as const,
-    model: '@anthropic/claude-3-5-haiku-20241022' as const,
+    model: 'ai.claude.model.claude-haiku-4-5' as const,
+    label: 'Claude Haiku',
   },
   {
     provider: 'ollama' as const,
-    model: 'gpt-oss:20b' as const,
+    model: 'ai.ollama.model.gpt-oss:20b' as const,
   },
   {
     provider: 'ollama' as const,
-    model: 'gemma4:latest' as const,
+    model: 'ai.ollama.model.gemma4:latest' as const,
   },
   {
     provider: 'lm-studio' as const,
-    model: '@google/gemma-3-27b' as const,
+    model: 'ai.google.model.gemma-3-27b' as const,
   },
   {
     provider: 'lm-studio' as const,
-    model: '@meta/llama-3.2-3b-instruct' as const,
+    model: 'ai.meta.model.llama-3.2-3b-instruct' as const,
   },
   {
-    model: 'deepseek-r1:latest' as const,
+    model: 'ai.ollama.model.deepseek-r1:latest' as const,
     provider: 'dxos-local' as const,
   },
 ].map(
-  ({ model, provider }, i) =>
+  ({ model, provider, label }, i) =>
     ({
       id: `preset-${i}`,
       provider,
       model,
-      label: createModelLabel(model),
+      label: label ?? createModelLabel(model),
     }) satisfies AiServicePreset,
 );

package/src/processor/{processor.test.ts → processor.node.test.ts}

@@ -4,14 +4,16 @@
 
 import { describe, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
 import * as ManagedRuntime from 'effect/ManagedRuntime';
 
+import { Capabilities } from '@dxos/app-framework';
 import { AiSession } from '@dxos/assistant';
 import { Chat } from '@dxos/assistant-toolkit';
-import { AssistantTestLayer } from '@dxos/assistant/testing';
 import { Database, Feed } from '@dxos/echo';
-import { acquireReleaseResource } from '@dxos/effect';
+import { EffectEx } from '@dxos/effect';
 import { TestHelpers } from '@dxos/effect/testing';
+import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 
 import { AiChatProcessor } from './processor';
 
@@ -25,11 +27,9 @@ describe('Chat processor', () => {
         const feed = Feed.make();
         yield* Database.add(feed);
         const runtime = yield* Effect.runtime<Feed.FeedService>();
-        const session = yield* acquireReleaseResource(() => new AiSession({ feed, runtime }));
-        const managedRuntime = ManagedRuntime.make(
-          Effect.runSync(Effect.map(Effect.context<never>(), () => undefined as any)) as any,
-        );
-        const processor = new AiChatProcessor(session, managedRuntime as any, feed);
+        const session = yield* EffectEx.acquireReleaseResource(() => new AiSession.Session({ feed, runtime }));
+        const managedRuntime = ManagedRuntime.make(Layer.empty) as unknown as Capabilities.ProcessManagerRuntime;
+        const processor = new AiChatProcessor(session, managedRuntime, feed, Layer.empty as any);
         expect(processor).toBeDefined();
         expect(processor.active).toBeDefined();
       },

package/src/processor/processor.ts

@@ -2,73 +2,109 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Atom, Registry } from '@effect-atom/atom-react';
+import { Atom, Registry as AtomRegistry } from '@effect-atom/atom-react';
+import * as AiError from '@effect/ai/AiError';
+import * as Cause from 'effect/Cause';
 import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
 import * as Fiber from 'effect/Fiber';
+import * as Layer from 'effect/Layer';
 import * as Option from 'effect/Option';
 import * as Stream from 'effect/Stream';
 
-import { type AiService, DEFAULT_EDGE_MODEL, type ModelName, type ModelRegistry } from '@dxos/ai';
+import { type AiService, DEFAULT_EDGE_MODEL, type ModelName, type ModelRegistry, type OpaqueToolkit } from '@dxos/ai';
+import { Capabilities } from '@dxos/app-framework';
 import {
-  AiContextService,
-  type AiSession,
+  AiContext,
+  AiSession,
   createSystemPrompt,
   formatSystemPrompt,
-  AgentService,
+  McpServerError,
   PartialBlock,
   ToolExecutionServices,
 } from '@dxos/assistant';
 import { type Chat } from '@dxos/assistant-toolkit';
-import { type Blueprint } from '@dxos/blueprints';
-import { type Database, Feed, Obj, Ref } from '@dxos/echo';
-import { runAndForwardErrors, unwrapExit } from '@dxos/effect';
-import { Trace, type CredentialsService, type QueueService } from '@dxos/functions';
+import { type Credential, Operation, type ServiceNotAvailableError, Trace } from '@dxos/compute';
+import { type Database, Feed, Obj, Ref, type Registry } from '@dxos/echo';
+import { EffectEx } from '@dxos/effect';
+import { AgentService } from '@dxos/functions-runtime';
 import { log } from '@dxos/log';
-import { Operation } from '@dxos/operation';
-import type { AutomationCapabilities } from '@dxos/plugin-automation/types';
 import { Message } from '@dxos/types';
 
-import { UpdateChatName } from '../operations/definitions';
+import { AssistantOperation } from '#types';
 
 /**
  * @deprecated Services type for the old direct-conversation processor path.
  * Retained for backward compatibility with CLI and update-name.
  */
 export type AiChatServices =
-  | CredentialsService
+  | Credential.CredentialsService
   | Database.Service
-  | QueueService
   | AiService.AiService
   | Trace.TraceService;
 
+/**
+ * Space-scoped services materialised by the layer passed into
+ * {@link AiChatProcessor}. Mirrors the tag list that
+ * {@link useChatProcessor} passes to {@link ServiceResolver.provide}.
+ */
+export type SpaceServices =
+  | Database.Service
+  | Feed.FeedService
+  | Credential.CredentialsService
+  | AiService.AiService
+  | AgentService.AgentService
+  | Registry.Service
+  | OpaqueToolkit.OpaqueToolkitProvider;
+
 export type AiChatProcessorOptions = {
   model?: ModelName;
   modelRegistry?: ModelRegistry;
-  blueprintRegistry?: Blueprint.Registry;
-  observableRegistry?: Registry.Registry;
+  registry?: Registry.Registry;
+  observableRegistry?: AtomRegistry.Registry;
   /**
    * For tracing.
    */
   chat?: Ref.Ref<Chat.Chat>;
   system?: string;
-  /**
-   * Probability of automatically updating chat name after each request.
-   * Chat name is always updated if it has no name.
-   * @default 0.1 (10%)
-   */
-  autoUpdateNameChance?: number;
 };
 
 const defaultOptions: Partial<AiChatProcessorOptions> = {
   model: DEFAULT_EDGE_MODEL,
-  autoUpdateNameChance: 0.1,
 };
 
-export type AiRequestOptions = {};
+export type ProcessorRequestOptions = {};
 
-export type AiRequest = {
+export type ProcessorRequest = {
   message: string;
-  options?: AiRequestOptions;
+  options?: ProcessorRequestOptions;
+};
+
+/**
+ * Maps a failure from the agent fiber to an error suitable for display.
+ * {@link AiError}s originate from the AI service and are actionable by the user
+ * (e.g., "model 'x' not found", "Connection refused"), so their detail is propagated.
+ * Any other failure is treated as an internal/unexpected error and reported generically
+ * to avoid leaking implementation detail.
+ */
+const parseError = (err: unknown): Error => {
+  let message: string | undefined;
+  if (AiError.isAiError(err)) {
+    message = err.description?.trim() || err.message;
+  } else if (typeof err === 'string') {
+    // TODO(burdon): This is brittle.
+    // UnknownError: ChatCompletionsClient.streamText: model 'gemma3:27b' not found
+    const [, model] = err.match(/model\s+'([^']+)'\s+not\s+found/i) || [];
+    if (model) {
+      message = `The model is not available: ${model}`;
+    }
+  }
+
+  if (!message) {
+    message = 'An unexpected error occurred.';
+  }
+
+  return new Error(message, { cause: err });
 };
 
 /**
@@ -76,7 +112,7 @@ export type AiRequest = {
  * Uses AgentService to spawn a process-backed agent and subscribes to ephemeral trace events for streaming.
  */
 export class AiChatProcessor {
-  readonly #registry: Registry.Registry;
+  readonly #registry: AtomRegistry.Registry;
 
   /** Pending messages (finalized, non-streaming). */
   readonly #pending = Atom.make<Message.Message[]>([]);
@@ -91,7 +127,7 @@ export class AiChatProcessor {
   #requestFiber: Fiber.RuntimeFiber<void, unknown> | undefined;
 
   /** Last request (for retries). */
-  #lastRequest: AiRequest | undefined;
+  #lastRequest: ProcessorRequest | undefined;
 
   /** Streaming state. */
   public readonly streaming = Atom.make<boolean>((get) => get(this.#streaming).length > 0);
@@ -105,13 +141,29 @@ export class AiChatProcessor {
   /** Last error. */
   public readonly error = Atom.make<Option.Option<Error>>(Option.none());
 
+  /**
+   * MCP server connection errors observed during the most recent request.
+   * Misconfigured/unreachable servers are dropped from the toolkit so the chat
+   * keeps working; the entries here let the UI display which servers failed.
+   */
+  public readonly mcpErrors = Atom.make<readonly Trace.PayloadType<typeof McpServerError>[]>([]);
+
   constructor(
-    private readonly _conversation: AiSession,
-    private readonly _runtime: AutomationCapabilities.ComputeRuntime,
+    private readonly _conversation: AiSession.Session,
+    private readonly _runtime: Capabilities.ProcessManagerRuntime,
     private readonly _feed: Feed.Feed,
+    /**
+     * Pre-built layer that materialises {@link SpaceServices}. Built via
+     * {@link ServiceResolver.provide} with the {@link ServiceResolver} already
+     * supplied (hence `RIn = never`); the {@link ServiceNotAvailableError}
+     * error channel surfaces when a tag is not available for the space.
+     * Provided to every effect run by the processor so the underlying
+     * {@link ProcessManagerRuntime} has access to space-affinity services.
+     */
+    private readonly _spaceLayer: Layer.Layer<SpaceServices, ServiceNotAvailableError, never>,
     private readonly _options: AiChatProcessorOptions = defaultOptions,
   ) {
-    this.#registry = this._options.observableRegistry ?? Registry.make();
+    this.#registry = this._options.observableRegistry ?? AtomRegistry.make();
     if (this._options.model && !this._options.system) {
       const capabilities = this._options.modelRegistry?.getCapabilities(this._options.model) ?? {};
       this._options.system = createSystemPrompt(capabilities);
@@ -126,8 +178,8 @@ export class AiChatProcessor {
     return this._conversation;
   }
 
-  get blueprintRegistry() {
-    return this._options.blueprintRegistry;
+  get registry() {
+    return this._options.registry;
   }
 
   get system(): string {
@@ -135,7 +187,9 @@ export class AiChatProcessor {
   }
 
   async getTools(): Promise<Record<string, any>> {
-    return this._runtime.runPromise(Effect.provide(this._conversation.getTools(), ToolExecutionServices));
+    return this._runtime.runPromise(
+      Effect.provide(this._conversation.getTools(), ToolExecutionServices).pipe(Effect.provide(this._spaceLayer)),
+    );
   }
 
   async getSystemPrompt(): Promise<string> {
@@ -144,14 +198,18 @@ export class AiChatProcessor {
         const blueprints = this.context.getBlueprints();
         const objects = this.context.getObjects();
         return yield* formatSystemPrompt({ system: this._options.system, blueprints, objects });
-      }).pipe(Effect.provideService(AiContextService, { binder: this.context }), Effect.orDie),
+      }).pipe(
+        Effect.provideService(AiContext.Service, { binder: this.context }),
+        Effect.provide(this._spaceLayer),
+        Effect.orDie,
+      ),
     );
   }
 
   /**
    * Initiates a new request via AgentService.
    */
-  async request(requestProp: AiRequest): Promise<void> {
+  async request(requestProp: ProcessorRequest): Promise<void> {
     if (this.#requestFiber) {
       await this.cancel();
     }
@@ -159,11 +217,12 @@ export class AiChatProcessor {
     try {
       this.#lastRequest = requestProp;
       this.#registry.set(this.error, Option.none());
+      this.#registry.set(this.mcpErrors, []);
       this.#registry.set(this.active, true);
 
       const effect = Effect.gen(this, function* () {
         // NOTE: Gets or creates a session for the feed.
-        log.info('init agent session', { feed: Obj.getDXN(this._feed).toString(), model: this._options.model });
+        log.info('init agent session', { feed: Obj.getURI(this._feed), model: this._options.model });
         const session = yield* AgentService.getSession(this._feed, { model: this._options.model });
         const ephemeralStream = session.subscribeEphemeral();
         yield* ephemeralStream.pipe(
@@ -172,6 +231,8 @@ export class AiChatProcessor {
               for (const event of message.events) {
                 if (Trace.isOfType(PartialBlock, event)) {
                   this.#handleEphemeralMessage(event.data);
+                } else if (Trace.isOfType(McpServerError, event)) {
+                  this.#handleMcpError(event.data);
                 }
               }
             }),
@@ -182,31 +243,40 @@ export class AiChatProcessor {
         log('chat processor submitting prompt', { length: requestProp.message.length });
         yield* session.submitPrompt(requestProp.message);
         log('chat processor submitPrompt returned, waiting for agent', {});
+
+        // On the first message (no name yet), schedule rename immediately so it
+        // runs concurrently with the AI response rather than waiting for completion.
+        if (!this._options.chat?.target?.name) {
+          yield* this.#updateChatName(requestProp.message);
+        }
+
         yield* session.waitForCompletion();
         log.info('session complete');
 
         this.#flushStreaming();
-
-        yield* this.#maybeUpdateChatName();
       });
 
-      this.#requestFiber = this._runtime.runFork(effect);
+      this.#requestFiber = this._runtime.runFork(effect.pipe(Effect.provide(this._spaceLayer)));
 
-      try {
-        await this._runtime.runPromise(Fiber.join(this.#requestFiber));
-      } catch (err: any) {
-        if (err._tag === 'InterruptedException' || err.message?.includes('interrupted')) {
+      // Inspect the fiber's exit so the underlying failure (e.g. "model 'x' not found") is
+      // preserved as a clean Error rather than an opaque FiberFailure.
+      const exit = await this._runtime.runPromise(Fiber.await(this.#requestFiber));
+      if (Exit.isFailure(exit)) {
+        if (Cause.isInterruptedOnly(exit.cause)) {
           return;
         }
-        throw err;
+
+        throw EffectEx.causeToError(exit.cause);
       }
 
       this.#registry.set(this.error, Option.none());
       this.#lastRequest = undefined;
       this.#requestFiber = undefined;
     } catch (err) {
+      // `EffectEx.causeToError` above unwraps the fiber failure into the underlying error (e.g. an AiError
+      // carrying "model 'x' not found"); `parseError` decides what to surface to the user.
       log.error('request failed', { error: err });
-      this.#registry.set(this.error, Option.some(new Error('AI service error', { cause: err })));
+      this.#registry.set(this.error, Option.some(parseError(err)));
     } finally {
       log.info('setting active to false');
       this.#registry.set(this.active, false);
@@ -218,12 +288,15 @@ export class AiChatProcessor {
    * Cancels the current request.
    */
   async cancel(): Promise<void> {
-    await runAndForwardErrors(
+    await EffectEx.runAndForwardErrors(
       Effect.gen(this, function* () {
+        log.info('cancelling request', { fiber: this.#requestFiber });
         if (this.#requestFiber) {
           yield* Fiber.interrupt(this.#requestFiber);
         }
-      }),
+        const session = yield* AgentService.getSession(this._feed);
+        yield* session.terminate();
+      }).pipe(Effect.provide(this._spaceLayer)),
     );
 
     this.#requestFiber = undefined;
@@ -239,11 +312,28 @@ export class AiChatProcessor {
     }
   }
 
+  /**
+   * Clears the recorded MCP server errors (e.g. after the user dismisses the warning banner).
+   */
+  dismissMcpErrors(): void {
+    this.#registry.set(this.mcpErrors, []);
+  }
+
   /**
    * Update the current chat's name.
    */
   async updateName(chat: Chat.Chat): Promise<void> {
-    unwrapExit(await this._runtime.runPromiseExit(Operation.invoke(UpdateChatName, { chat })));
+    const spaceId = Obj.getDatabase(chat)?.spaceId;
+    if (!spaceId) {
+      return;
+    }
+    EffectEx.unwrapExit(
+      await this._runtime.runPromiseExit(
+        Operation.invoke(AssistantOperation.UpdateChatName, { chat }, { spaceId }).pipe(
+          Effect.provide(this._spaceLayer),
+        ),
+      ),
+    );
   }
 
   /**
@@ -286,6 +376,20 @@ export class AiChatProcessor {
     }
   }
 
+  /**
+   * Records a per-server MCP failure, deduped by url+protocol so repeat misconfigurations
+   * across turns do not spam the UI.
+   */
+  #handleMcpError(event: Trace.PayloadType<typeof McpServerError>) {
+    log.warn('MCP server error', event);
+    this.#registry.update(this.mcpErrors, (errors) => {
+      if (errors.some((existing) => existing.url === event.url && existing.protocol === event.protocol)) {
+        return errors;
+      }
+      return [...errors, event];
+    });
+  }
+
   /**
    * Move remaining streaming messages to pending (called when agent completes).
    */
@@ -299,23 +403,21 @@ export class AiChatProcessor {
   }
 
   /**
-   * Conditionally schedule chat name update in detached fork mode.
-   * Updates if chat has no name OR based on random chance (default 10%).
+   * Schedule a chat name update as a detached (fire-and-forget) operation.
+   * Called automatically on the first message; can also be invoked manually via the toolbar.
    */
-  #maybeUpdateChatName(): Effect.Effect<void, never, Operation.Service> {
+  #updateChatName(prompt?: string): Effect.Effect<void, never, Operation.Service> {
     const chat = this._options.chat?.target;
     if (!chat) {
       return Effect.void;
     }
 
-    const chance = this._options.autoUpdateNameChance ?? defaultOptions.autoUpdateNameChance ?? 0.1;
-    const shouldUpdate = !chat.name || Math.random() < chance;
-    if (!shouldUpdate) {
+    const spaceId = Obj.getDatabase(chat)?.spaceId;
+    if (!spaceId) {
       return Effect.void;
     }
 
-    // TODO(dmaretskyi): Operation.schedule didn't work.
-    log.info('scheduling chat name update', { hasName: !!chat.name, chance });
-    return Operation.schedule(UpdateChatName, { chat });
+    log.info('scheduling chat name update');
+    return Operation.schedule(AssistantOperation.UpdateChatName, { chat, prompt }, { spaceId });
   }
 }

package/src/templates/automation-templates.test.ts

@@ -0,0 +1,66 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { describe, test } from 'vitest';
+
+import { Operation, Routine, Trace, Trigger } from '@dxos/compute';
+import { Database, Filter, Obj, Query } from '@dxos/echo';
+import { TestDatabaseLayer } from '@dxos/echo-client/testing';
+import { EffectEx } from '@dxos/effect';
+import { Automation } from '@dxos/plugin-automation';
+
+import { dailyDigest } from './daily-digest';
+import { researchBrief } from './research-brief';
+
+const dbLayer = TestDatabaseLayer({
+  types: [Automation.Automation, Routine.Routine, Trigger.Trigger, Operation.PersistentOperation],
+});
+
+const TestLayer = Layer.mergeAll(dbLayer, Trace.writerLayerNoop);
+
+const templates = [
+  { template: researchBrief, blueprintCount: 4 },
+  { template: dailyDigest, blueprintCount: 3 },
+];
+
+describe('scheduled automation templates', () => {
+  test('apply globally (no subject required)', ({ expect }) => {
+    // Like Blank, these are offered in the global create dialog — no `appliesTo` gate.
+    expect(researchBrief.appliesTo).toBeUndefined();
+    expect(dailyDigest.appliesTo).toBeUndefined();
+  });
+
+  for (const { template, blueprintCount } of templates) {
+    test(`${template.label} scaffolds a Routine, a disabled timer Trigger, and an Automation`, async ({ expect }) => {
+      await Effect.gen(function* () {
+        const automation = yield* template.scaffold({});
+        yield* Database.add(automation);
+        yield* Database.flush();
+
+        expect(automation.triggers).toHaveLength(1);
+        expect(automation.runnable).toBeDefined();
+
+        const routines = yield* Database.query(Filter.type(Routine.Routine)).run;
+        expect(routines).toHaveLength(1);
+        expect(routines[0]?.blueprints).toHaveLength(blueprintCount);
+
+        const triggers = yield* Database.query(Query.select(Filter.type(Trigger.Trigger))).run;
+        expect(triggers).toHaveLength(1);
+        const trigger = triggers[0];
+        expect(trigger?.enabled).toBe(false);
+        expect(trigger?.spec?.kind).toBe('timer');
+        expect(trigger?.input?.prompt).toBeDefined();
+        // The trigger is owned by the automation (cascade-deletes with it); the routine stays independent.
+        expect(trigger && Obj.getParent(trigger)?.id).toBe(automation.id);
+        expect(routines[0] && Obj.getParent(routines[0])).toBeUndefined();
+
+        const operations = yield* Database.query(Filter.type(Operation.PersistentOperation)).run;
+        expect(operations).toHaveLength(1);
+        expect(automation.runnable?.uri).toBe(trigger?.function?.uri);
+      }).pipe(Effect.provide(TestLayer), EffectEx.runAndForwardErrors);
+    });
+  }
+});