@dxos/assistant-toolkit 0.10.0 → 0.11.0

package/src/skills/memory/operations/query.test.ts

@@ -0,0 +1,76 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Operation } from '@dxos/compute';
+import { Database, Obj } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { EntityId } from '@dxos/keys';
+
+import { OperationTestLayer } from '../../../testing';
+import { Memory } from '../../../types/Memory';
+import { QueryMemories } from './definitions';
+
+EntityId.dangerouslyDisableRandomness();
+
+describe('QueryMemories', () => {
+  it.effect(
+    'lists every memory when no text is given',
+    Effect.fnUntraced(
+      function* (_) {
+        yield* seed();
+
+        const results = yield* Operation.invoke(QueryMemories, {});
+
+        expect((yield* titles(results)).sort()).toEqual(['Favourite colour', 'Favourite language']);
+      },
+      Effect.provide(OperationTestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.effect(
+    'narrows to the memories matching the search text',
+    Effect.fnUntraced(
+      function* (_) {
+        yield* seed();
+
+        const results = yield* Operation.invoke(QueryMemories, { text: 'colour' });
+
+        expect(yield* titles(results)).toEqual(['Favourite colour']);
+      },
+      Effect.provide(OperationTestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.effect(
+    'caps the result count at the given limit',
+    Effect.fnUntraced(
+      function* (_) {
+        yield* seed();
+
+        const results = yield* Operation.invoke(QueryMemories, { limit: 1 });
+
+        expect(results).toHaveLength(1);
+      },
+      Effect.provide(OperationTestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});
+
+const titles = (results: readonly unknown[]) =>
+  Schema.decodeUnknown(Schema.Array(Schema.Struct({ title: Schema.String })))(results).pipe(
+    Effect.map((rows) => rows.map((row) => row.title)),
+  );
+
+const seed = Effect.fnUntraced(function* () {
+  yield* Database.add(Obj.make(Memory, { title: 'Favourite colour', content: 'The colour blue.' }));
+  yield* Database.add(Obj.make(Memory, { title: 'Favourite language', content: 'TypeScript.' }));
+  yield* Database.flush();
+});

package/src/skills/memory/operations/save.test.ts

@@ -0,0 +1,43 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Operation } from '@dxos/compute';
+import { Database, Filter, Query } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { EntityId } from '@dxos/keys';
+
+import { OperationTestLayer } from '../../../testing';
+import { Memory } from '../../../types/Memory';
+import { SaveMemory } from './definitions';
+
+EntityId.dangerouslyDisableRandomness();
+
+describe('SaveMemory', () => {
+  it.effect(
+    'persists a memory with the given title and content',
+    Effect.fnUntraced(
+      function* (_) {
+        const saved = yield* Operation.invoke(SaveMemory, {
+          title: 'Favourite language',
+          content: 'TypeScript',
+        });
+
+        const memories = yield* Database.query(Query.select(Filter.type(Memory))).run;
+        expect(memories).toHaveLength(1);
+        expect(memories[0].title).toBe('Favourite language');
+        expect(memories[0].content).toBe('TypeScript');
+
+        // The handler returns the stored entity so the agent can reference it by id.
+        const { id } = yield* Schema.decodeUnknown(Schema.Struct({ id: Schema.String }))(saved);
+        expect(id).toBe(memories[0].id);
+      },
+      Effect.provide(OperationTestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});

package/src/skills/planning/operations/definitions.ts

@@ -10,13 +10,16 @@ import { Operation } from '@dxos/compute';
 import { Database } from '@dxos/echo';
 import { DXN } from '@dxos/keys';
 
-import { Plan } from '../../../types';
 import INSTRUCTIONS from './update-tasks.md?raw';
 
-// Omit `delegated` and `agentPid` from the LLM-facing schema: these are set by the
-// delegation tool / runtime, never by ordinary planning, and keeping them out leaves the tool
-// schema unchanged.
-const SimpleTask = Plan.Task.omit('delegated', 'agentPid');
+/**
+ * LLM-facing checklist entry: items are addressed by title (the checklist is markdown — see
+ * `Outline.upsertChecklistItems`); `in-progress` renders unchecked, nuance lives in conversation.
+ */
+const ChecklistTask = Schema.Struct({
+  title: Schema.String.annotations({ description: 'Task title; also the key for updates.' }),
+  status: Schema.Literal('todo', 'in-progress', 'done'),
+});
 
 export const UpdateTasks = Operation.make({
   meta: {
@@ -26,7 +29,7 @@ export const UpdateTasks = Operation.make({
     icon: 'ph--check-square-offset--regular',
   },
   input: Schema.Struct({
-    tasks: Schema.Array(SimpleTask),
+    tasks: Schema.Array(ChecklistTask),
   }),
   output: Schema.Any,
   services: [Harness.HarnessService, Database.Service],

package/src/skills/planning/operations/plan-reminder.test.ts

@@ -0,0 +1,123 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+
+import { AssistantTestLayerWithTriggers } from '@dxos/agent-runtime/testing';
+import { ScriptedLanguageModel } from '@dxos/ai/testing';
+import { AiContext } from '@dxos/assistant';
+import { Operation, OperationHandlerSet, Skill } from '@dxos/compute';
+import { Database, Feed, Obj, Ref } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { EntityId } from '@dxos/keys';
+import { Text } from '@dxos/schema';
+import { Message, Outline } from '@dxos/types';
+
+import { Agent, Chat } from '../../../types';
+import { PlanReminder } from './definitions';
+import { PlanningHandlers } from './index';
+
+EntityId.dangerouslyDisableRandomness();
+
+describe('PlanReminder', () => {
+  it.effect(
+    'attempts a continuation reminder when the model says continue',
+    Effect.fnUntraced(
+      function* (_) {
+        const conversation = yield* setupChatWithChecklist([false]);
+
+        const exit = yield* Effect.exit(Operation.invoke(PlanReminder, {}).pipe(Effect.provide(conversation)));
+
+        expect(Exit.isFailure(exit)).toBe(true);
+      },
+      Effect.provide(layerDeciding('continue')),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.effect(
+    'enqueues nothing when the model says stop',
+    Effect.fnUntraced(
+      function* (_) {
+        const conversation = yield* setupChatWithChecklist([false]);
+
+        const exit = yield* Effect.exit(Operation.invoke(PlanReminder, {}).pipe(Effect.provide(conversation)));
+
+        expect(Exit.isSuccess(exit)).toBe(true);
+      },
+      Effect.provide(layerDeciding('stop')),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.effect(
+    'is a no-op when every item is checked, without consulting the model',
+    Effect.fnUntraced(
+      function* (_) {
+        const conversation = yield* setupChatWithChecklist([true]);
+
+        const exit = yield* Effect.exit(Operation.invoke(PlanReminder, {}).pipe(Effect.provide(conversation)));
+
+        // The script is empty, so reaching the model at all would fail as exhausted.
+        expect(Exit.isSuccess(exit)).toBe(true);
+      },
+      Effect.provide(
+        AssistantTestLayerWithTriggers({
+          operationHandlers: OperationHandlerSet.merge(PlanningHandlers),
+          types,
+          aiService: ScriptedLanguageModel.scriptedAiService([]),
+        }),
+      ),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});
+
+/** Creates a chat bound to its feed, carrying an outline checklist with the given item states. */
+const setupChatWithChecklist = Effect.fnUntraced(function* (states: readonly boolean[]) {
+  const feed = yield* Database.add(Feed.make());
+  const chat = yield* Database.add(Chat.make({ feed: Ref.make(feed) }));
+  const { text } = yield* Chat.ensureOutlineText(chat);
+  Obj.update(text, (text) => {
+    text.content = Outline.upsertChecklistItems(
+      text.content,
+      states.map((done, index) => ({ title: `Task ${index}`, done })),
+    );
+  });
+  yield* Database.flush();
+
+  const runtime = yield* Effect.runtime<Database.Service>();
+  const binder = new AiContext.Binder({ feed, runtime });
+  yield* Effect.promise(() => binder.bind({ objects: [Ref.make(chat)] }));
+
+  return Operation.withInvocationOptions({ conversation: Obj.getURI(feed) });
+});
+
+const types = [
+  Agent.Agent,
+  Outline.Outline,
+  Text.Text,
+  Chat.Chat,
+  Chat.CompanionTo,
+  Skill.Skill,
+  Feed.Feed,
+  Message.Message,
+  AiContext.Binding,
+];
+
+// The hook asks the model whether to keep working; scripting that reply covers both branches, which
+// a single frozen conversation could not.
+//
+// No host process is spawned, so the Tier B enqueue on the continue branch fails with
+// NotSupportedError. That failure is the assertion: it fires exactly when the hook decided to
+// enqueue, and its absence proves it decided not to — observable without reaching into the host's
+// queue, which is where the reminder would otherwise land.
+const layerDeciding = (decision: string) =>
+  AssistantTestLayerWithTriggers({
+    operationHandlers: OperationHandlerSet.merge(PlanningHandlers),
+    types,
+    aiService: ScriptedLanguageModel.scriptedAiService([{ parts: [ScriptedLanguageModel.text(decision)] }]),
+  });

package/src/skills/planning/operations/plan-reminder.ts

@@ -10,19 +10,20 @@ import { AiPreprocessor, AiService } from '@dxos/ai';
 import { Harness } from '@dxos/assistant';
 import { Operation } from '@dxos/compute';
 import { Database } from '@dxos/echo';
-import { ContentBlock } from '@dxos/types';
+import { ContentBlock, Outline } from '@dxos/types';
 import { trim } from '@dxos/util';
 
-import { Chat, Plan } from '../../../types';
+import { Chat } from '../../../types';
 import { PlanReminder } from './definitions';
 
 /**
- * End-request hook for the planning blueprint. When the session plan still has open tasks, an
- * ephemeral check asks the model — given the full conversation — whether the agent should keep
- * working: a deterministic reminder alone would trap an agent that legitimately finishes with open
- * tasks in an unbreakable re-prompt loop. On "continue" it enqueues a continuation reminder onto the
- * owning host's queue (HarnessService Tier B), which keeps the process alive; on "stop" it does
- * nothing so the agent may complete with tasks deliberately left open.
+ * End-request hook for the planning skill. When the conversation's working outline still has
+ * unchecked items, an ephemeral check asks the model — given the full conversation — whether the
+ * agent should keep working: a deterministic reminder alone would trap an agent that legitimately
+ * finishes with open items in an unbreakable re-prompt loop. On "continue" it enqueues a
+ * continuation reminder onto the owning host's queue (HarnessService Tier B), which keeps the
+ * process alive; on "stop" it does nothing so the agent may complete with items deliberately left
+ * open.
  */
 export default PlanReminder.pipe(
   Operation.withHandler(
@@ -32,27 +33,31 @@ export default PlanReminder.pipe(
         if (!chat) {
           return;
         }
-        if (!chat?.plan) {
+        // Only consult an outline that already exists — the reminder never creates one.
+        const outline = yield* resolveExistingOutline(chat);
+        if (!outline) {
           return;
         }
-        const plan = yield* Database.load(chat.plan).pipe(Effect.orElseSucceed(() => undefined));
-        if (!plan || !Plan.hasIncompleteTasks(plan)) {
+        const text = yield* Database.load(outline.content).pipe(Effect.orElseSucceed(() => undefined));
+        if (!text || !Outline.hasOpenItems(text.content)) {
           return;
         }
 
         const history = yield* Harness.history;
         const prompt = Prompt.merge(
-          yield* AiPreprocessor.preprocessPrompt(history, { system: planCompletionCheckSystem }),
-          planCompletionCheckPrompt(plan),
+          yield* AiPreprocessor.preprocessPrompt(history, { system: checklistCompletionCheckSystem }),
+          checklistCompletionCheckPrompt(text.content),
         );
-        const { text } = yield* Effect.scoped(LanguageModel.generateText({ prompt }));
+        const { text: reply } = yield* Effect.scoped(LanguageModel.generateText({ prompt }));
 
-        if (!parseContinueDecision(text)) {
+        if (!parseContinueDecision(reply)) {
           return;
         }
 
         yield* Harness.enqueueMessage({
-          content: [ContentBlock.Text.make({ text: planContinueReminderPrompt(plan), disposition: 'synthetic' })],
+          content: [
+            ContentBlock.Text.make({ text: checklistContinueReminderPrompt(text.content), disposition: 'synthetic' }),
+          ],
         });
       },
       Effect.provide(AiService.model('com.anthropic.model.claude-sonnet-4-6.default')),
@@ -60,24 +65,37 @@ export default PlanReminder.pipe(
   ),
 );
 
-const planCompletionCheckSystem = trim`
-  You decide whether an agent should stop or continue working on its plan, given the conversation
-  so far and the agent's remaining plan tasks.
+/**
+ * The working outline, if one exists: the parent project's, else the chat's own. Mirrors
+ * {@link Chat.ensureOutline}'s resolution order without the create path.
+ */
+const resolveExistingOutline = (chat: Chat.Chat) =>
+  Effect.gen(function* () {
+    const ref = Chat.peekOutlineRef(chat);
+    if (!ref) {
+      return undefined;
+    }
+    return yield* Database.load(ref).pipe(Effect.orElseSucceed(() => undefined));
+  });
+
+const checklistCompletionCheckSystem = trim`
+  You decide whether an agent should stop or continue working on its checklist, given the
+  conversation so far and the agent's remaining items.
   Reply with exactly one word: "stop" or "continue". Do not use tools. Do not add explanation.
 `;
 
-const planCompletionCheckPrompt = (plan: Plan.Plan): string => trim`
-  The agent is about to finish, but its plan still has incomplete tasks:
+const checklistCompletionCheckPrompt = (markdown: string): string => trim`
+  The agent is about to finish, but its checklist still has unchecked items:
 
-  <plan>
-  ${Plan.formatPlan(plan)}
-  </plan>
+  <checklist>
+  ${markdown}
+  </checklist>
 
-  Should the agent STOP now (no more work needed) or CONTINUE working on the plan?
+  Should the agent STOP now (no more work needed) or CONTINUE working on the checklist?
   Reply with exactly one word: "stop" or "continue".
 `;
 
-/** Prefer an explicit "continue"; treat ambiguous replies as continue so open plan work is not dropped. */
+/** Prefer an explicit "continue"; treat ambiguous replies as continue so open work is not dropped. */
 const parseContinueDecision = (reply: string): boolean => {
   const normalized = reply.toLowerCase();
   if (/\bcontinue\b/.test(normalized)) {
@@ -89,10 +107,10 @@ const parseContinueDecision = (reply: string): boolean => {
   return true;
 };
 
-const planContinueReminderPrompt = (plan: Plan.Plan): string => trim`
-  Your plan still has incomplete tasks — continue working before finishing:
+const checklistContinueReminderPrompt = (markdown: string): string => trim`
+  Your checklist still has unchecked items — continue working before finishing:
 
-  <plan>
-  ${Plan.formatPlan(plan)}
-  </plan>
+  <checklist>
+  ${markdown}
+  </checklist>
 `;

package/src/skills/planning/operations/update-tasks.md

@@ -9,7 +9,7 @@ Important: Do not show or summarize the contents of the task list unless the use
 ### CORE USAGE PRINCIPLES
 
 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),
+user requests for task organization, multiple deliverables provided together, new instructions (capture as tasks immediately),
 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,
@@ -17,13 +17,14 @@ informational queries, quick lookups or clarifications, and avoid creating verif
 
 ### TOOL SPECIFICATION
 
-`update-tasks` requires an array of task objects. Each task object contains:
+`update-tasks` requires an array of task objects. The task list is a markdown checklist; the
+title is the key — reuse the exact title to update an existing item, use a new title to add one.
+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`
+- title (string, required): specific, actionable task description; also the update key
+- status (string, required): `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 (rendered as a checked item).
 
 ### OPERATIONAL GUIDELINES
 
@@ -38,10 +39,10 @@ Batch task updates with other actions when possible for efficiency.
 <user_message>I need to research sustainable packaging options and write a report comparing costs and environmental impact.</user_message>
 <assistant_action>
 Creates tasks:
-1. {id: "research_materials", title: "Research sustainable packaging materials", status: "in-progress"}
-2. {id: "compare_costs", title: "Compile cost comparison data", status: "todo"}
-3. {id: "assess_impact", title: "Evaluate environmental impact metrics", status: "todo"}
-4. {id: "draft_report", title: "Write comparative analysis report", status: "todo"}
+1. {title: "Research sustainable packaging materials", status: "in-progress"}
+2. {title: "Compile cost comparison data", status: "todo"}
+3. {title: "Evaluate environmental impact metrics", status: "todo"}
+4. {title: "Write comparative analysis report", status: "todo"}
 
 Begins research work immediately in same response.
 </assistant_action>
@@ -52,10 +53,10 @@ Begins research work immediately in same response.
 <user_message>Help me plan a team retreat - venue, agenda, catering, and send invitations.</user_message>
 <assistant_action>
 Creates tasks:
-1. {id: "venue_options", title: "Research and recommend venues", status: "in-progress"}
-2. {id: "draft_agenda", title: "Create retreat agenda", status: "todo"}
-3. {id: "arrange_catering", title: "Coordinate catering options", status: "todo"}
-4. {id: "send_invites", title: "Draft and send invitations", status: "todo"}
+1. {title: "Research and recommend venues", status: "in-progress"}
+2. {title: "Create retreat agenda", status: "todo"}
+3. {title: "Coordinate catering options", status: "todo"}
+4. {title: "Draft and send invitations", status: "todo"}
 </assistant_action>
 <reasoning>Multiple distinct deliverables with dependencies requiring organized tracking.</reasoning>
 </example>
@@ -64,10 +65,10 @@ Creates tasks:
 <user_message>Review this 30-page contract for key terms, risks, and negotiation points.</user_message>
 <assistant_action>
 Creates tasks:
-1. {id: "extract_key_terms", title: "Identify key contractual terms", status: "in-progress"}
-2. {id: "flag_risks", title: "Flag potential risks and liabilities", status: "todo"}
-3. {id: "negotiation_points", title: "Compile negotiation recommendations", status: "todo"}
-4. {id: "summary_doc", title: "Prepare executive summary", status: "todo"}
+1. {title: "Identify key contractual terms", status: "in-progress"}
+2. {title: "Flag potential risks and liabilities", status: "todo"}
+3. {title: "Compile negotiation recommendations", status: "todo"}
+4. {title: "Prepare executive summary", status: "todo"}
 </assistant_action>
 <reasoning>Substantial analysis work requiring methodical breakdown and systematic review.</reasoning>
 </example>
@@ -76,9 +77,9 @@ Creates tasks:
 <user_message>I need: 1) competitor analysis for three companies, 2) SWOT analysis, 3) market positioning recommendations.</user_message>
 <assistant_action>
 Creates tasks:
-1. {id: "competitor_research", title: "Research three competitor companies", status: "in-progress"}
-2. {id: "swot_analysis", title: "Develop SWOT analysis", status: "todo"}
-3. {id: "positioning_recs", title: "Create market positioning recommendations", status: "todo"}
+1. {title: "Research three competitor companies", status: "in-progress"}
+2. {title: "Develop SWOT analysis", status: "todo"}
+3. {title: "Create market positioning recommendations", status: "todo"}
 </assistant_action>
 <reasoning>User provided numbered list of distinct deliverables requiring separate effort.</reasoning>
 </example>
@@ -109,7 +110,7 @@ Creates tasks:
 
 ### 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 task creation: use specific stable titles (they are the update key), 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.

package/src/skills/planning/operations/update-tasks.test.ts

@@ -5,15 +5,17 @@
 import { describe, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 
+import { AssistantTestLayer } from '@dxos/agent-runtime/testing';
 import { AiContext } from '@dxos/assistant';
 import { Operation, Skill } from '@dxos/compute';
 import { Database, Feed, Obj, Ref } from '@dxos/echo';
 import { TestHelpers } from '@dxos/effect/testing';
-import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 import { invariant } from '@dxos/invariant';
 import { EntityId } from '@dxos/keys';
+import { Text } from '@dxos/schema';
+import { Outline } from '@dxos/types';
 
-import { Agent, Chat, Plan } from '../../../types';
+import { Agent, Chat } from '../../../types';
 import PlanningSkill from '../skill';
 import { UpdateTasks } from './definitions';
 import { PlanningHandlers } from './index';
@@ -22,31 +24,33 @@ EntityId.dangerouslyDisableRandomness();
 
 const TestLayer = AssistantTestLayer({
   operationHandlers: PlanningHandlers,
-  types: [Agent.Agent, Plan.Plan, Chat.Chat, Chat.CompanionTo, Skill.Skill, Feed.Feed],
+  types: [Agent.Agent, Outline.Outline, Text.Text, Chat.Chat, Chat.CompanionTo, Skill.Skill, Feed.Feed],
   skills: [PlanningSkill.make()],
   disableLlmMemoization: true,
 });
 
 describe('UpdateTasks', () => {
   it.scoped(
-    'adds tasks to the plan',
+    'adds items to the checklist',
     Effect.fnUntraced(
       function* ({ expect }) {
         const agent = yield* Agent.makeInitialized({ name: 'Planner', instructions: 'Test.' }, PlanningSkill.make());
         yield* Database.flush();
 
-        const chatFeed = agent.chat?.target?.feed?.target;
+        const agentChat = yield* Agent.loadChat(agent);
+        const chatFeed = agentChat?.feed?.target;
         invariant(chatFeed, 'Agent chat feed not found.');
 
         yield* Operation.invoke(UpdateTasks, {
-          tasks: [{ id: Plan.TaskId.make('task-1'), title: 'Hello', status: 'todo' }],
+          tasks: [{ title: 'Hello', status: 'todo' }],
         }).pipe(Effect.provide(Operation.withInvocationOptions({ conversation: Obj.getURI(chatFeed) })));
 
-        const chat = yield* Database.load(agent.chat!);
-        expect(chat.plan).toBeDefined();
-        const plan = yield* Database.load(chat.plan!);
-        expect(plan.tasks).toHaveLength(1);
-        expect(plan.tasks[0]).toMatchObject({ id: 'task-1', title: 'Hello', status: 'todo' });
+        const chat = yield* Agent.loadChat(agent);
+        invariant(chat, 'Agent chat not found.');
+        expect(chat.outline).toBeDefined();
+        const outline = yield* Database.load(chat.outline!);
+        const text = yield* Database.load(outline.content);
+        expect(Outline.parseChecklist(text.content)).toEqual([{ title: 'Hello', done: false }]);
       },
       Effect.provide(TestLayer),
       TestHelpers.provideTestContext,
@@ -54,23 +58,33 @@ describe('UpdateTasks', () => {
   );
 
   it.scoped(
-    'adds tasks to the plan without an agent',
+    'adds items to the checklist without an agent, and checks off completed ones',
     Effect.fnUntraced(
       function* ({ expect }) {
         const feed = yield* Database.add(Feed.make());
         const chat = yield* Database.add(Chat.make({ feed: Ref.make(feed) }));
-        expect(chat.plan).toBeUndefined();
+        expect(chat.outline).toBeUndefined();
         const runtime = yield* Effect.runtime<Database.Service>();
         const binder = new AiContext.Binder({ feed, runtime });
         yield* Effect.promise(() => binder.bind({ objects: [Ref.make(chat)] }));
 
         yield* Operation.invoke(UpdateTasks, {
-          tasks: [{ id: Plan.TaskId.make('task-1'), title: 'Hello', status: 'todo' }],
+          tasks: [
+            { title: 'Hello', status: 'todo' },
+            { title: 'World', status: 'in-progress' },
+          ],
         }).pipe(Effect.provide(Operation.withInvocationOptions({ conversation: Obj.getURI(feed) })));
 
-        const plan = yield* Database.load(chat.plan!);
-        expect(plan.tasks).toHaveLength(1);
-        expect(plan.tasks[0]).toMatchObject({ id: 'task-1', title: 'Hello', status: 'todo' });
+        yield* Operation.invoke(UpdateTasks, {
+          tasks: [{ title: 'Hello', status: 'done' }],
+        }).pipe(Effect.provide(Operation.withInvocationOptions({ conversation: Obj.getURI(feed) })));
+
+        const outline = yield* Database.load(chat.outline!);
+        const text = yield* Database.load(outline.content);
+        expect(Outline.parseChecklist(text.content)).toEqual([
+          { title: 'Hello', done: true },
+          { title: 'World', done: false },
+        ]);
       },
       Effect.provide(TestLayer),
       TestHelpers.provideTestContext,