@dxos/assistant-toolkit 0.9.1-main.c7dcc2e112 → 0.10.0

package/src/{blueprints/memory/blueprint.test.ts → skills/memory/skill.test.ts}

@@ -7,7 +7,7 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
 import { OpaqueToolkit } from '@dxos/ai';
-import { Blueprint } from '@dxos/compute';
+import { Skill } from '@dxos/compute';
 import { Database, Feed, Filter, Obj, Query } from '@dxos/echo';
 import { TestHelpers } from '@dxos/effect/testing';
 import { AgentService } from '@dxos/functions-runtime';
@@ -16,33 +16,33 @@ import { EntityId } from '@dxos/keys';
 
 import { Memory } from '../../types/Memory';
 import { WebSearchToolkit } from '../websearch';
-import MemoryBlueprint from './blueprint';
 import { MemoryHandlers } from './operations';
+import MemorySkill from './skill';
 
 EntityId.dangerouslyDisableRandomness();
 
 const TestLayer = AssistantTestLayer({
   operationHandlers: MemoryHandlers,
-  types: [Memory, Blueprint.Blueprint, Feed.Feed],
-  blueprints: [MemoryBlueprint.make()],
+  types: [Memory, Skill.Skill, Feed.Feed],
+  skills: [MemorySkill.make()],
   tracing: 'pretty',
 });
 
 const TestLayerWithWebSearch = AssistantTestLayer({
   operationHandlers: MemoryHandlers,
   toolkits: [OpaqueToolkit.make(WebSearchToolkit, Layer.empty)],
-  types: [Memory, Blueprint.Blueprint, Feed.Feed],
-  blueprints: [MemoryBlueprint.make()],
+  types: [Memory, Skill.Skill, Feed.Feed],
+  skills: [MemorySkill.make()],
   tracing: 'pretty',
 });
 
-describe('Memory Blueprint', () => {
+describe('Memory Skill', () => {
   it.effect(
     'save: saves a memory',
     Effect.fnUntraced(
       function* (_) {
         const agent = yield* AgentService.createSession({
-          blueprints: [MemoryBlueprint.make()],
+          skills: [MemorySkill.make()],
         });
         yield* agent.submitPrompt('Remember that my favorite programming language is TypeScript.');
         yield* agent.waitForCompletion();
@@ -72,7 +72,7 @@ describe('Memory Blueprint', () => {
           }),
         );
         const agent = yield* AgentService.createSession({
-          blueprints: [MemoryBlueprint.make()],
+          skills: [MemorySkill.make()],
         });
         yield* agent.submitPrompt('Search your memories for anything about colors.');
         yield* agent.waitForCompletion();
@@ -94,7 +94,7 @@ describe('Memory Blueprint', () => {
           }),
         );
         const agent = yield* AgentService.createSession({
-          blueprints: [MemoryBlueprint.make()],
+          skills: [MemorySkill.make()],
         });
         yield* agent.submitPrompt('Delete the memory about "Outdated fact".');
         yield* agent.waitForCompletion();
@@ -114,7 +114,7 @@ describe('Memory Blueprint', () => {
     Effect.fnUntraced(
       function* (_) {
         const agent = yield* AgentService.createSession({
-          blueprints: [MemoryBlueprint.make()],
+          skills: [MemorySkill.make()],
         });
         yield* agent.submitPrompt(
           "I'm going to LA next week. Find me some good hotels and remember the recommendations.",

package/src/{blueprints/memory/blueprint.ts → skills/memory/skill.ts}

@@ -2,14 +2,14 @@
 // Copyright 2026 DXOS.org
 //
 
-import { Blueprint } from '@dxos/compute';
+import { Skill } from '@dxos/compute';
 import { Ref } from '@dxos/echo';
 import { Text } from '@dxos/schema';
 import { trim } from '@dxos/util';
 
-import { QueryMemories, SaveMemory, DeleteMemory } from './operations/definitions';
+import { DeleteMemory, QueryMemories, SaveMemory } from './operations/definitions';
 
-const BLUEPRINT_KEY = 'org.dxos.blueprint.memory';
+const SKILL_KEY = 'org.dxos.skill.memory';
 
 const instructions = trim`
   You have the ability to save and recall memories.
@@ -22,20 +22,20 @@ const instructions = trim`
 `;
 
 const make = () =>
-  Blueprint.make({
-    key: BLUEPRINT_KEY,
+  Skill.make({
+    key: SKILL_KEY,
     name: 'Memory',
     description: 'Persistent memory storage and retrieval.',
     agentCanEnable: true,
     instructions: {
       source: Ref.make(Text.make({ content: instructions })),
     },
-    tools: Blueprint.toolDefinitions({ operations: [SaveMemory, QueryMemories, DeleteMemory] }),
+    tools: Skill.toolDefinitions({ operations: [SaveMemory, QueryMemories, DeleteMemory] }),
   });
 
-const blueprint: Blueprint.Definition = {
-  key: BLUEPRINT_KEY,
+const skill: Skill.Definition = {
+  key: SKILL_KEY,
   make,
 };
 
-export default blueprint;
+export default skill;

package/src/{blueprints → skills}/planning/index.ts

@@ -2,5 +2,5 @@
 // Copyright 2026 DXOS.org
 //
 
-export { default as PlanningBlueprint } from './blueprint';
+export { default as PlanningSkill } from './skill';
 export { PlanningHandlers, PlanningOperations } from './operations';

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

@@ -0,0 +1,44 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { AiService } from '@dxos/ai';
+import { Harness } from '@dxos/assistant';
+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');
+
+export const UpdateTasks = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.function.planning.updateTasks'),
+    name: 'Update tasks',
+    description: INSTRUCTIONS,
+    icon: 'ph--check-square-offset--regular',
+  },
+  input: Schema.Struct({
+    tasks: Schema.Array(SimpleTask),
+  }),
+  output: Schema.Any,
+  services: [Harness.HarnessService, Database.Service],
+});
+
+export const PlanReminder = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.function.planning.planReminder'),
+    name: 'Plan reminder',
+    description: 'Reminds the agent to continue when its plan still has incomplete tasks.',
+  },
+  input: Schema.Struct({}),
+  output: Schema.Void,
+  services: [Harness.HarnessService, Database.Service, AiService.AiService],
+});

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

@@ -0,0 +1,12 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/compute';
+
+export * as PlanningOperations from './definitions';
+
+export const PlanningHandlers = OperationHandlerSet.lazy(
+  () => import('./update-tasks'),
+  () => import('./plan-reminder'),
+);

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

@@ -0,0 +1,98 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as LanguageModel from '@effect/ai/LanguageModel';
+import * as Prompt from '@effect/ai/Prompt';
+import * as Effect from 'effect/Effect';
+
+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 { trim } from '@dxos/util';
+
+import { Chat, Plan } 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.
+ */
+export default PlanReminder.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(
+      function* () {
+        const chat = yield* Chat.getFromContext.pipe(Effect.orElseSucceed(() => undefined));
+        if (!chat) {
+          return;
+        }
+        if (!chat?.plan) {
+          return;
+        }
+        const plan = yield* Database.load(chat.plan).pipe(Effect.orElseSucceed(() => undefined));
+        if (!plan || !Plan.hasIncompleteTasks(plan)) {
+          return;
+        }
+
+        const history = yield* Harness.history;
+        const prompt = Prompt.merge(
+          yield* AiPreprocessor.preprocessPrompt(history, { system: planCompletionCheckSystem }),
+          planCompletionCheckPrompt(plan),
+        );
+        const { text } = yield* Effect.scoped(LanguageModel.generateText({ prompt }));
+
+        if (!parseContinueDecision(text)) {
+          return;
+        }
+
+        yield* Harness.enqueueMessage({
+          content: [ContentBlock.Text.make({ text: planContinueReminderPrompt(plan), disposition: 'synthetic' })],
+        });
+      },
+      Effect.provide(AiService.model('com.anthropic.model.claude-sonnet-4-6.default')),
+    ),
+  ),
+);
+
+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.
+  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:
+
+  <plan>
+  ${Plan.formatPlan(plan)}
+  </plan>
+
+  Should the agent STOP now (no more work needed) or CONTINUE working on the plan?
+  Reply with exactly one word: "stop" or "continue".
+`;
+
+/** Prefer an explicit "continue"; treat ambiguous replies as continue so open plan work is not dropped. */
+const parseContinueDecision = (reply: string): boolean => {
+  const normalized = reply.toLowerCase();
+  if (/\bcontinue\b/.test(normalized)) {
+    return true;
+  }
+  if (/\bstop\b/.test(normalized)) {
+    return false;
+  }
+  return true;
+};
+
+const planContinueReminderPrompt = (plan: Plan.Plan): string => trim`
+  Your plan still has incomplete tasks — continue working before finishing:
+
+  <plan>
+  ${Plan.formatPlan(plan)}
+  </plan>
+`;

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

@@ -0,0 +1,79 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+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 { Agent, Chat, Plan } from '../../../types';
+import PlanningSkill from '../skill';
+import { UpdateTasks } from './definitions';
+import { PlanningHandlers } from './index';
+
+EntityId.dangerouslyDisableRandomness();
+
+const TestLayer = AssistantTestLayer({
+  operationHandlers: PlanningHandlers,
+  types: [Agent.Agent, Plan.Plan, Chat.Chat, Chat.CompanionTo, Skill.Skill, Feed.Feed],
+  skills: [PlanningSkill.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.' }, PlanningSkill.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.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' });
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.scoped(
+    'adds tasks to the plan without an agent',
+    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();
+        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' }],
+        }).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' });
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});

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

@@ -0,0 +1,51 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
+import { trim } from '@dxos/util';
+
+import { Chat, Plan } from '../../../types';
+import { UpdateTasks } from './definitions';
+
+/**
+ * Updates the planning document (Chat.plan) with the given tasks.
+ */
+export default UpdateTasks.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ tasks: newTasks }) {
+      const chat = yield* Chat.getFromContext;
+      // TODO(burdon): How to specify requirements/preconditions before calling?
+      // TODO(burdon): How to report non-technical error?
+      const plan = yield* Chat.ensurePlan(chat);
+
+      Obj.update(plan, (plan) => {
+        for (const task of newTasks) {
+          const existingTask = plan.tasks.find((t) => t.id === task.id);
+          if (existingTask) {
+            existingTask.title = task.title;
+            existingTask.status = task.status;
+          } else {
+            plan.tasks.push({
+              id: task.id,
+              title: task.title,
+              status: task.status,
+            });
+          }
+        }
+      });
+
+      return trim`
+        You must update the task status to 'in-progress' when you start and 'done' when complete.
+        Current plan updated:
+        <plan>
+          ${Plan.formatPlan(plan)}
+        </plan>
+      `;
+    }),
+  ),
+  Operation.opaqueHandler,
+);

package/src/skills/planning/skill.conversations.json

@@ -0,0 +1 @@
+{"conversations":[{"parameters":{"model":"dxn:com.anthropic.model.claudeSonnet46","stream":false,"tools":[]},"prompt":{"content":[{"role":"system","content":"You decide whether an agent should stop or continue working on its plan, given the conversation\nso far and the agent's remaining plan tasks.\nReply with exactly one word: \"stop\" or \"continue\". Do not use tools. Do not add explanation.","options":{}},{"role":"user","content":"The agent is about to finish, but its plan still has incomplete tasks:\n\n<plan>\n- **TODO**: Buy eggs <!-- id=task-1 -->\n- **IN-PROGRESS**: Crack eggs <!-- id=task-2 -->\n</plan>\n\nShould the agent STOP now (no more work needed) or CONTINUE working on the plan?\nReply with exactly one word: \"stop\" or \"continue\".","options":{}}]},"response":[{"type":"response-metadata","id":"msg_015FvDvL8TEw6YqGBNLs8yRs","modelId":"claude-sonnet-4-5-20250929","timestamp":"1970-01-01T00:00:00.000Z","metadata":{}},{"type":"text","text":"continue","metadata":{}},{"type":"finish","reason":"stop","usage":{"inputTokens":151,"outputTokens":4,"totalTokens":155,"cachedInputTokens":0},"metadata":{"anthropic":{"usage":{"cache_creation":{"ephemeral_1h_input_tokens":0,"ephemeral_5m_input_tokens":0},"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"input_tokens":151,"output_tokens":4,"server_tool_use":null,"service_tier":"standard"}}}}]},{"parameters":{"model":"dxn:com.anthropic.model.claude-sonnet-4-6.default","stream":false,"tools":[]},"prompt":{"content":[{"role":"system","content":"You decide whether an agent should stop or continue working on its plan, given the conversation\nso far and the agent's remaining plan tasks.\nReply with exactly one word: \"stop\" or \"continue\". Do not use tools. Do not add explanation.","options":{}},{"role":"user","content":"The agent is about to finish, but its plan still has incomplete tasks:\n\n<plan>\n- **TODO**: Buy eggs <!-- id=task-1 -->\n- **IN-PROGRESS**: Crack eggs <!-- id=task-2 -->\n</plan>\n\nShould the agent STOP now (no more work needed) or CONTINUE working on the plan?\nReply with exactly one word: \"stop\" or \"continue\".","options":{}}]},"response":[{"type":"response-metadata","id":"msg_01NSkcUieedKCREEajLSJWYs","modelId":"claude-sonnet-4-6","timestamp":"1970-01-01T00:00:00.000Z","metadata":{}},{"type":"text","text":"continue","metadata":{}},{"type":"finish","reason":"stop","usage":{"inputTokens":152,"outputTokens":4,"totalTokens":156,"cachedInputTokens":0},"metadata":{"anthropic":{"usage":{"cache_creation":{"ephemeral_1h_input_tokens":0,"ephemeral_5m_input_tokens":0},"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"input_tokens":152,"output_tokens":4,"server_tool_use":null,"service_tier":"standard"}}}}]}]}

package/src/skills/planning/skill.test.ts

@@ -0,0 +1,123 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, it, test } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { Operation, Process, Skill } from '@dxos/compute';
+import { ProcessManager } from '@dxos/compute-runtime';
+import { getSession } from '@dxos/compute/AgentService';
+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 { EntityId } from '@dxos/keys';
+
+import { Agent, Chat, Plan } from '../../types';
+import { PlanningHandlers, PlanningOperations } from './operations';
+import PlanningSkill from './skill';
+
+EntityId.dangerouslyDisableRandomness();
+
+const TestLayer = AssistantTestLayer({
+  operationHandlers: PlanningHandlers,
+  types: [Agent.Agent, Plan.Plan, Chat.Chat, Chat.CompanionTo, Skill.Skill, Feed.Feed],
+  skills: [PlanningSkill.make()],
+});
+
+describe('Planning skill', () => {
+  // The hook fires the plan-reminder operation only while the plan has open tasks; cover that
+  // predicate directly so the branch is verified without an agent turn.
+  describe('hasIncompleteTasks', () => {
+    test('is true while any task is todo or in-progress', ({ expect }) => {
+      expect(Plan.hasIncompleteTasks(makePlan(['todo']))).toBe(true);
+      expect(Plan.hasIncompleteTasks(makePlan(['done', 'in-progress']))).toBe(true);
+    });
+
+    test('is false when every task is done', ({ expect }) => {
+      expect(Plan.hasIncompleteTasks(makePlan(['done', 'done']))).toBe(false);
+      expect(Plan.hasIncompleteTasks(makePlan([]))).toBe(false);
+    });
+  });
+
+  // The end-request hook reads the plan (Tier A), runs an ephemeral stop/continue check over the
+  // conversation history (LanguageModel, memoized), and on "continue" reaches the live host through
+  // HarnessService Tier B (like the alarm skill's set-alarm) to enqueue a reminder. Spawning a
+  // host on the agent's chat feed and invoking the operation against that conversation dispatches
+  // over the process RPC loopback; the host staying live proves the read, the check, and the enqueue
+  // resolved end-to-end without failing the process.
+  describe('plan-reminder hook (end-request, Tier B)', () => {
+    it.scoped(
+      'enqueues a continuation reminder when the plan has incomplete tasks',
+      Effect.fnUntraced(
+        function* ({ expect }) {
+          const { conversation, host } = yield* setupAgentWithLiveHost([
+            { id: Plan.TaskId.make('task-1'), title: 'Buy eggs', status: 'todo' },
+            { id: Plan.TaskId.make('task-2'), title: 'Crack eggs', status: 'in-progress' },
+          ]);
+
+          yield* Operation.invoke(PlanningOperations.PlanReminder, {}).pipe(
+            Effect.provide(Operation.withInvocationOptions({ conversation })),
+          );
+
+          expect(host.status.state).not.toBe(Process.State.FAILED);
+          expect(host.status.state).not.toBe(Process.State.TERMINATED);
+        },
+        Effect.provide(TestLayer),
+        TestHelpers.provideTestContext,
+      ),
+    );
+
+    it.scoped(
+      'is a no-op when the plan is complete',
+      Effect.fnUntraced(
+        function* ({ expect }) {
+          const { conversation, host } = yield* setupAgentWithLiveHost([
+            { id: Plan.TaskId.make('task-1'), title: 'Buy eggs', status: 'done' },
+          ]);
+
+          yield* Operation.invoke(PlanningOperations.PlanReminder, {}).pipe(
+            Effect.provide(Operation.withInvocationOptions({ conversation })),
+          );
+
+          expect(host.status.state).not.toBe(Process.State.FAILED);
+          expect(host.status.state).not.toBe(Process.State.TERMINATED);
+        },
+        Effect.provide(TestLayer),
+        TestHelpers.provideTestContext,
+      ),
+    );
+  });
+});
+
+const makePlan = (statuses: readonly Plan.TaskStatus[]): Plan.Plan =>
+  Plan.makePlan({ tasks: statuses.map((status, index) => ({ title: `Task ${index}`, status })) });
+
+/**
+ * Creates an agent (with the planning skill and a seeded plan) bound to its chat feed, then
+ * spawns a live host process on that feed so HarnessService Tier B is reachable for the conversation.
+ */
+const setupAgentWithLiveHost = (tasks: readonly Plan.Task[]) =>
+  Effect.gen(function* () {
+    const agent = yield* Agent.makeInitialized({ name: 'Planner', instructions: 'Test.' }, PlanningSkill.make());
+    const chat = yield* Database.load(agent.chat!);
+    const plan = yield* Chat.ensurePlan(chat);
+    Obj.update(plan, (plan) => {
+      plan.tasks.push(...tasks);
+    });
+    yield* Database.flush();
+
+    const chatFeed = agent.chat?.target?.feed?.target;
+    invariant(chatFeed, 'Agent chat feed not found.');
+
+    // Spawns (and stamps) the host process that owns the conversation's harness.
+    yield* getSession(chatFeed);
+
+    const conversation = Obj.getURI(chatFeed);
+    const processManager = yield* ProcessManager.Service;
+    const [host] = yield* processManager.list({ target: conversation });
+    invariant(host, 'Host process not found.');
+
+    return { conversation, host };
+  });

package/src/skills/planning/skill.ts

@@ -0,0 +1,34 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Operation, Skill } from '@dxos/compute';
+import { Ref } from '@dxos/echo';
+
+import { PlanReminder, UpdateTasks } from './operations/definitions';
+
+const SKILL_KEY = 'org.dxos.skill.planning';
+
+const make = () =>
+  Skill.make({
+    key: SKILL_KEY,
+    name: 'Planning',
+    description: 'Plans and tracks complex tasks using artifacts.',
+    agentCanEnable: true,
+    tools: Skill.toolDefinitions({ operations: [UpdateTasks] }),
+    // At the end of every request, remind the agent to keep working while its plan has open tasks.
+    // The reminder enqueues onto the owning host (Tier B), which keeps the process alive.
+    hooks: [
+      {
+        spec: { _tag: 'end-request' },
+        function: Ref.make(Operation.serialize(PlanReminder)),
+      },
+    ],
+  });
+
+const skill: Skill.Definition = {
+  key: SKILL_KEY,
+  make,
+};
+
+export default skill;

package/src/skills/skill-manager/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export { default as SkillManagerSkill } from './skill';
+export { SkillManagerHandlers, SkillManagerOperations } from './operations';

package/src/skills/skill-manager/operations/definitions.ts

@@ -0,0 +1,48 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Harness } from '@dxos/assistant';
+import { Operation, Skill } from '@dxos/compute';
+import { Database, Registry, Type } from '@dxos/echo';
+import { DXN } from '@dxos/keys';
+
+export const QuerySkills = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.function.skillManager.querySkills'),
+    name: 'Query skills',
+    description: 'Queries available skills.',
+    icon: 'ph--blueprint--regular',
+  },
+  input: Schema.Struct({}),
+  output: Schema.Array(Type.getSchema(Skill.Skill)),
+  services: [Registry.Service],
+});
+
+export const EnableSkills = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.function.skillManager.enableSkills'),
+    name: 'Enable skills',
+    description:
+      'Enables skills in the current conversation by their keys. Only skills with agentCanEnable=true can be enabled. Always call [query-skills] first to discover available skill keys.',
+    icon: 'ph--plugs-connected--regular',
+  },
+  input: Schema.Struct({
+    keys: Schema.Array(Schema.String).annotations({
+      description: 'The keys of the skills to enable.',
+      examples: [['org.dxos.skill.memory', 'org.dxos.skill.database']],
+    }),
+  }),
+  output: Schema.Struct({
+    enabled: Schema.Array(Type.getSchema(Skill.Skill)),
+    rejected: Schema.Array(
+      Schema.Struct({
+        key: Schema.String,
+        reason: Schema.String,
+      }),
+    ),
+  }),
+  services: [Registry.Service, Database.Service, Harness.HarnessService],
+});