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

package/src/types/Agent.ts

@@ -5,12 +5,11 @@
 // @import-as-namespace
 
 import * as Effect from 'effect/Effect';
-import * as Function from 'effect/Function';
 import * as Schema from 'effect/Schema';
 
-import { AiContext } from '@dxos/assistant';
-import { type Blueprint } from '@dxos/compute';
-import { DXN, Annotation, Database, Feed, Format, Obj, Ref, Relation, Type } from '@dxos/echo';
+import { AiContext, Harness } from '@dxos/assistant';
+import { type Skill } from '@dxos/compute';
+import { Annotation, Database, DXN, Feed, Filter, Format, Obj, Ref, Relation, Type } from '@dxos/echo';
 import { FormInputAnnotation } from '@dxos/echo/Annotation';
 import { type EntityNotFoundError } from '@dxos/echo/Err';
 import { EffectEx } from '@dxos/effect';
@@ -18,121 +17,113 @@ import { invariant } from '@dxos/invariant';
 import { EID, type EntityId } from '@dxos/keys';
 import { Text } from '@dxos/schema';
 
+import { HarnessContextError } from '../errors';
 import * as Chat from './Chat';
-import * as Plan from './Plan';
 
 /**
  * Agent schema definition.
  */
-export const Agent = Schema.Struct({
-  name: Schema.optional(Schema.String),
+export class Agent extends Type.makeObject<Agent>(DXN.make('org.dxos.type.agent', '0.1.0'))(
+  Schema.Struct({
+    name: Schema.optional(Schema.String),
 
-  /**
-   * When false, agent triggers are disabled after sync-triggers runs.
-   */
-  enabled: Schema.optional(Schema.Boolean).annotations({
-    title: 'Enabled',
-    description: 'Master switch for agent automation; propagated to all triggers on sync.',
-  }),
-
-  /**
-   * Instructions for the agent.
-   */
-  instructions: Ref.Ref(Text.Text).pipe(
-    Format.FormatAnnotation.set(Format.TypeFormat.Markdown),
-    Schema.annotations({ title: 'Instructions' }),
-  ),
+    /**
+     * When false, agent triggers are disabled after sync-triggers runs.
+     */
+    enabled: Schema.optional(Schema.Boolean).annotations({
+      title: 'Enabled',
+      description: 'Master switch for agent automation; propagated to all triggers on sync.',
+    }),
 
-  /**
-   * Primary chat for the agent.
-   */
-  // TODO(dmaretskyi): Multiple chats; RB: branching hierarchy.
-  chat: Schema.optional(Ref.Ref(Chat.Chat).pipe(FormInputAnnotation.set(false))),
+    /**
+     * Instructions for the agent.
+     */
+    instructions: Ref.Ref(Text.Text).pipe(
+      Format.FormatAnnotation.set(Format.TypeFormat.Markdown),
+      Schema.annotations({ title: 'Instructions' }),
+    ),
 
-  // TODO(burdon): Is this used? Should it be an artifact?
-  // Format.FormatAnnotation.set(Format.TypeFormat.Markdown)
-  plan: Ref.Ref(Plan.Plan).pipe(FormInputAnnotation.set(false)),
+    /**
+     * Primary chat for the agent.
+     */
+    // TODO(dmaretskyi): Multiple chats; RB: branching hierarchy.
+    chat: Schema.optional(Ref.Ref(Chat.Chat).pipe(FormInputAnnotation.set(false))),
 
-  // TODO(burdon): Currently Memory.Memory objects are global to the space; make them artifacts?
-  artifacts: Schema.Array(
-    Schema.Struct({
-      // TODO(dmaretskyi): Consider gettings names from the artifact itself using Obj.getLabel.
-      name: Schema.String,
-      // TODO(burdon): Rename object.
-      data: Ref.Ref(Obj.Unknown),
-    }),
-  ).pipe(FormInputAnnotation.set(false)),
-
-  /**
-   * References to objects with a canonical queue property.
-   * Schema must have the QueueAnnotation.
-   */
-  // Change to trigger.
-  // TODO(dmaretskyi): Turn into an array of objects when form-data
-  subscriptions: Schema.Array(Ref.Ref(Obj.Unknown)).pipe(FormInputAnnotation.set(false)),
+    // TODO(burdon): Currently Memory.Memory objects are global to the space; make them artifacts?
+    artifacts: Schema.Array(
+      Schema.Struct({
+        // TODO(dmaretskyi): Consider gettings names from the artifact itself using Obj.getLabel.
+        name: Schema.String,
+        // TODO(burdon): Rename object.
+        data: Ref.Ref(Obj.Unknown),
+      }),
+    ).pipe(FormInputAnnotation.set(false)),
 
-  /**
-   * Cron expression for a timer trigger that invokes the agent worker on a schedule.
-   * The timer trigger bypasses the qualifier and goes straight to the agent worker.
-   */
-  // Change to trigger.
-  cron: Schema.optional(Schema.String).annotations({
-    title: 'Cron',
-    description: 'Cron expression for a timer trigger that invokes the agent on a schedule.',
-  }),
+    /**
+     * References to objects with a canonical queue property.
+     * Schema must have the QueueAnnotation.
+     */
+    // Change to trigger.
+    // TODO(dmaretskyi): Turn into an array of objects when form-data
+    subscriptions: Schema.Array(Ref.Ref(Obj.Unknown)).pipe(FormInputAnnotation.set(false)),
 
-  /**
-   * Input feed for subscriptions.
-   * @deprecated Subscriptions will write directly to the agent.
-   */
-  feed: Schema.optional(Ref.Ref(Feed.Feed).pipe(FormInputAnnotation.set(false))),
+    /**
+     * Cron expression for a timer trigger that invokes the agent worker on a schedule.
+     * The timer trigger bypasses the qualifier and goes straight to the agent worker.
+     */
+    // Change to trigger.
+    cron: Schema.optional(Schema.String).annotations({
+      title: 'Cron',
+      description: 'Cron expression for a timer trigger that invokes the agent on a schedule.',
+    }),
 
-  /**
-   * Allow the agent to filter events.
-   * Related events will be added to the input queue of the agent.
-   * It is recommended to enable this.
-   * @deprecated
-   */
-  filterEvents: Schema.optional(Schema.Boolean).annotations({
-    title: 'Filter events',
-    description: 'Allow the agent to filter events.',
-  }),
-}).pipe(
-  Annotation.LabelAnnotation.set(['name']),
-  Annotation.IconAnnotation.set({ icon: 'ph--drone--regular', hue: 'sky' }),
-  Type.makeObject(DXN.make('org.dxos.type.agent', '0.1.0')),
-);
+    /**
+     * Input feed for subscriptions.
+     * @deprecated Subscriptions will write directly to the agent.
+     */
+    feed: Schema.optional(Ref.Ref(Feed.Feed).pipe(FormInputAnnotation.set(false))),
 
-export type Agent = Type.InstanceType<typeof Agent>;
+    /**
+     * Allow the agent to filter events.
+     * Related events will be added to the input queue of the agent.
+     * It is recommended to enable this.
+     * @deprecated
+     */
+    filterEvents: Schema.optional(Schema.Boolean).annotations({
+      title: 'Filter events',
+      description: 'Allow the agent to filter events.',
+    }),
+  }).pipe(
+    Annotation.LabelAnnotation.set(['name']),
+    Annotation.IconAnnotation.set({ icon: 'ph--drone--regular', hue: 'sky' }),
+  ),
+) {}
 
-export type MakeProps = Omit<
-  Obj.MakeProps<typeof Agent>,
-  'instructions' | 'plan' | 'artifacts' | 'subscriptions' | 'chat'
-> &
+export type MakeProps = Omit<Obj.MakeProps<typeof Agent>, 'instructions' | 'artifacts' | 'subscriptions' | 'chat'> &
   Partial<Pick<Obj.MakeProps<typeof Agent>, 'artifacts' | 'subscriptions'>> & {
     instructions: string;
-    blueprints?: Ref.Ref<Blueprint.Blueprint>[];
+    skills?: Ref.Ref<Skill.Skill>[];
     contextObjects?: Ref.Ref<Obj.Any>[];
   };
 
 /**
  * Creates a fully initialized Agent with chat, queue, and context bindings.
  *
- * @param props - Agent properties including spec, plan, blueprints, and context objects.
- * @param blueprint - The blueprint to use for the agent context.
+ * @param props - Agent properties including spec, skills, and context objects.
+ * @param skill - The skill to use for the agent context.
  * @returns An Effect that yields the initialized Agent.
  */
 export const makeInitialized = (
   props: MakeProps,
-  // TODO(burdon): Reconcile with props.blueprints.
-  blueprint: Blueprint.Blueprint,
-): Effect.Effect<Agent, never, Feed.FeedService | Database.Service> =>
+  // TODO(burdon): Reconcile with props.skills.
+  skill: Skill.Skill,
+): Effect.Effect<Agent, never, Database.Service> =>
   Effect.gen(function* () {
+    const { skills: propsSkills, contextObjects, ...agentProps } = props;
     const agent = yield* Database.add(
       Obj.make(Agent, {
-        ...props,
+        ...agentProps,
         instructions: Ref.make(Text.make({ content: props.instructions })),
-        plan: Ref.make(Plan.makePlan({ tasks: [] })),
         artifacts: props.artifacts ?? [],
         subscriptions: props.subscriptions ?? [],
         filterEvents: props.filterEvents ?? true,
@@ -140,15 +131,20 @@ export const makeInitialized = (
       }),
     );
     const feed = yield* Database.add(Feed.make());
-    const runtime = yield* Effect.runtime<Feed.FeedService>();
+    const runtime = yield* Effect.runtime<Database.Service>();
     const contextBinder = new AiContext.Binder({ feed, runtime });
-    // TODO(dmaretskyi): Blueprint registry.
-    const agentBlueprint = yield* Database.add(Obj.clone(blueprint, { deep: true }));
-    yield* Effect.promise(() =>
-      contextBinder.bind({
-        blueprints: [Ref.make(agentBlueprint), ...(props.blueprints ?? [])],
-        objects: [Ref.make(agent), ...(props.contextObjects ?? [])],
-      }),
+    // TODO(dmaretskyi): Skill registry.
+    const agentSkill = yield* Database.add(Obj.clone(skill, { deep: 'all' }));
+
+    // Persist any inline (transient) skills so their refs are resolvable from feed bindings later.
+    // Refs created with Ref.make(obj) carry an inline target, but when stored in ECHO and read back
+    // by a new AiSession, the target is lost and must be found in the DB via tryLoad().
+    const persistedPropsSkills = yield* Effect.all(
+      (propsSkills ?? []).map((ref) =>
+        ref.target !== undefined
+          ? Database.add(ref.target).pipe(Effect.map((persisted) => Ref.make(persisted)))
+          : Effect.succeed(ref),
+      ),
     );
 
     const chat = yield* Database.add(
@@ -158,6 +154,12 @@ export const makeInitialized = (
       }),
     );
     Obj.setParent(feed, chat);
+    yield* Effect.promise(() =>
+      contextBinder.bind({
+        skills: [Ref.make(agentSkill), ...persistedPropsSkills],
+        objects: [Ref.make(agent), Ref.make(chat), ...(contextObjects ?? [])],
+      }),
+    );
     yield* Database.add(
       Relation.make(Chat.CompanionTo, {
         [Relation.Source]: chat,
@@ -176,14 +178,12 @@ export const makeInitialized = (
 
 /**
  * Resets the agent chat history by rebuilding the chat context.
- * Preserves the existing blueprints and objects from the current chat context.
+ * Preserves the existing skills and objects from the current chat context.
  *
  * @param agent - The agent whose chat history should be reset. Must have an existing chat.
  * @returns An Effect that resets the chat history.
  */
-export const resetChatHistory = (
-  agent: Agent,
-): Effect.Effect<void, EntityNotFoundError, Feed.FeedService | Database.Service> =>
+export const resetChatHistory = (agent: Agent): Effect.Effect<void, EntityNotFoundError, Database.Service> =>
   Effect.gen(function* () {
     invariant(agent.chat, 'Agent must have an existing chat to reset.');
 
@@ -191,7 +191,7 @@ export const resetChatHistory = (
       Effect.map((_) => _.feed),
       Effect.flatMap(Database.load),
     );
-    const runtime = yield* Effect.runtime<Feed.FeedService>();
+    const runtime = yield* Effect.runtime<Database.Service>();
     const existingContextBinder = yield* EffectEx.acquireReleaseResource(
       () =>
         new AiContext.Binder({
@@ -199,24 +199,28 @@ export const resetChatHistory = (
           runtime,
         }),
     );
-    const blueprints = existingContextBinder.getBlueprints().map((blueprint) => Ref.make(blueprint));
-    const objects = existingContextBinder.getObjects().map((object) => Ref.make(object));
+    const skills = existingContextBinder.getSkills().map((skill) => Ref.make(skill));
+    const objects = existingContextBinder
+      .getObjects()
+      .filter((object) => !Obj.instanceOf(Chat.Chat, object))
+      .map((object) => Ref.make(object));
 
     const feed = yield* Database.add(Feed.make());
     const contextBinder = new AiContext.Binder({ feed, runtime });
-    yield* Effect.promise(() =>
-      contextBinder.bind({
-        blueprints,
-        objects,
-      }),
-    );
 
     const chat = yield* Database.add(
       Chat.make({
+        [Obj.Parent]: agent,
         feed: Ref.make(feed),
       }),
     );
     Obj.setParent(feed, chat);
+    yield* Effect.promise(() =>
+      contextBinder.bind({
+        skills,
+        objects: [...objects, Ref.make(chat)],
+      }),
+    );
     Obj.update(agent, (agent) => {
       agent.chat = Ref.make(chat);
     });
@@ -229,10 +233,14 @@ export const resetChatHistory = (
     );
   }).pipe(Effect.scoped);
 
-export const getFromChatContext: Effect.Effect<Agent, Error, AiContext.Service> = Effect.gen(function* () {
-  const agents = yield* Function.pipe(AiContext.Service.findObjects(Agent));
+export const getFromChatContext: Effect.Effect<
+  Agent,
+  HarnessContextError | Harness.NotSupportedError,
+  Harness.HarnessService
+> = Effect.gen(function* () {
+  const agents = yield* Harness.queryContext(Filter.type(Agent));
   if (agents.length !== 1) {
-    return yield* Effect.fail(new Error(`There should be exactly one agent in context. Got: ${agents.length}`));
+    return yield* Effect.fail(new HarnessContextError({ type: 'agent', count: agents.length }));
   }
 
   const agent = agents[0];

package/src/types/Chat.ts

@@ -4,50 +4,98 @@
 
 // @import-as-namespace
 
+import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { DXN, Annotation, Feed, Obj, Ref, Type } from '@dxos/echo';
+import { Harness } from '@dxos/assistant';
+import { Annotation, Database, DXN, Feed, Filter, Obj, Ref, Type } from '@dxos/echo';
 import { FormInputAnnotation, LabelAnnotation } from '@dxos/echo/Annotation';
+import { type EntityNotFoundError } from '@dxos/echo/Err';
+
+import { HarnessContextError } from '../errors';
+import * as Plan from './Plan';
 
 /**
  * AI chat.
  */
-export const Chat = Schema.Struct({
-  name: Schema.String.pipe(Schema.optional),
-  feed: Ref.Ref(Feed.Feed).pipe(FormInputAnnotation.set(false)),
-  view: Schema.String.pipe(Schema.optional),
-}).pipe(
-  LabelAnnotation.set(['name']),
-  Annotation.IconAnnotation.set({ icon: 'ph--sparkle--regular', hue: 'sky' }),
-  Type.makeObject(DXN.make('org.dxos.type.assistant.chat', '0.1.0')),
-);
-
-export type Chat = Type.InstanceType<typeof Chat>;
+export class Chat extends Type.makeObject<Chat>(DXN.make('org.dxos.type.assistant.chat', '0.1.0'))(
+  Schema.Struct({
+    name: Schema.String.pipe(Schema.optional),
+    feed: Ref.Ref(Feed.Feed).pipe(FormInputAnnotation.set(false)),
+    viewType: Schema.String.pipe(Schema.optional),
+
+    /**
+     * Session plan for tracking task progress within this conversation.
+     * Created lazily when the first task is recorded.
+     */
+    plan: Schema.optional(Ref.Ref(Plan.Plan).pipe(FormInputAnnotation.set(false))),
+  }).pipe(
+    LabelAnnotation.set(['name']),
+    Annotation.IconAnnotation.set({
+      icon: 'ph--sparkle--regular',
+      hue: 'amber',
+    }),
+  ),
+) {}
+
 export const make = (props: Obj.MakeProps<typeof Chat>) => Obj.make(Chat, props);
 
+/**
+ * Returns the session plan, creating and attaching one when absent.
+ */
+export const ensurePlan = (chat: Chat): Effect.Effect<Plan.Plan, EntityNotFoundError, Database.Service> =>
+  Effect.gen(function* () {
+    if (chat.plan) {
+      return yield* Database.load(chat.plan);
+    }
+
+    const plan = yield* Database.add(Plan.makePlan({ tasks: [] }));
+    Obj.update(chat, (chat) => {
+      chat.plan = Ref.make(plan);
+    });
+    yield* Database.flush();
+    return plan;
+  });
+
+/**
+ * Resolves the bound session {@link Chat} for the current conversation.
+ * Planning and other session-scoped tools require exactly one chat in harness context.
+ */
+export const getFromContext: Effect.Effect<
+  Chat,
+  HarnessContextError | Harness.NotSupportedError,
+  Harness.HarnessService
+> = Effect.gen(function* () {
+  const chats = yield* Harness.queryContext(Filter.type(Chat));
+  if (chats.length !== 1) {
+    return yield* Effect.fail(new HarnessContextError({ type: 'chat', count: chats.length }));
+  }
+
+  return chats[0];
+});
+
 /** @deprecated Use CompanionTo instead. */
-export const LegacyCompanionTo = Schema.Struct({
-  id: Obj.ID,
-}).pipe(
-  Type.makeRelation({
-    dxn: DXN.make('org.dxos.relation.assistant.companionTo', '0.1.0'),
-    source: Chat,
-    target: Obj.Unknown,
+export class LegacyCompanionTo extends Type.makeRelation<LegacyCompanionTo>(
+  DXN.make('org.dxos.relation.assistant.companionTo', '0.1.0'),
+)({
+  source: Chat,
+  target: Obj.Unknown,
+})(
+  Schema.Struct({
+    id: Obj.ID,
   }),
-);
+) {}
 
-export type LegacyCompanionTo = Type.InstanceType<typeof LegacyCompanionTo>;
 /**
  * Relation between a Chat and companion objects (e.g., artifacts).
  */
-export const CompanionTo = Schema.Struct({
-  id: Obj.ID,
-}).pipe(
-  Type.makeRelation({
-    dxn: DXN.make('org.dxos.relation.assistant.companionTo', '0.1.0'),
-    source: Chat,
-    target: Obj.Unknown,
+export class CompanionTo extends Type.makeRelation<CompanionTo>(
+  DXN.make('org.dxos.relation.assistant.companionTo', '0.1.0'),
+)({
+  source: Chat,
+  target: Obj.Unknown,
+})(
+  Schema.Struct({
+    id: Obj.ID,
   }),
-);
-
-export type CompanionTo = Type.InstanceType<typeof CompanionTo>;
+) {}

package/src/types/McpServer.ts

@@ -7,7 +7,7 @@
 import * as Schema from 'effect/Schema';
 
 import { McpServer as McpServerSpec } from '@dxos/compute';
-import { DXN, Annotation, Type } from '@dxos/echo';
+import { Annotation, DXN, Type } from '@dxos/echo';
 import { LabelAnnotation } from '@dxos/echo/Annotation';
 
 /**
@@ -19,13 +19,12 @@ import { LabelAnnotation } from '@dxos/echo/Annotation';
  * NOTE: `apiKey` is stored in plaintext and replicated to all peers with access to the space.
  * A future iteration should move secrets to per-device credential storage or use envelope encryption.
  */
-export const McpServer = Schema.Struct({
-  ...McpServerSpec.McpServer.fields,
-  enabled: Schema.optional(Schema.Boolean),
-}).pipe(
-  LabelAnnotation.set(['name']),
-  Annotation.IconAnnotation.set({ icon: 'ph--plugs-connected--regular', hue: 'sky' }),
-  Type.makeObject(DXN.make('org.dxos.type.assistant.mcpServer', '0.1.0')),
-);
-
-export type McpServer = Type.InstanceType<typeof McpServer>;
+export class McpServer extends Type.makeObject<McpServer>(DXN.make('org.dxos.type.assistant.mcpServer', '0.1.0'))(
+  Schema.Struct({
+    ...McpServerSpec.McpServer.fields,
+    enabled: Schema.optional(Schema.Boolean),
+  }).pipe(
+    LabelAnnotation.set(['name']),
+    Annotation.IconAnnotation.set({ icon: 'ph--plugs-connected--regular', hue: 'sky' }),
+  ),
+) {}

package/src/types/Memory.ts

@@ -4,19 +4,18 @@
 
 import * as Schema from 'effect/Schema';
 
-import { DXN, Annotation, Type } from '@dxos/echo';
+import { Annotation, DXN, Type } from '@dxos/echo';
 
 /**
  * Unit of knowledge generated by an agent.
  */
-export const Memory = Schema.Struct({
-  title: Schema.String,
-  content: Schema.String,
-}).pipe(
-  Annotation.LabelAnnotation.set(['title']),
-  Annotation.IconAnnotation.set({ icon: 'ph--brain--regular', hue: 'pink' }),
-  Annotation.HiddenAnnotation.set(true),
-  Type.makeObject(DXN.make('org.dxos.type.memory', '0.1.0')),
-);
-
-export type Memory = Type.InstanceType<typeof Memory>;
+export class Memory extends Type.makeObject<Memory>(DXN.make('org.dxos.type.memory', '0.1.0'))(
+  Schema.Struct({
+    title: Schema.String,
+    content: Schema.String,
+  }).pipe(
+    Annotation.LabelAnnotation.set(['title']),
+    Annotation.IconAnnotation.set({ icon: 'ph--brain--regular', hue: 'pink' }),
+    Annotation.HiddenAnnotation.set(true),
+  ),
+) {}

package/src/types/Plan.ts

@@ -6,9 +6,8 @@
 
 import * as Schema from 'effect/Schema';
 
-import { DXN, Annotation, Obj, Ref, Type } from '@dxos/echo';
-
-import * as Chat from './Chat';
+import { Process } from '@dxos/compute';
+import { Annotation, DXN, Obj, Type } from '@dxos/echo';
 
 export const TaskId = Schema.String.pipe(Schema.brand('@dxos/assistant-toolkit/TaskId'));
 export type TaskId = Schema.Schema.Type<typeof TaskId>;
@@ -33,26 +32,38 @@ export const Task = Schema.Struct({
   delegated: Schema.optional(Schema.Boolean),
 
   /**
-   * Parent task ID.
+   * Sub-agent process id; set when the supervisor spawns a delegated task.
    */
-  parent: Schema.optional(TaskId).annotations({
-    description: 'Parent task ID.',
+  agentPid: Schema.optional(Process.ID).annotations({
+    description: 'Sub-agent process id for delegated tasks.',
   }),
 
   /**
-   * Chat object that this task is associated with.
+   * Parent task ID.
    */
-  chat: Schema.optional(Ref.Ref(Chat.Chat)),
+  parent: Schema.optional(TaskId).annotations({
+    description: 'Parent task ID.',
+  }),
 });
 
 export type Task = Schema.Schema.Type<typeof Task>;
+
+/** Lifecycle status of a {@link Task}. */
+export type TaskStatus = Task['status'];
+
+/**
+ * Short tag label for a delegated sub-agent process id (e.g. `agent-a1b2`).
+ */
+export const formatAgentPidTag = (pid: Process.ID): string => `agent-${String(pid).replaceAll('-', '').slice(0, 4)}`;
+
 /**
  * Hierarchical collection of tasks for humans and agents to track progress.
  */
-export const Plan = Schema.Struct({
-  tasks: Schema.Array(Task),
-}).pipe(Annotation.HiddenAnnotation.set(true), Type.makeObject(DXN.make('org.dxos.type.plan', '0.1.0')));
-export type Plan = Type.InstanceType<typeof Plan>;
+export class Plan extends Type.makeObject<Plan>(DXN.make('org.dxos.type.plan', '0.1.0'))(
+  Schema.Struct({
+    tasks: Schema.Array(Task),
+  }).pipe(Annotation.HiddenAnnotation.set(true)),
+) {}
 export const generateTaskId = (plan: Plan): TaskId => {
   const existingIds = plan.tasks
     .map((task) => {
@@ -76,7 +87,7 @@ export const generateTaskId = (plan: Plan): TaskId => {
  */
 export const addTasks = (
   plan: Obj.Mutable<Plan>,
-  tasks: (Pick<Task, 'title'> & Partial<Pick<Task, 'status' | 'parent' | 'chat' | 'delegated'>>)[],
+  tasks: (Pick<Task, 'title'> & Partial<Pick<Task, 'status' | 'parent' | 'delegated'>>)[],
 ) => {
   for (const task of tasks) {
     const taskId = generateTaskId(plan);
@@ -105,3 +116,8 @@ export const formatPlan = (plan: Plan): string => {
     .map((task) => `- **${task.status?.toLocaleUpperCase()}**: ${task.title ?? 'No title'} <!-- id=${task.id} -->`)
     .join('\n');
 };
+
+/**
+ * True when the plan has any task that is not yet `done`.
+ */
+export const hasIncompleteTasks = (plan: Plan): boolean => plan.tasks.some((task) => task.status !== 'done');

package/dist/lib/neutral/agent-LCBDWP74.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/blueprints/agent/operations/agent.ts"],
-  "sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\n\nimport { AiService } from '@dxos/ai';\nimport { AiSession, ToolExecutionServices } from '@dxos/assistant';\nimport { Operation } from '@dxos/compute';\nimport { Database, Feed, Obj } from '@dxos/echo';\nimport { EffectEx } from '@dxos/effect';\nimport { invariant } from '@dxos/invariant';\nimport { ContentBlock } from '@dxos/types';\n\nimport { Agent } from '../../../types';\nimport { AgentWorker } from './definitions';\n\nexport default AgentWorker.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* ({ agent: agentRef, prompt, event }) {\n      const agent = yield* Database.load(agentRef).pipe(\n        Effect.catchTag('EntityNotFoundError', () => Effect.die(new Error('Unable to load agent object.'))),\n      );\n      invariant(Obj.instanceOf(Agent.Agent, agent));\n      invariant(agent.chat, 'Agent has no chat.');\n\n      const chatFeed = yield* agent.chat.pipe(\n        Database.load,\n        Effect.flatMap((chat) => Database.load(chat.feed)),\n        Effect.catchTag('EntityNotFoundError', () => Effect.die(new Error('Unable to load agent chat feed object.'))),\n      );\n      invariant(chatFeed, 'Agent chat feed not found.');\n      const runtime = yield* Effect.runtime<Feed.FeedService>();\n      const session = yield* EffectEx.acquireReleaseResource(() => new AiSession.Session({ feed: chatFeed, runtime }));\n\n      const agentsInContext = session.context.getObjects().filter(Obj.instanceOf(Agent.Agent));\n      if (agentsInContext.length !== 1) {\n        throw new Error('There should be exactly one agent in context. Got: ' + agentsInContext.length);\n      }\n\n      if (!prompt && !event) {\n        throw new Error('Either prompt or event must be provided.');\n      }\n\n      let input: ContentBlock.Any[] = [];\n      if (prompt) {\n        input.push({ _tag: 'text', text: prompt, disposition: 'synthetic' });\n      }\n      if (event) {\n        input.push({ _tag: 'text', text: JSON.stringify(event), disposition: 'synthetic' });\n      }\n\n      yield* session\n        .createRequest({\n          prompt: input,\n        })\n        .pipe(\n          Effect.provide(\n            Layer.mergeAll(AiService.model('ai.claude.model.claude-opus-4-6'), ToolExecutionServices).pipe(\n              Layer.provideMerge(Operation.withInvocationOptions({ conversation: Obj.getURI(chatFeed) })),\n            ),\n          ),\n          Effect.retry({ times: 2 }),\n        );\n    }, Effect.scoped),\n  ),\n  Operation.opaqueHandler,\n);\n"],
-  "mappings": ";;;;;;;;;;;AAIA,YAAYA,YAAY;AACxB,YAAYC,WAAW;AAEvB,SAASC,iBAAiB;AAC1B,SAASC,WAAWC,6BAA6B;AACjD,SAASC,iBAAiB;AAC1B,SAASC,UAAgBC,WAAW;AACpC,SAASC,gBAAgB;AACzB,SAASC,iBAAiB;AAM1B,IAAA,eAAeC;IAMTC,gBAAUC,YAAIC,KAAWC,UAAaC,YAAAA,kBAAAA,WAAAA,EAAAA,OAAAA,UAAAA,QAAAA,MAAAA,GAAAA;AACtCJ,QAAAA,QAAUI,OAAU,SAAE,KAAA,QAAA,EAAA,KAAA,gBAAA,uBAAA,MAAA,WAAA,IAAA,MAAA,8BAAA,CAAA,CAAA,CAAA;AAEtB,YAAMC,IAAAA,WAAkBD,cAAME,OAAKC,KACjCC,GAAAA,QAASC,EAAI,YACNC,YAASJ,GAAAA,cAAkBG,GAAKH,IAAAA,GAAKK,MAAI,GAAA,CAChDC,sCAAgB,EAAuB,EAAA,CAAA;AAEzCZ,YAAUK,MAAAA,MAAU,sBAAA,EAAA,YAAA,YAAA,GAAA,cAAA,GAAA,IAAA,GAAA,MAAA,GAAA,CAAA,cAAA,sBAAA,EAAA,CAAA;AACpB,QAAMQ,WAAU,OAAOD,MAAOC,KAAAA,KAAO,SAAA,MAAA,eAAA,CAAA,SAAA,SAAA,KAAA,KAAA,IAAA,CAAA,GAAA,gBAAA,uBAAA,MAAA,WAAA,IAAA,MAAA,wCAAA,CAAA,CAAA,CAAA;AACrC,YAAMC,UAAU,8BAAgBC,EAAAA,YAA6B,YAAIC,GAAUC,cAAQ,GAAA,IAAA,GAAA,MAAA,GAAA,CAAA,YAAA,8BAAA,EAAA,CAAA;mBAAQZ,OAAAA,eAAAA;kBAAUQ,OAAAA,SAAAA,uBAAAA,MAAAA,IAAAA,UAAAA,QAAAA;IAAQ,MAAA;IAEvGK,SAAAA;EACFA,CAAAA,CAAAA;QACF,kBAAgB,QAAA,QAAA,WAAA,EAAA,OAAA,IAAA,WAAA,cAAwDA,KAAAA,CAAAA;AAC1E,MAAA,gBAAA,WAAA,GAAA;AAEI,UAACC,IAAAA,MAAWC,wDAAO,gBAAA,MAAA;;AAEvB,MAAA,CAAA,UAAA,CAAA,OAAA;AAEIC,UAAAA,IAA8B,MAAA,0CAAA;EAClC;MACEA,QAAMC,CAAAA;cAAOC;UAAcC,KAAML;MAAQM,MAAAA;MAAyB,MAAA;MACpE,aAAA;IACIL,CAAAA;;aACWG;UAAcC,KAAME;MAAuBD,MAAAA;MAAyB,MAAA,KAAA,UAAA,KAAA;MACnF,aAAA;IAEA,CAAA;;AAGE,SACK,QACIE,cACCC;IACiDC,QAAAA;EAAmC,CAAA,EAAA,KAGrFC,eAAM,eAAA,UAAA,MAAA,iCAAA,GAAA,qBAAA,EAAA,KAAA,mBAAA,UAAA,sBAAA;IAAEC,cAAO,IAAA,OAAA,QAAA;EAAE,CAAA,CAAA,CAAA,CAAA,GAAA,aAAA;IAE3BnB,OAAOoB;;;",
-  "names": ["Effect", "Layer", "AiService", "AiSession", "ToolExecutionServices", "Operation", "Database", "Obj", "EffectEx", "invariant", "AgentWorker", "invariant", "Obj", "instanceOf", "Agent", "agent", "chatFeed", "chat", "pipe", "Database", "load", "flatMap", "feed", "Effect", "runtime", "session", "acquireReleaseResource", "AiSession", "Session", "agentsInContext", "prompt", "event", "input", "push", "_tag", "text", "disposition", "JSON", "provide", "mergeAll", "conversation", "retry", "times", "scoped"]
-}

package/dist/lib/neutral/agent-rules-3TBAIVTS.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/blueprints/agent-wizard/operations/agent-rules.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Operation } from '@dxos/compute';\nimport { trim } from '@dxos/util';\n\nimport { AgentRules } from './definitions';\n\nexport default AgentRules.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* () {\n      return trim`\n        You can ask the user for qualifying questions about the agents.\n        If agents should actively read incoming emails, query for mailboxes and add a subscription to them.\n        If the user wants the agent to run on a schedule (e.g. \"every morning\", \"every 5 minutes\"), set the agent's \\`cron\\` field to a standard cron expression (e.g. \\`0 9 * * *\\` for daily at 09:00, \\`*/5 * * * *\\` for every 5 minutes). Timer triggers bypass the qualifier and invoke the agent worker directly on the schedule.\n        Use [query-blueprints] from the Blueprint Manager to query for available blueprints and their keys.\n        Use [create-agent] function to create a new agent.\n\n        Notable blueprints (query to get their keys):\n\n        - Blueprint Manger - allows agent to self-enable blueprints (always include this one).\n        - Database -- CRUD on objects in the ECHO database.\n        - Markdown -- Create and edit markdown documents.\n        - Websearch -- Search the web for information.\n        - Browser -- Virtual browser via playwright when simple WebSearch is not enough.\n        - Memory -- Memory to store and retrieve information.\n\n        Experimental blueprints that are discouraged:\n\n        - Research\n        - Design\n        - Agent (not wizard) -- those are agent internals, they are auto-added to every new agent.\n\n        <example_agent>\n          ## CRM from your inbox\n\n          Blueprints: database, websearch, browser\n\n          Subscribe to your inboxes.\n          Spec says that on every email we should extract People and Organizations and save them to the database, but first query the database for existing people and organizations to avoid duplicates.\n          Also run a quick research on the web to find more information about the person or organization and save it to the database.\n        </example_agent>\n\n        <example_agent>\n          ## Parcel tracking\n\n          Blueprints: database\n\n          Based on emails from vendors (amazon, fedex, etc.) track the status of the parcels ordered online and keep a table of orders.\n\n          Before creating an agent, use the Database blueprint to create an Order schema:\n            - seller\n            - name\n            - price\n            - status (enum of: pending, shipped, waiting for pickup, delivered, cancelled, returned)\n            - tracking numbers/notes\n            - date of delivery\n            - shipping address\n        </example_agent>\n\n        <example_agent>\n          ## Comms assistant\n\n          Blueprints: database, markdown, inbox\n\n          Helps user maintain comms with external parites via email.\n          Ask user specifically who they want to communicate with and on what topic.\n          Agent should keep a markdown document in artifacts outlining the current state of the comms.\n          Agent should propose drafts to follow up on the comms. Only propose sensible drafts, do not propose drafts that are not relevant or actionable.\n        </example_agent>\n      `;\n    }),\n  ),\n);\n"],
-  "mappings": ";;;;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,iBAAiB;AAC1B,SAASC,YAAY;AAIrB,IAAA,sBAAeC,WAAWC,KACxBC,UAAUC,YACDC,kBAAW,aAAA;AAChB,SAAOC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DT,CAAA,CAAA,CAAA;",
-  "names": ["Effect", "Operation", "trim", "AgentRules", "pipe", "Operation", "withHandler", "fnUntraced", "trim"]
-}