@dxos/assistant-toolkit 0.10.0 → 0.11.1

package/src/skills/database/operations/schema-add.test.ts

@@ -0,0 +1,79 @@
+//
+// 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, JsonSchema, Query, Scope, Type } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { EntityId } from '@dxos/keys';
+
+import { OperationTestLayer } from '../../../testing';
+import { SchemaAdd } from './definitions';
+
+EntityId.dangerouslyDisableRandomness();
+
+// A representative draft-07 JSON Schema as a model would emit for the `add-schema` tool.
+const PROJECT_JSON_SCHEMA = {
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  type: 'object',
+  title: 'Project',
+  properties: {
+    name: { type: 'string' },
+    description: { type: 'string' },
+    status: { type: 'string' },
+  },
+  required: ['name'],
+};
+
+describe('SchemaAdd', () => {
+  it.effect(
+    'schema-add: requires jsonSchema to be an object',
+    Effect.fnUntraced(function* (_) {
+      // The tool parameter is typed as an object so the model emits the JSON Schema as an object.
+      // An unconstrained parameter let some models emit a JSON-encoded string, which then corrupted
+      // the created type; a non-object is now rejected at the tool-call boundary.
+      const decode = Schema.decodeUnknown(SchemaAdd.input);
+      const base = { name: 'Project', typename: 'com.example.type.project' };
+
+      const fromObject = yield* decode({ ...base, jsonSchema: PROJECT_JSON_SCHEMA });
+      expect(fromObject.jsonSchema).toEqual(PROJECT_JSON_SCHEMA);
+
+      const fromString = yield* Effect.either(decode({ ...base, jsonSchema: JSON.stringify(PROJECT_JSON_SCHEMA) }));
+      expect(fromString._tag).toBe('Left');
+    }),
+  );
+
+  it.effect(
+    'schema-add: creates a schema with the declared fields',
+    Effect.fnUntraced(
+      function* (_) {
+        // Run the handler and assert the created type carries the declared fields, not merely that a
+        // type with the typename exists.
+        yield* Operation.invoke(SchemaAdd, {
+          name: 'Project',
+          typename: 'com.example.type.project',
+          jsonSchema: PROJECT_JSON_SCHEMA,
+        });
+
+        const allTypes = yield* Database.query(
+          Query.select(Filter.type(Type.Type)).from(Scope.space(), Scope.registry()),
+        ).run;
+        const schemas = allTypes.filter((type) => Type.getTypename(type) === 'com.example.type.project');
+        expect(schemas).toHaveLength(1);
+        expectSchemaProperties(schemas[0], ['name', 'description', 'status']);
+      },
+      Effect.provide(OperationTestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});
+
+// Asserts that the type's JSON Schema declares (at least) the given property names.
+const expectSchemaProperties = (schema: Parameters<typeof JsonSchema.toJsonSchema>[0], expectedKeys: string[]) => {
+  const properties = JsonSchema.toJsonSchema(schema).properties ?? {};
+  expect(Object.keys(properties)).toEqual(expect.arrayContaining(expectedKeys));
+};

package/src/skills/database/operations/schema-list.test.ts

@@ -0,0 +1,42 @@
+//
+// 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, Skill } from '@dxos/compute';
+import { Feed, Type } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { EntityId } from '@dxos/keys';
+import { Employer, Organization, Person } from '@dxos/types';
+
+import { OperationTestLayer } from '../../../testing';
+import { SchemaList } from './definitions';
+
+EntityId.dangerouslyDisableRandomness();
+
+describe('SchemaList', () => {
+  it.effect(
+    'schema-list: lists registered types and omits the excluded ones',
+    Effect.fnUntraced(
+      function* (_) {
+        const schemas = yield* Operation.invoke(SchemaList, {});
+
+        const rows = yield* Schema.decodeUnknown(
+          Schema.Array(Schema.Struct({ typename: Schema.String, kind: Schema.String })),
+        )(schemas);
+        const typenames = rows.map((row) => row.typename);
+        expect(typenames).toContain(Type.getTypename(Organization.Organization));
+        expect(typenames).toContain(Type.getTypename(Person.Person));
+        // Skill and Feed are on the handler's exclusion list, which keeps them out of the agent's context.
+        expect(typenames).not.toContain(Type.getTypename(Skill.Skill));
+        expect(typenames).not.toContain(Type.getTypename(Feed.Feed));
+        expect(rows.find((row) => row.typename === Type.getTypename(Employer.Employer))?.kind).toBe('relation');
+      },
+      Effect.provide(OperationTestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});

package/src/skills/database/operations/tag-add.test.ts

@@ -0,0 +1,41 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+import { Database, Obj, Ref, Tag } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { EID, EntityId } from '@dxos/keys';
+import { Organization } from '@dxos/types';
+
+import { OperationTestLayer } from '../../../testing';
+import { TagAdd } from './definitions';
+
+EntityId.dangerouslyDisableRandomness();
+
+describe('TagAdd', () => {
+  it.effect(
+    'tag-add: attaches the tag to the object',
+    Effect.fnUntraced(
+      function* (_) {
+        const organization = yield* Database.add(Obj.make(Organization.Organization, { name: 'Tagged Corp' }));
+        const tag = yield* Database.add(Tag.make({ label: 'important' }));
+        yield* Database.flush();
+
+        yield* Operation.invoke(TagAdd, { tag: Ref.make(tag), obj: Ref.make(organization) });
+
+        expect(taggedIds(organization)).toContain(tag.id);
+      },
+      Effect.provide(OperationTestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});
+
+// Compare by entity id: a same-space ref stores a local EID (`echo:/<id>`) while `Obj.getURI`
+// returns the fully-qualified form (`echo://<space>/<id>`).
+const taggedIds = (obj: Obj.Any): (string | undefined)[] =>
+  Obj.getMeta(obj).tags.map((ref) => EID.getEntityId(EID.parse(ref.uri)));

package/src/skills/database/operations/tag-remove.test.ts

@@ -0,0 +1,43 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+import { Database, Obj, Ref, Tag } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { EID, EntityId } from '@dxos/keys';
+import { Organization } from '@dxos/types';
+
+import { OperationTestLayer } from '../../../testing';
+import { TagAdd, TagRemove } from './definitions';
+
+EntityId.dangerouslyDisableRandomness();
+
+describe('TagRemove', () => {
+  it.effect(
+    'tag-remove: detaches the tag from the object',
+    Effect.fnUntraced(
+      function* (_) {
+        const organization = yield* Database.add(Obj.make(Organization.Organization, { name: 'Tagged Corp' }));
+        const tag = yield* Database.add(Tag.make({ label: 'important' }));
+        yield* Database.flush();
+        yield* Operation.invoke(TagAdd, { tag: Ref.make(tag), obj: Ref.make(organization) });
+        expect(taggedIds(organization)).toContain(tag.id);
+
+        yield* Operation.invoke(TagRemove, { tag: Ref.make(tag), obj: Ref.make(organization) });
+
+        expect(taggedIds(organization)).not.toContain(tag.id);
+      },
+      Effect.provide(OperationTestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});
+
+// Compare by entity id: a same-space ref stores a local EID (`echo:/<id>`) while `Obj.getURI`
+// returns the fully-qualified form (`echo://<space>/<id>`).
+const taggedIds = (obj: Obj.Any): (string | undefined)[] =>
+  Obj.getMeta(obj).tags.map((ref) => EID.getEntityId(EID.parse(ref.uri)));

package/src/skills/delegation/operations/delegate-task.test.ts

@@ -5,14 +5,16 @@
 import { describe, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 
+import { AssistantTestLayer } from '@dxos/agent-runtime/testing';
 import { Operation, Skill } from '@dxos/compute';
-import { Database, Feed, Obj } from '@dxos/echo';
+import { Database, Feed, Filter, Obj, Query } 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, Task, TaskSet } from '@dxos/types';
 
-import { Agent, Chat, Plan } from '../../../types';
+import { Agent, Chat } from '../../../types';
 import DelegationSkill from '../skill';
 import { DelegateTask } from './delegate-task';
 import { DelegationHandlers } from './index';
@@ -21,19 +23,29 @@ EntityId.dangerouslyDisableRandomness();
 
 const TestLayer = AssistantTestLayer({
   operationHandlers: DelegationHandlers,
-  types: [Agent.Agent, Plan.Plan, Chat.Chat, Chat.CompanionTo, Skill.Skill, Feed.Feed],
+  types: [
+    Agent.Agent,
+    Outline.Outline,
+    Task.Task,
+    TaskSet.TaskSet,
+    Text.Text,
+    Chat.Chat,
+    Chat.CompanionTo,
+    Skill.Skill,
+    Feed.Feed,
+  ],
   skills: [DelegationSkill.make()],
   disableLlmMemoization: true,
 });
 
-const invokeDelegateTask = (input: { id?: Plan.TaskId; title?: string }, chatFeed: Feed.Feed) =>
+const invokeDelegateTask = (input: { title: string }, chatFeed: Feed.Feed) =>
   Operation.invoke(DelegateTask, input).pipe(
     Effect.provide(Operation.withInvocationOptions({ conversation: Obj.getURI(chatFeed) })),
   );
 
 describe('DelegateTask', () => {
   it.scoped(
-    'adds an in-progress task to the agent plan for delegated work',
+    'promotes delegated work to a durable in-progress agent task',
     Effect.fnUntraced(
       function* ({ expect }) {
         const agent = yield* Agent.makeInitialized(
@@ -42,19 +54,29 @@ describe('DelegateTask', () => {
         );
         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* invokeDelegateTask({ title: 'Research widgets' }, chatFeed);
 
-        const chat = yield* Database.load(agent.chat!);
-        const plan = yield* Database.load(chat.plan!);
-        expect(plan.tasks).toHaveLength(1);
-        expect(plan.tasks[0]).toMatchObject({
+        // The durable task is parented to the outline's task set with an agent assignee.
+        const chat = yield* Agent.loadChat(agent);
+        invariant(chat, 'Agent chat not found.');
+        const outline = yield* Database.load(chat.outline!);
+        const taskSet = yield* Database.load(outline.taskSet!);
+        const children = yield* Database.query(Query.select(Filter.id(taskSet.id)).children()).run;
+        const tasks = children.filter((child): child is Task.Task => Obj.instanceOf(Task.Task, child));
+        expect(tasks).toHaveLength(1);
+        expect(tasks[0]).toMatchObject({
           title: 'Research widgets',
           status: 'in-progress',
-          delegated: true,
+          assignee: { role: 'assistant' },
         });
+
+        // The checklist mirrors the item, unchecked until the sub-agent completes.
+        const text = yield* Database.load(outline.content);
+        expect(Outline.parseChecklist(text.content)).toEqual([{ title: 'Research widgets', done: false }]);
       },
       Effect.provide(TestLayer),
       TestHelpers.provideTestContext,
@@ -62,35 +84,29 @@ describe('DelegateTask', () => {
   );
 
   it.scoped(
-    'delegates an existing plan task by id without duplicating',
+    'reuses the outline task set across delegations',
     Effect.fnUntraced(
       function* ({ expect }) {
         const agent = yield* Agent.makeInitialized(
           { name: 'Supervisor', instructions: 'Test.' },
           DelegationSkill.make(),
         );
-        const chat = yield* Database.load(agent.chat!);
-        const plan = yield* Chat.ensurePlan(chat);
-        const taskId = Plan.TaskId.make('1-ab');
-        Obj.update(plan, (plan) => {
-          plan.tasks.push({ id: taskId, title: 'Research widgets', status: 'todo' });
-        });
         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* invokeDelegateTask({ id: taskId }, chatFeed);
-
-        const updatedChat = yield* Database.load(agent.chat!);
-        const updated = yield* Database.load(updatedChat.plan!);
-        expect(updated.tasks).toHaveLength(1);
-        expect(updated.tasks[0]).toMatchObject({
-          id: taskId,
-          title: 'Research widgets',
-          status: 'in-progress',
-          delegated: true,
-        });
+        yield* invokeDelegateTask({ title: 'Research widgets' }, chatFeed);
+        yield* invokeDelegateTask({ title: 'Summarize findings' }, chatFeed);
+
+        const chat = yield* Agent.loadChat(agent);
+        invariant(chat, 'Agent chat not found.');
+        const outline = yield* Database.load(chat.outline!);
+        const taskSet = yield* Database.load(outline.taskSet!);
+        const children = yield* Database.query(Query.select(Filter.id(taskSet.id)).children()).run;
+        const tasks = children.filter((child): child is Task.Task => Obj.instanceOf(Task.Task, child));
+        expect(tasks).toHaveLength(2);
       },
       Effect.provide(TestLayer),
       TestHelpers.provideTestContext,
@@ -98,7 +114,7 @@ describe('DelegateTask', () => {
   );
 
   it.scoped(
-    'fails when both id and title are provided',
+    'fails on an empty title',
     Effect.fnUntraced(
       function* ({ expect }) {
         const agent = yield* Agent.makeInitialized(
@@ -107,12 +123,11 @@ describe('DelegateTask', () => {
         );
         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.');
 
-        const exit = yield* invokeDelegateTask({ id: Plan.TaskId.make('1-ab'), title: 'New task' }, chatFeed).pipe(
-          Effect.exit,
-        );
+        const exit = yield* invokeDelegateTask({ title: '' }, chatFeed).pipe(Effect.exit);
         expect(exit._tag).toBe('Failure');
       },
       Effect.provide(TestLayer),

package/src/skills/delegation/operations/delegate-task.ts

@@ -9,9 +9,10 @@ import { Harness } from '@dxos/assistant';
 import { Operation } from '@dxos/compute';
 import { Database, Obj } from '@dxos/echo';
 import { DXN } from '@dxos/keys';
+import { Outline } from '@dxos/types';
 import { trim } from '@dxos/util';
 
-import { Chat, Plan } from '../../../types';
+import { Chat } from '../../../types';
 
 export const DelegateTask = Operation.make({
   meta: {
@@ -19,17 +20,14 @@ export const DelegateTask = Operation.make({
     name: 'Delegate task',
     description: trim`
       Delegate a unit of work to a sub-agent.
-      Provide either \`id\` (an existing plan task from update-tasks) or \`title\` (to create a new task).
-      Marks the task in-progress and delegated so the supervisor spawns a background sub-agent.
+      Promotes the titled checklist item to a durable in-progress task assigned to an agent, so
+      the supervisor spawns a background sub-agent. Creates the checklist item if absent.
     `,
     icon: 'ph--share-network--regular',
   },
   input: Schema.Struct({
-    id: Schema.optional(Plan.TaskId).annotations({
-      description: 'Id of an existing plan task to delegate (from update-tasks).',
-    }),
-    title: Schema.optional(Schema.String).annotations({
-      description: 'Title for a new task to create and delegate. Omit when delegating by id.',
+    title: Schema.String.annotations({
+      description: 'Title of the work to delegate (matched against the checklist, created if new).',
     }),
   }),
   output: Schema.Any,
@@ -37,56 +35,41 @@ export const DelegateTask = Operation.make({
 });
 
 /**
- * Records delegated work as an in-progress task on the current session plan.
+ * Delegation is the promotion moment: the scratch checklist item becomes a durable `Task`
+ * (parented to the outline's task set) assigned to an agent (`role: 'assistant'`), which the
+ * supervisor's reconcile loop picks up. The markdown line is checked off only when the sub-agent
+ * completes (see the delegation strategy).
  */
 export default DelegateTask.pipe(
   Operation.withHandler(
-    Effect.fn(function* ({ id, title }) {
-      const hasId = id !== undefined;
-      const hasTitle = title !== undefined && title.length > 0;
-      if (hasId === hasTitle) {
-        return yield* Effect.fail(
-          new Error('Provide exactly one of `id` (existing plan task) or `title` (new task to create).'),
-        );
+    Effect.fn(function* ({ title }) {
+      if (title.length === 0) {
+        return yield* Effect.fail(new Error('Provide a non-empty task title.'));
       }
 
       const chat = yield* Chat.getFromContext;
-      const plan = yield* Chat.ensurePlan(chat);
+      const { outline, text } = yield* Chat.ensureOutlineText(chat);
+      const { db } = yield* Database.Service;
 
-      if (hasId) {
-        const existing = plan.tasks.find((task) => task.id === id);
-        if (!existing) {
-          return yield* Effect.fail(new Error(`Plan task not found: ${id}`));
-        }
-        if (existing.status === 'done' || existing.status === 'failed') {
-          return yield* Effect.fail(
-            new Error(`Plan task "${id}" is already ${existing.status} and cannot be delegated.`),
-          );
-        }
+      const task = yield* Effect.promise(() =>
+        Outline.createTask(outline, db, title, {
+          status: 'in-progress',
+          assignee: { role: 'assistant' },
+        }),
+      );
 
-        Obj.update(plan, (plan) => {
-          const task = plan.tasks.find((task) => task.id === id);
-          if (task) {
-            task.delegated = true;
-            task.status = 'in-progress';
-          }
-        });
-      } else {
-        if (title === undefined) {
-          return yield* Effect.fail(
-            new Error('Provide exactly one of `id` (existing plan task) or `title` (new task to create).'),
-          );
-        }
-        Obj.update(plan, (plan) => {
-          Plan.addTasks(plan, [{ title, status: 'in-progress', delegated: true }]);
-        });
-      }
+      // Ensure the checklist carries the item (unchecked until the sub-agent completes).
+      Obj.update(text, (text) => {
+        text.content = Outline.upsertChecklistItems(text.content, [{ title: task.title, done: false }]);
+      });
+      yield* Database.flush();
 
       return trim`
-        Delegated work as an in-progress task. Current plan:
-        <plan>
-          ${Plan.formatPlan(plan)}
-        </plan>
+        Delegated "${task.title}" as an in-progress agent task (id: ${task.id}).
+        Current checklist:
+        <checklist>
+          ${text.content}
+        </checklist>
       `;
     }),
   ),

package/src/skills/discord/operations/fetch-messages.test.ts

@@ -8,10 +8,10 @@ import * as Config from 'effect/Config';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
+import { AssistantTestLayer } from '@dxos/agent-runtime/testing';
 import { Operation, OperationHandlerSet } from '@dxos/compute';
+import { credentialsLayerConfig } from '@dxos/compute-runtime';
 import { TestHelpers } from '@dxos/effect/testing';
-import { credentialsLayerConfig } from '@dxos/functions';
-import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 
 import { default as fetchMessages } from './fetch-messages';
 

package/src/skills/github/operations/fetch-prs.ts

@@ -6,7 +6,7 @@ import * as HttpClient from '@effect/platform/HttpClient';
 import * as Effect from 'effect/Effect';
 
 import { Credential, Operation } from '@dxos/compute';
-import { withAuthorization } from '@dxos/functions';
+import { withAuthorization } from '@dxos/compute-runtime';
 
 import { FetchPrs } from './definitions';
 

package/src/skills/index.ts

@@ -15,4 +15,5 @@ export * from './discord';
 export * from './linear';
 export * from './memory';
 export * from './planning';
+export * from './project';
 export * from './websearch';

package/src/skills/linear/operations/linear.test.ts

@@ -5,10 +5,10 @@
 import { describe, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 
+import { AssistantTestLayer } from '@dxos/agent-runtime/testing';
 import { Operation, OperationHandlerSet } from '@dxos/compute';
 import { Database, Obj, Query } from '@dxos/echo';
 import { TestHelpers } from '@dxos/effect/testing';
-import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 import { Person, Pipeline, Task } from '@dxos/types';
 
 import { LINEAR_ID_KEY, default as fetchLinearIssues } from './sync-issues';

package/src/skills/linear/operations/sync-issues.ts

@@ -9,10 +9,10 @@ import * as Effect from 'effect/Effect';
 import * as Function from 'effect/Function';
 
 import { Credential, Operation } from '@dxos/compute';
+import { withAuthorization } from '@dxos/compute-runtime';
 import { Database, Filter, Obj, Query, Ref, type Type } from '@dxos/echo';
-import { withAuthorization } from '@dxos/functions';
 import { log } from '@dxos/log';
-import { Person, Pipeline, Task } from '@dxos/types';
+import { Person, Task } from '@dxos/types';
 
 import { syncObjects } from '../../../sync';
 import { graphqlRequestBody } from '../../../util';
@@ -156,27 +156,10 @@ const mapLinearIssue = (issue: LinearIssue, { teamId }: { teamId: string }): Tas
     },
     title: issue.title ?? undefined,
     description: issue.description ?? undefined,
-    assigned: !issue.assignee ? undefined : Ref.make(mapLinearPerson(issue.assignee, { teamId })),
+    assignee: !issue.assignee ? undefined : { contact: Ref.make(mapLinearPerson(issue.assignee, { teamId })) },
     // TODO(dmaretskyi): Sync those (+ linear team as org?).
     // state: issue.state.name,
-
-    project: !issue.project
-      ? undefined
-      : Ref.make(
-          Pipeline.make({
-            [Obj.Meta]: {
-              keys: [
-                {
-                  id: issue.project.id,
-                  source: LINEAR_ID_KEY,
-                },
-                {
-                  id: teamId,
-                  source: LINEAR_TEAM_ID_KEY,
-                },
-              ],
-            },
-            name: issue.project.name,
-          }),
-        ),
+    // Container membership (TaskSet parent edge) is not mapped here: `syncObjects` upserts
+    // detached objects, and parent edges need persisted objects — plugin-linear's sync owns
+    // real project mirroring.
   });

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

@@ -0,0 +1,37 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+import { Database, Filter, Obj, Query, Ref } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { EntityId } from '@dxos/keys';
+
+import { OperationTestLayer } from '../../../testing';
+import { Memory } from '../../../types/Memory';
+import { DeleteMemory } from './definitions';
+
+EntityId.dangerouslyDisableRandomness();
+
+describe('DeleteMemory', () => {
+  it.effect(
+    'removes the memory from the database',
+    Effect.fnUntraced(
+      function* (_) {
+        const memory = yield* Database.add(Obj.make(Memory, { title: 'Outdated fact', content: 'Stale.' }));
+        const kept = yield* Database.add(Obj.make(Memory, { title: 'Current fact', content: 'Fresh.' }));
+        yield* Database.flush();
+
+        yield* Operation.invoke(DeleteMemory, { memory: Ref.make(memory) });
+
+        const memories = yield* Database.query(Query.select(Filter.type(Memory))).run;
+        expect(memories.map((entry) => entry.id)).toEqual([kept.id]);
+      },
+      Effect.provide(OperationTestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});