@dxos/assistant-toolkit 0.8.4-main.abd8ff62ef → 0.8.4-main.bc2380dfbc

package/src/blueprints/memory/blueprint.ts

@@ -28,7 +28,7 @@ const make = () =>
     description: 'Persistent memory storage and retrieval.',
     agentCanEnable: true,
     instructions: {
-      source: Ref.make(Text.make(instructions)),
+      source: Ref.make(Text.make({ content: instructions })),
     },
     tools: Blueprint.toolDefinitions({ operations: [SaveMemory, QueryMemories, DeleteMemory] }),
   });

package/src/blueprints/planning/blueprint.ts

@@ -12,7 +12,7 @@ const make = () =>
   Blueprint.make({
     key: BLUEPRINT_KEY,
     name: 'Planning',
-    description: 'Plans and tracks complex tasks with artifact management.',
+    description: 'Plans and tracks complex tasks using artifacts.',
     tools: Blueprint.toolDefinitions({ operations: [UpdateTasks] }),
   });
 

package/src/blueprints/planning/functions/index.ts

@@ -4,6 +4,6 @@
 
 import { OperationHandlerSet } from '@dxos/compute';
 
-export * from './definitions';
+export * from './update-tasks';
 
 export const PlanningHandlers = OperationHandlerSet.lazy(() => import('./update-tasks'));

package/src/blueprints/planning/functions/{definitions.ts → update-tasks.md}

@@ -1,41 +1,38 @@
-//
-// Copyright 2026 DXOS.org
-//
+## PLANNING TOOL
 
-import * as Schema from 'effect/Schema';
+This tool maintains an organized task list.
+Use this to track progress, break down objectives, and ensure thoroughness.
+If you are asked to create a plan use this tool instead of creating a new document.
+After creating initial tasks, update them silently without announcing changes to the user.
+Important: Do not show or summarize the contents of the task list unless the user asks for this.
 
-import { AiContextService } from '@dxos/assistant';
-import { Operation } from '@dxos/compute';
-import { Database } from '@dxos/echo';
-import { trim } from '@dxos/util';
+### CORE USAGE PRINCIPLES
 
-import { Plan } from '../../../types';
+Create and manage tasks for: multi-step objectives requiring 3+ distinct actions, complex projects needing careful sequencing,
+user requests for task organization, multiple deliverables provided together, new instructions (capture as tasks immediately with new IDs),
+completed work (mark `done` and add follow-ups), and active work (mark as `in-progress`, limit one at a time).
 
-const INSTRUCTIONS = trim`
-TASK MANAGEMENT TOOL - USAGE GUIDELINES
+Skip task management for: single straightforward actions, simple requests achievable in 1-2 steps,
+informational queries, quick lookups or clarifications, and avoid creating verification tasks unless requested.
 
-This tool maintains an organized task list during work sessions to track progress, break down objectives, and ensure thoroughness. After creating initial tasks, update them silently without announcing changes to the user.
+### TOOL SPECIFICATION
 
-=== CORE USAGE PRINCIPLES ===
+`update-tasks` requires an array of task objects. Each task object contains:
 
-Create and manage tasks for: multi-step objectives requiring 3+ distinct actions, complex projects needing careful sequencing, user requests for task organization, multiple deliverables provided together, new instructions (capture as tasks immediately with new IDs), completed work (mark done and add follow-ups), and active work (mark as 'in-progress', limit one at a time).
-
-Skip task management for: single straightforward actions, simple requests achievable in 1-2 steps, informational queries, quick lookups or clarifications, and avoid creating verification tasks unless requested.
-
-=== TOOL SPECIFICATION ===
-
-update-tasks requires an array of task objects. Each task object contains:
 - id (string, required): unique identifier like "task_1" or "research_sources"
 - title (string, optional): update to clarify or refine task description
-- status (string, optional): 'todo' | 'in-progress' | 'done'
+- status (string, optional): `todo` | `in-progress` | `done`
 
-Task status meanings: 'todo' means not yet started, 'in-progress' means currently being worked on, 'done' means completed successfully.
+Task status meanings: 'todo' means not yet started, `in-progress` means currently being worked on, `done` means completed successfully.
 
-=== OPERATIONAL GUIDELINES ===
+### OPERATIONAL GUIDELINES
 
-Update tasks in real-time as work progresses. Mark tasks 'done' immediately upon completion. Maintain only ONE task with 'in-progress' status at a time. Complete current tasks before starting new ones. Use specific, actionable task titles. Break complex work into manageable logical pieces. Batch task updates with other actions when possible for efficiency.
+Update tasks in realtime as work progresses. Mark tasks `done` immediately upon completion.
+Maintain only ONE task with `in-progress` status at a time. Complete current tasks before starting new ones.
+Use specific, actionable task titles. Break complex work into manageable logical pieces.
+Batch task updates with other actions when possible for efficiency.
 
-=== USAGE EXAMPLES ===
+### USAGE EXAMPLES
 
 <example type="research_project">
 <user_message>I need to research sustainable packaging options and write a report comparing costs and environmental impact.</user_message>
@@ -110,28 +107,10 @@ Creates tasks:
 <reasoning>One-step action with immediate completion, no organizational benefit from tasks.</reasoning>
 </example>
 
-=== BEST PRACTICES ===
-
-For task creation: use descriptive unique IDs reflecting the work, start first task as 'in-progress', batch initial creation with beginning work. For progress tracking: update status immediately upon completion, keep only one 'in-progress' task unless parallel work is natural, add follow-up tasks as they emerge. For task breakdown: aim for reasonably-scoped tasks, group related small actions into logical units, split tasks requiring different approaches.
-
-When uncertain whether to use task management, err on the side of creating tasks. Proactive organization demonstrates thoroughness and ensures comprehensive work completion.
-`;
-
-const TaskProps = Schema.Struct({
-  id: Plan.TaskId,
-  title: Schema.String,
-  status: Schema.Literal('todo', 'in-progress', 'done'),
-});
-
-export const UpdateTasks = Operation.make({
-  meta: {
-    key: 'org.dxos.function.planning.update-tasks',
-    name: 'Update tasks',
-    description: INSTRUCTIONS,
-  },
-  input: Schema.Struct({
-    tasks: Schema.Array(TaskProps),
-  }),
-  output: Schema.Any,
-  services: [AiContextService, Database.Service],
-});
+### BEST PRACTICES
+
+For task creation: use descriptive unique IDs reflecting the work, start first task as `in-progress`, batch initial creation with beginning work.
+For progress tracking: update status immediately upon completion, keep only one `in-progress` task unless parallel work is natural, add follow-up tasks as they emerge. For task breakdown: aim for reasonably-scoped tasks, group related small actions into logical units, split tasks requiring different approaches.
+
+When uncertain whether to use task management, err on the side of creating tasks.
+Proactive organization demonstrates thoroughness and ensures comprehensive work completion.

package/src/blueprints/planning/functions/update-tasks.test.ts

@@ -0,0 +1,55 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { Blueprint, Operation } from '@dxos/compute';
+import { Database, Feed, Obj } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
+import { invariant } from '@dxos/invariant';
+import { ObjectId } from '@dxos/keys';
+
+import { Agent, Chat, Plan } from '../../../types';
+import PlanningBlueprint from '../blueprint';
+import { PlanningHandlers } from './index';
+import { UpdateTasks } from './update-tasks';
+
+ObjectId.dangerouslyDisableRandomness();
+
+const TestLayer = AssistantTestLayer({
+  operationHandlers: PlanningHandlers,
+  types: [Agent.Agent, Plan.Plan, Chat.Chat, Chat.CompanionTo, Blueprint.Blueprint, Feed.Feed],
+  blueprints: [PlanningBlueprint.make()],
+  disableLlmMemoization: true,
+});
+
+describe('UpdateTasks', () => {
+  it.scoped(
+    'adds tasks to the plan',
+    Effect.fnUntraced(
+      function* ({ expect }) {
+        const agent = yield* Agent.makeInitialized(
+          { name: 'Planner', instructions: 'Test.' },
+          PlanningBlueprint.make(),
+        );
+        yield* Database.flush();
+
+        const chatFeed = agent.chat?.target?.feed?.target;
+        invariant(chatFeed, 'Agent chat feed not found.');
+
+        yield* Operation.invoke(UpdateTasks, {
+          tasks: [{ id: Plan.TaskId.make('task-1'), title: 'Hello', status: 'todo' }],
+        }).pipe(Effect.provide(Operation.withInvocationOptions({ conversation: Obj.getDXN(chatFeed).toString() })));
+
+        const plan = yield* Database.load(agent.plan);
+        expect(plan.tasks).toHaveLength(1);
+        expect(plan.tasks[0]).toMatchObject({ id: 'task-1', title: 'Hello', status: 'todo' });
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});

package/src/blueprints/planning/functions/update-tasks.ts

@@ -3,18 +3,40 @@
 //
 
 import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
 
+import { AiContext } from '@dxos/assistant';
 import { Operation } from '@dxos/compute';
 import { Database, Obj } from '@dxos/echo';
 import { trim } from '@dxos/util';
 
 import { Plan, Agent } from '../../../types';
-import { UpdateTasks } from './definitions';
+import INSTRUCTIONS from './update-tasks.md?raw';
 
+const SimpleTask = Plan.Task.omit('chat');
+
+export const UpdateTasks = Operation.make({
+  meta: {
+    key: 'org.dxos.function.planning.update-tasks', // TODO(burdon): Are hyphens allowed?
+    name: 'Update tasks',
+    description: INSTRUCTIONS,
+  },
+  input: Schema.Struct({
+    tasks: Schema.Array(SimpleTask),
+  }),
+  output: Schema.Any,
+  services: [AiContext.Service, Database.Service],
+});
+
+/**
+ * Updates the planning document (Agent.plan) with the given tasks.
+ */
 export default UpdateTasks.pipe(
   Operation.withHandler(
     Effect.fn(function* ({ tasks: newTasks }) {
       const agent = yield* Agent.getFromChatContext;
+      // TODO(burdon): How to specify requirements/preconditions before calling?
+      // TODO(burdon): How to report non-technical error?
       const plan = yield* Database.load(agent.plan);
 
       Obj.update(plan, (plan) => {
@@ -34,8 +56,8 @@ export default UpdateTasks.pipe(
       });
 
       return trim`
-        Tasks updated. Don't forget to mark tasks as done when you're done with them or update their status to 'in-progress' when you start working on them.
-        Current plan:
+        You must update the task status to 'in-progress' when you start and 'done' when complete.
+        Current plan updated:
         <plan>
           ${Plan.formatPlan(plan)}
         </plan>