@dxos/assistant-toolkit 0.9.1-main.c7dcc2e112 → 0.9.1-staging.ee54ba693a

package/dist/lib/neutral/index.mjs

@@ -1,38 +1,44 @@
+import {
+  PlanReminder,
+  UpdateTasks,
+  definitions_exports as definitions_exports9
+} from "./chunk-3KA66YBF.mjs";
 import {
   Fetch,
-  definitions_exports as definitions_exports8
-} from "./chunk-FQNZX2SH.mjs";
+  definitions_exports as definitions_exports10
+} from "./chunk-KLFXJ2Z3.mjs";
 import {
-  AgentPrompt
-} from "./chunk-WTUY5UCA.mjs";
+  RunInstructions
+} from "./chunk-VJ5QBYM5.mjs";
 import {
   DelegateTask,
   delegate_task_exports
-} from "./chunk-ZA5WZL4H.mjs";
+} from "./chunk-JKOOA5OS.mjs";
 import {
   FetchMessages,
-  definitions_exports as definitions_exports5
-} from "./chunk-ZQDWSV26.mjs";
+  definitions_exports as definitions_exports6
+} from "./chunk-6SGNFL6I.mjs";
 import {
   SyncIssues,
-  definitions_exports as definitions_exports6,
+  definitions_exports as definitions_exports7,
   syncObjects
-} from "./chunk-24L572PJ.mjs";
+} from "./chunk-LL3MOQUZ.mjs";
 import {
   DeleteMemory,
   QueryMemories,
   SaveMemory,
-  definitions_exports as definitions_exports7
-} from "./chunk-DLVIJSH6.mjs";
-import {
-  UpdateTasks,
-  update_tasks_exports
-} from "./chunk-ABOAU3NN.mjs";
+  definitions_exports as definitions_exports8
+} from "./chunk-LBA5UOLF.mjs";
 import {
-  EnableBlueprints,
-  QueryBlueprints,
+  GetCurrentDate,
+  SetAlarm,
   definitions_exports as definitions_exports3
-} from "./chunk-NSAUN2IX.mjs";
+} from "./chunk-JBTXZQ5G.mjs";
+import {
+  EnableSkills,
+  QuerySkills,
+  definitions_exports as definitions_exports4
+} from "./chunk-JTEBE7KA.mjs";
 import {
   ContextAdd,
   ContextRemove,
@@ -47,42 +53,40 @@ import {
   SchemaList,
   TagAdd,
   TagRemove,
-  definitions_exports as definitions_exports4
-} from "./chunk-4LFE5PQ3.mjs";
+  definitions_exports as definitions_exports5
+} from "./chunk-YQSQRSXG.mjs";
 import {
-  AgentBlueprintHandlers,
-  blueprint_default
-} from "./chunk-OK3P6URP.mjs";
+  AgentSkillHandlers,
+  skill_default
+} from "./chunk-MFVIGJBW.mjs";
 import {
   AgentRules,
   CreateAgent,
   SyncTriggers,
   definitions_exports as definitions_exports2
-} from "./chunk-KZDQGI3S.mjs";
+} from "./chunk-PBARVBNJ.mjs";
 import {
   definitions_exports
-} from "./chunk-CUT6GB2W.mjs";
+} from "./chunk-BDTGFPM7.mjs";
 import {
   Agent_exports,
-  McpServer_exports,
-  Plan_exports
-} from "./chunk-5HANNHZZ.mjs";
+  McpServer_exports
+} from "./chunk-H4W22FFJ.mjs";
 import {
-  Chat_exports
-} from "./chunk-JZHXJBSM.mjs";
+  Chat_exports,
+  Plan_exports
+} from "./chunk-Z2HFOZXK.mjs";
 import {
   Memory_exports
-} from "./chunk-SYUTQPSB.mjs";
-import {
-  __export
-} from "./chunk-J5LGTIGS.mjs";
+} from "./chunk-EPQCDGIV.mjs";
+import "./chunk-J5LGTIGS.mjs";
 
-// src/blueprints/agent-wizard/blueprint.ts
-import { Blueprint, Template } from "@dxos/compute";
+// src/skills/agent-wizard/skill.ts
+import { Skill, Template } from "@dxos/compute";
 import { trim } from "@dxos/util";
-var BLUEPRINT_KEY = "org.dxos.blueprint.agentWizard";
-var make = () => Blueprint.make({
-  key: BLUEPRINT_KEY,
+var SKILL_KEY = "org.dxos.skill.agentWizard";
+var make = () => Skill.make({
+  key: SKILL_KEY,
   name: "Agent Wizard",
   description: "Help the user create a new agent (subscriptions, optional cron timer, sync-triggers after edits).",
   agentCanEnable: true,
@@ -101,14 +105,14 @@ var make = () => Blueprint.make({
         Examples: \`0 9 * * *\` for daily at 09:00, or \`*/5 * * * *\` for every 5 minutes.
         Timer triggers bypass the qualifier and invoke the agent worker directly on the schedule.
 
-        The agent itself is an ECHO object and can be edited like any other object using the database blueprint.
+        The agent itself is an ECHO object and can be edited like any other object using the database skill.
         You can edit the agent's instructions, name, and other properties directly.
         If you edit the agent's \`enabled\` field, \`filterEvents\` field, subscriptions array, or \`cron\` field, you MUST call the sync-triggers function afterward to synchronize the triggers (\`enabled\` is applied to all triggers).
 
         IMPORTANT: Before attempting to create an agent call the [agent-rules] tool to get the rules for creating an agent.
       `
   }),
-  tools: Blueprint.toolDefinitions({
+  tools: Skill.toolDefinitions({
     operations: [
       AgentRules,
       CreateAgent,
@@ -116,23 +120,61 @@ var make = () => Blueprint.make({
     ]
   })
 });
-var blueprint = {
-  key: BLUEPRINT_KEY,
+var skill = {
+  key: SKILL_KEY,
   make
 };
-var blueprint_default2 = blueprint;
+var skill_default2 = skill;
 
-// src/blueprints/agent-wizard/operations/index.ts
+// src/skills/agent-wizard/operations/index.ts
 import { OperationHandlerSet } from "@dxos/compute";
-var AgentWizardHandlers = OperationHandlerSet.lazy(() => import("./create-agent-7PBQFYHF.mjs"), () => import("./agent-rules-L3AHRSR4.mjs"), () => import("./sync-triggers-CI6ECSZX.mjs"));
+var AgentWizardHandlers = OperationHandlerSet.lazy(() => import("./create-agent-5WTOFIEK.mjs"), () => import("./agent-rules-KWCBKJ5W.mjs"), () => import("./sync-triggers-YBTLPCUB.mjs"));
 
-// src/blueprints/automation/blueprint.ts
-import { Blueprint as Blueprint2, Trigger, Operation } from "@dxos/compute";
-import { Ref, Type } from "@dxos/echo";
+// src/skills/alarm/skill.ts
+import { Skill as Skill2 } from "@dxos/compute";
+import { Ref } from "@dxos/echo";
 import { Text } from "@dxos/schema";
 import { trim as trim2 } from "@dxos/util";
-var BLUEPRINT_KEY2 = "dxos.org/blueprint/automation";
+var SKILL_KEY2 = "org.dxos.skill.alarm";
 var instructions = trim2`
+  You can schedule an alarm to wake yourself up in the future and continue working.
+  When the alarm fires you receive a prompt carrying any reminder you set.
+  Read the current time before computing an absolute wake time.
+`;
+var make2 = () => Skill2.make({
+  key: SKILL_KEY2,
+  name: "Alarm",
+  description: "Schedule a self-wake and inspect the current time.",
+  agentCanEnable: true,
+  instructions: {
+    source: Ref.make(Text.make({
+      content: instructions
+    }))
+  },
+  tools: Skill2.toolDefinitions({
+    operations: [
+      SetAlarm,
+      GetCurrentDate
+    ]
+  })
+});
+var skill2 = {
+  key: SKILL_KEY2,
+  make: make2
+};
+var skill_default3 = skill2;
+
+// src/skills/alarm/operations/index.ts
+import { OperationHandlerSet as OperationHandlerSet2 } from "@dxos/compute";
+var AlarmHandlers = OperationHandlerSet2.lazy(() => import("./set-alarm-BD3NEYSU.mjs"), () => import("./get-current-date-JR5F7ZS3.mjs"));
+
+// src/skills/automation/skill.ts
+import { Operation, Skill as Skill3, Trigger } from "@dxos/compute";
+import { Ref as Ref2, Type } from "@dxos/echo";
+import { Text as Text2 } from "@dxos/schema";
+import { trim as trim3 } from "@dxos/util";
+var SKILL_KEY3 = "org.dxos.skill.automation";
+var instructions2 = trim3`
   Automation allows you to automatically initiate actions based on events.
   Automations are configured by creating a trigger that references a function.
   Whenever event that matches the trigger occurs, the function is invoked.
@@ -170,7 +212,7 @@ var instructions = trim2`
   ## Editing triggers
 
   Triggers are represented as objects of type ${Type.getTypename(Trigger.Trigger)}.
-  You need access to the Database blueprint to manipulate triggers.
+  You need access to the Database skill to manipulate triggers.
   Read trigger schema before manipulating triggers.
   Having a Trigger object in the database is enough to setup an automation. 
 
@@ -209,89 +251,89 @@ var instructions = trim2`
     }
   }
 `;
-var make2 = () => Blueprint2.make({
-  key: BLUEPRINT_KEY2,
+var make3 = () => Skill3.make({
+  key: SKILL_KEY3,
   name: "Triggers",
   description: "Trigger management and automation.",
   instructions: {
-    source: Ref.make(Text.make({
-      content: instructions
+    source: Ref2.make(Text2.make({
+      content: instructions2
     }))
   }
 });
-var blueprint2 = {
-  key: BLUEPRINT_KEY2,
-  make: make2
+var skill3 = {
+  key: SKILL_KEY3,
+  make: make3
 };
-var blueprint_default3 = blueprint2;
+var skill_default4 = skill3;
 
-// src/blueprints/blueprint-manager/blueprint.ts
-import { Blueprint as Blueprint3, Template as Template2 } from "@dxos/compute";
+// src/skills/skill-manager/skill.ts
+import { Skill as Skill4, Template as Template2 } from "@dxos/compute";
 import { DXN } from "@dxos/keys";
-import { trim as trim3 } from "@dxos/util";
-var BLUEPRINT_KEY3 = "org.dxos.blueprint.blueprintManager";
-var make3 = () => Blueprint3.make({
-  key: BLUEPRINT_KEY3,
-  name: "Blueprint Manager",
-  description: "Query and enable blueprints in the current conversation.",
+import { trim as trim4 } from "@dxos/util";
+var SKILL_KEY4 = "org.dxos.skill.skillManager";
+var make4 = () => Skill4.make({
+  key: SKILL_KEY4,
+  name: "Skill Manager",
+  description: "Query and enable skills in the current conversation.",
   instructions: Template2.make({
-    source: trim3`
-        You can query available blueprints and enable them in the current conversation.
-        Use [query-blueprints] to refresh the list of available blueprints.
-        Use [enable-blueprints] to enable blueprints by their keys. Always call [query-blueprints] first.
-        Only blueprints with agentCanEnable=true can be enabled by the agent.
-
-        <available_blueprints>
-        {{#each blueprints}}
+    source: trim4`
+        You can query available skills and enable them in the current conversation.
+        Use [query-skills] to refresh the list of available skills.
+        Use [enable-skills] to enable skills by their keys. Always call [query-skills] first.
+        Only skills with agentCanEnable=true can be enabled by the agent.
+
+        <available_skills>
+        {{#each skills}}
         - {{key}} "{{name}}"{{#if description}} -- {{description}}{{/if}}{{#if agentCanEnable}} [agent-can-enable]{{/if}}
         {{/each}}
-        </available_blueprints>
+        </available_skills>
 
-        NOTE: You must enable the blueprint to use it, only then the tools from that blueprint will appear.
+        NOTE: You must enable the skill to use it, only then the tools from that skill will appear.
       `,
     inputs: [
       {
-        name: "blueprints",
+        name: "skills",
         kind: "operation",
-        operation: DXN.getName(QueryBlueprints.meta.key)
+        operation: DXN.getName(QuerySkills.meta.key)
       }
     ]
   }),
-  tools: Blueprint3.toolDefinitions({
+  tools: Skill4.toolDefinitions({
     operations: [
-      QueryBlueprints,
-      EnableBlueprints
+      QuerySkills,
+      EnableSkills
     ]
   })
 });
-var blueprint3 = {
-  key: BLUEPRINT_KEY3,
-  make: make3
+var skill4 = {
+  key: SKILL_KEY4,
+  make: make4
 };
-var blueprint_default4 = blueprint3;
+var skill_default5 = skill4;
 
-// src/blueprints/blueprint-manager/operations/index.ts
-import { OperationHandlerSet as OperationHandlerSet2 } from "@dxos/compute";
-var BlueprintManagerHandlers = OperationHandlerSet2.lazy(() => import("./query-blueprints-7NDHHM7U.mjs"), () => import("./enable-blueprints-OGYSQ7HD.mjs"));
+// src/skills/skill-manager/operations/index.ts
+import { OperationHandlerSet as OperationHandlerSet3 } from "@dxos/compute";
+var SkillManagerHandlers = OperationHandlerSet3.lazy(() => import("./query-skills-7GQFSU4V.mjs"), () => import("./enable-skills-FHEJXQVB.mjs"));
 
-// src/blueprints/browser/blueprint.ts
-import { Blueprint as Blueprint4 } from "@dxos/compute";
-import { Ref as Ref2 } from "@dxos/echo";
-import { Text as Text2 } from "@dxos/schema";
-import { trim as trim4 } from "@dxos/util";
-var BLUEPRINT_KEY4 = "org.dxos.blueprint.browser";
-var instructions2 = trim4`
+// src/skills/browser/skill.ts
+import { Skill as Skill5 } from "@dxos/compute";
+import { Ref as Ref3 } from "@dxos/echo";
+import { Text as Text3 } from "@dxos/schema";
+import { trim as trim5 } from "@dxos/util";
+var SKILL_KEY5 = "org.dxos.skill.browser";
+var instructions3 = trim5`
   You are able to connect and use a virtual browser with persistent session.
   Browser tools are provided via MCP.
 `;
-var make4 = () => Blueprint4.make({
-  key: BLUEPRINT_KEY4,
+var make5 = () => Skill5.make({
+  key: SKILL_KEY5,
   name: "Browser",
   description: "Access to a real isolated browser.",
   agentCanEnable: true,
   instructions: {
-    source: Ref2.make(Text2.make({
-      content: instructions2
+    source: Ref3.make(Text3.make({
+      content: instructions3
     }))
   },
   mcpServers: [
@@ -302,33 +344,69 @@ var make4 = () => Blueprint4.make({
     }
   ]
 });
-var blueprint4 = {
-  key: BLUEPRINT_KEY4,
-  make: make4
+var skill5 = {
+  key: SKILL_KEY5,
+  make: make5
 };
-var blueprint_default5 = blueprint4;
+var skill_default6 = skill5;
 
-// src/blueprints/database/blueprint.ts
-import { Blueprint as Blueprint5 } from "@dxos/compute";
-import { Ref as Ref3 } from "@dxos/echo";
-import { Text as Text3 } from "@dxos/schema";
-import { trim as trim5 } from "@dxos/util";
-var BLUEPRINT_KEY5 = "org.dxos.blueprint.database";
-var instructions3 = trim5`
+// src/skills/connectors/skill.ts
+import { Skill as Skill6 } from "@dxos/compute";
+import { Ref as Ref4 } from "@dxos/echo";
+import { Text as Text4 } from "@dxos/schema";
+import { trim as trim6 } from "@dxos/util";
+var SKILL_KEY6 = "org.dxos.skill.connectors";
+var instructions4 = trim6`
+  Users connect external services (such as Gmail, Slack, GitHub, Linear, and Discord) through connectors.
+  A service is available to you only when a connection to it already exists in the current space.
+
+  When a request needs a service that is not connected, DO NOT fail, refuse, or apologize. Instead, render
+  a connector prompt so the user can connect it inline. Emit a self-closing surface tag with the
+  'integration-prompt' role and the service's domain:
+
+  <surface role='integration-prompt' data='{"service":"gmail.com"}' />
+
+  Use the service's domain as the 'service' value (for example 'gmail.com', 'slack.com', 'github.com').
+  Emit the surface once, then briefly tell the user that connecting the service will let you continue.
+`;
+var make6 = () => Skill6.make({
+  key: SKILL_KEY6,
+  name: "Connectors",
+  description: "Prompt the user to connect external services when a connector is required but unavailable.",
+  agentCanEnable: true,
+  instructions: {
+    source: Ref4.make(Text4.make({
+      content: instructions4
+    }))
+  }
+});
+var skill6 = {
+  key: SKILL_KEY6,
+  make: make6
+};
+var skill_default7 = skill6;
+
+// src/skills/database/skill.ts
+import { Skill as Skill7 } from "@dxos/compute";
+import { Ref as Ref5 } from "@dxos/echo";
+import { Text as Text5 } from "@dxos/schema";
+import { trim as trim7 } from "@dxos/util";
+var SKILL_KEY7 = "org.dxos.skill.database";
+var instructions5 = trim7`
   You can query, create, update, and delete objects in ECHO.
   You can manage schemas, relations, tags, and add objects to the chat context.
 `;
-var make5 = () => Blueprint5.make({
-  key: BLUEPRINT_KEY5,
+var make7 = () => Skill7.make({
+  key: SKILL_KEY7,
   name: "Database",
   description: "Query and manipulate objects in the ECHO database.",
   agentCanEnable: true,
   instructions: {
-    source: Ref3.make(Text3.make({
-      content: instructions3
+    source: Ref5.make(Text5.make({
+      content: instructions5
     }))
   },
-  tools: Blueprint5.toolDefinitions({
+  tools: Skill7.toolDefinitions({
     operations: [
       ContextAdd,
       ContextRemove,
@@ -346,84 +424,84 @@ var make5 = () => Blueprint5.make({
     ]
   })
 });
-var blueprint5 = {
-  key: BLUEPRINT_KEY5,
-  make: make5
+var skill7 = {
+  key: SKILL_KEY7,
+  make: make7
 };
-var blueprint_default6 = blueprint5;
+var skill_default8 = skill7;
 
-// src/blueprints/database/operations/index.ts
-import { OperationHandlerSet as OperationHandlerSet3 } from "@dxos/compute";
-var DatabaseHandlers = OperationHandlerSet3.lazy(() => import("./context-add-KWEKPGMI.mjs"), () => import("./context-remove-HIQFSVHW.mjs"), () => import("./load-C4OPO7RD.mjs"), () => import("./object-create-F7R7IRW5.mjs"), () => import("./object-delete-3TJ3XMLN.mjs"), () => import("./object-update-EBRM5AKN.mjs"), () => import("./query-QGSHZMCD.mjs"), () => import("./relation-create-WA2DM76W.mjs"), () => import("./relation-delete-66XP7KL7.mjs"), () => import("./schema-add-2AWYVGOC.mjs"), () => import("./schema-list-74CQW2N3.mjs"), () => import("./tag-add-6EGIY2CC.mjs"), () => import("./tag-remove-XVTYJRI7.mjs"));
+// src/skills/database/operations/index.ts
+import { OperationHandlerSet as OperationHandlerSet4 } from "@dxos/compute";
+var DatabaseHandlers = OperationHandlerSet4.lazy(() => import("./context-add-DZTPB3FK.mjs"), () => import("./context-remove-XSBOM4VJ.mjs"), () => import("./load-S6HC5TGX.mjs"), () => import("./object-create-PVDQ62CG.mjs"), () => import("./object-delete-3CSL6XI6.mjs"), () => import("./object-update-NIGMZINM.mjs"), () => import("./query-NCTCRYTD.mjs"), () => import("./relation-create-QKXHTL7G.mjs"), () => import("./relation-delete-PDIWT2JX.mjs"), () => import("./schema-add-5NOK2RWE.mjs"), () => import("./schema-list-BZUR5KMX.mjs"), () => import("./tag-add-L5WNOBYY.mjs"), () => import("./tag-remove-WV5RPE5W.mjs"));
 
-// src/blueprints/delegation/blueprint.ts
-import { Blueprint as Blueprint6 } from "@dxos/compute";
-var BLUEPRINT_KEY6 = "org.dxos.blueprint.delegation";
-var make6 = () => Blueprint6.make({
-  key: BLUEPRINT_KEY6,
+// src/skills/delegation/skill.ts
+import { Skill as Skill8 } from "@dxos/compute";
+var SKILL_KEY8 = "org.dxos.skill.delegation";
+var make8 = () => Skill8.make({
+  key: SKILL_KEY8,
   name: "Delegation",
   description: "Delegates work to sub-agents and tracks it as plan tasks.",
-  tools: Blueprint6.toolDefinitions({
+  tools: Skill8.toolDefinitions({
     operations: [
       DelegateTask
     ]
   })
 });
-var blueprint6 = {
-  key: BLUEPRINT_KEY6,
-  make: make6
+var skill8 = {
+  key: SKILL_KEY8,
+  make: make8
 };
-var blueprint_default7 = blueprint6;
+var skill_default9 = skill8;
 
-// src/blueprints/delegation/operations/index.ts
-import { OperationHandlerSet as OperationHandlerSet4 } from "@dxos/compute";
-var DelegationHandlers = OperationHandlerSet4.lazy(() => import("./delegate-task-IQJSRLN3.mjs"));
+// src/skills/delegation/operations/index.ts
+import { OperationHandlerSet as OperationHandlerSet5 } from "@dxos/compute";
+var DelegationHandlers = OperationHandlerSet5.lazy(() => import("./delegate-task-UX64NK4M.mjs"));
 
-// src/blueprints/discord/blueprint.ts
-import { Blueprint as Blueprint7 } from "@dxos/compute";
-import { Ref as Ref4 } from "@dxos/echo";
-import { Text as Text4 } from "@dxos/schema";
-import { trim as trim6 } from "@dxos/util";
-var BLUEPRINT_KEY7 = "org.dxos.blueprint.discord";
-var instructions4 = trim6`
+// src/skills/discord/skill.ts
+import { Skill as Skill9 } from "@dxos/compute";
+import { Ref as Ref6 } from "@dxos/echo";
+import { Text as Text6 } from "@dxos/schema";
+import { trim as trim8 } from "@dxos/util";
+var SKILL_KEY9 = "org.dxos.skill.discord";
+var instructions6 = trim8`
   You are able to fetch messages from Discord servers.
 
   Known servers:
 
   DXOS serverId: 837138313172353095
 `;
-var make7 = () => Blueprint7.make({
-  key: BLUEPRINT_KEY7,
+var make9 = () => Skill9.make({
+  key: SKILL_KEY9,
   name: "Discord",
   description: "Discord integration.",
   instructions: {
-    source: Ref4.make(Text4.make({
-      content: instructions4
+    source: Ref6.make(Text6.make({
+      content: instructions6
     }))
   },
-  tools: Blueprint7.toolDefinitions({
+  tools: Skill9.toolDefinitions({
     operations: [
       FetchMessages
     ]
   })
 });
-var blueprint7 = {
-  key: BLUEPRINT_KEY7,
-  make: make7
+var skill9 = {
+  key: SKILL_KEY9,
+  make: make9
 };
-var blueprint_default8 = blueprint7;
+var skill_default10 = skill9;
 
-// src/blueprints/discord/operations/index.ts
-import { OperationHandlerSet as OperationHandlerSet5 } from "@dxos/compute";
-var DiscordHandlers = OperationHandlerSet5.lazy(() => import("./fetch-messages-4EVGVEQK.mjs"));
+// src/skills/discord/operations/index.ts
+import { OperationHandlerSet as OperationHandlerSet6 } from "@dxos/compute";
+var DiscordHandlers = OperationHandlerSet6.lazy(() => import("./fetch-messages-CQMDI36G.mjs"));
 
-// src/blueprints/linear/blueprint.ts
-import { Blueprint as Blueprint8 } from "@dxos/compute";
-import { Ref as Ref5 } from "@dxos/echo";
-import { Text as Text5 } from "@dxos/schema";
-import { trim as trim7 } from "@dxos/util";
-var BLUEPRINT_KEY8 = "org.dxos.blueprint.linear";
-var instructions5 = trim7`
+// src/skills/linear/skill.ts
+import { Skill as Skill10 } from "@dxos/compute";
+import { Ref as Ref7 } from "@dxos/echo";
+import { Text as Text7 } from "@dxos/schema";
+import { trim as trim9 } from "@dxos/util";
+var SKILL_KEY10 = "org.dxos.skill.linear";
+var instructions7 = trim9`
   You are able to sync Linear workspaces.
   Sometimes sync does not complete in one go and you need to call the function again.
 
@@ -431,38 +509,38 @@ var instructions5 = trim7`
 
   DXOS teamId: 1127c63a-6f77-4725-9229-50f6cd47321c
 `;
-var make8 = () => Blueprint8.make({
-  key: BLUEPRINT_KEY8,
+var make10 = () => Skill10.make({
+  key: SKILL_KEY10,
   name: "Linear",
   description: "Syncs Linear workspaces.",
   instructions: {
-    source: Ref5.make(Text5.make({
-      content: instructions5
+    source: Ref7.make(Text7.make({
+      content: instructions7
     }))
   },
-  tools: Blueprint8.toolDefinitions({
+  tools: Skill10.toolDefinitions({
     operations: [
       SyncIssues
     ]
   })
 });
-var blueprint8 = {
-  key: BLUEPRINT_KEY8,
-  make: make8
+var skill10 = {
+  key: SKILL_KEY10,
+  make: make10
 };
-var blueprint_default9 = blueprint8;
+var skill_default11 = skill10;
 
-// src/blueprints/linear/operations/index.ts
-import { OperationHandlerSet as OperationHandlerSet6 } from "@dxos/compute";
-var LinearHandlers = OperationHandlerSet6.lazy(() => import("./sync-issues-VUX4OWPO.mjs"));
+// src/skills/linear/operations/index.ts
+import { OperationHandlerSet as OperationHandlerSet7 } from "@dxos/compute";
+var LinearHandlers = OperationHandlerSet7.lazy(() => import("./sync-issues-O76MCMD3.mjs"));
 
-// src/blueprints/memory/blueprint.ts
-import { Blueprint as Blueprint9 } from "@dxos/compute";
-import { Ref as Ref6 } from "@dxos/echo";
-import { Text as Text6 } from "@dxos/schema";
-import { trim as trim8 } from "@dxos/util";
-var BLUEPRINT_KEY9 = "org.dxos.blueprint.memory";
-var instructions6 = trim8`
+// src/skills/memory/skill.ts
+import { Skill as Skill11 } from "@dxos/compute";
+import { Ref as Ref8 } from "@dxos/echo";
+import { Text as Text8 } from "@dxos/schema";
+import { trim as trim10 } from "@dxos/util";
+var SKILL_KEY11 = "org.dxos.skill.memory";
+var instructions8 = trim10`
   You have the ability to save and recall memories.
   Memories are persistent knowledge units stored in the database.
   Use memories to remember facts, user preferences, decisions, and any knowledge that should persist across conversations.
@@ -471,17 +549,17 @@ var instructions6 = trim8`
   When the user asks about something you might have stored, query your memories first.
   You can also delete outdated or incorrect memories.
 `;
-var make9 = () => Blueprint9.make({
-  key: BLUEPRINT_KEY9,
+var make11 = () => Skill11.make({
+  key: SKILL_KEY11,
   name: "Memory",
   description: "Persistent memory storage and retrieval.",
   agentCanEnable: true,
   instructions: {
-    source: Ref6.make(Text6.make({
-      content: instructions6
+    source: Ref8.make(Text8.make({
+      content: instructions8
     }))
   },
-  tools: Blueprint9.toolDefinitions({
+  tools: Skill11.toolDefinitions({
     operations: [
       SaveMemory,
       QueryMemories,
@@ -489,371 +567,133 @@ var make9 = () => Blueprint9.make({
     ]
   })
 });
-var blueprint9 = {
-  key: BLUEPRINT_KEY9,
-  make: make9
+var skill11 = {
+  key: SKILL_KEY11,
+  make: make11
 };
-var blueprint_default10 = blueprint9;
-
-// src/blueprints/memory/operations/index.ts
-import { OperationHandlerSet as OperationHandlerSet7 } from "@dxos/compute";
-var MemoryHandlers = OperationHandlerSet7.lazy(() => import("./save-HQY35ACW.mjs"), () => import("./query-6XCQIIZC.mjs"), () => import("./delete-QHGM7N23.mjs"));
+var skill_default12 = skill11;
 
-// src/blueprints/planning/blueprint.ts
-import { Blueprint as Blueprint10 } from "@dxos/compute";
-var BLUEPRINT_KEY10 = "org.dxos.blueprint.planning";
-var make10 = () => Blueprint10.make({
-  key: BLUEPRINT_KEY10,
+// src/skills/memory/operations/index.ts
+import { OperationHandlerSet as OperationHandlerSet8 } from "@dxos/compute";
+var MemoryHandlers = OperationHandlerSet8.lazy(() => import("./save-UYVRA4RS.mjs"), () => import("./query-K4R7UHLU.mjs"), () => import("./delete-IU7HPU3K.mjs"));
+
+// src/skills/planning/skill.ts
+import { Operation as Operation2, Skill as Skill12 } from "@dxos/compute";
+import { Ref as Ref9 } from "@dxos/echo";
+var SKILL_KEY12 = "org.dxos.skill.planning";
+var make12 = () => Skill12.make({
+  key: SKILL_KEY12,
   name: "Planning",
   description: "Plans and tracks complex tasks using artifacts.",
-  tools: Blueprint10.toolDefinitions({
+  agentCanEnable: true,
+  tools: Skill12.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: Ref9.make(Operation2.serialize(PlanReminder))
+    }
+  ]
 });
-var blueprint10 = {
-  key: BLUEPRINT_KEY10,
-  make: make10
+var skill12 = {
+  key: SKILL_KEY12,
+  make: make12
 };
-var blueprint_default11 = blueprint10;
+var skill_default13 = skill12;
 
-// src/blueprints/planning/operations/index.ts
-import { OperationHandlerSet as OperationHandlerSet8 } from "@dxos/compute";
-var PlanningHandlers = OperationHandlerSet8.lazy(() => import("./update-tasks-R5YXESZ6.mjs"));
+// src/skills/planning/operations/index.ts
+import { OperationHandlerSet as OperationHandlerSet9 } from "@dxos/compute";
+var PlanningHandlers = OperationHandlerSet9.lazy(() => import("./update-tasks-HX4ILWOU.mjs"), () => import("./plan-reminder-N4X6JPBI.mjs"));
 
-// src/blueprints/websearch/blueprint.ts
-import { Blueprint as Blueprint11 } from "@dxos/compute";
-import { Ref as Ref7 } from "@dxos/echo";
-import { Text as Text7 } from "@dxos/schema";
-var BLUEPRINT_KEY11 = "org.dxos.blueprint.webSearch";
-var make11 = () => Blueprint11.make({
-  key: BLUEPRINT_KEY11,
+// src/skills/websearch/skill.ts
+import { Skill as Skill13 } from "@dxos/compute";
+import { Ref as Ref10 } from "@dxos/echo";
+import { Text as Text9 } from "@dxos/schema";
+
+// src/skills/websearch/toolkit.ts
+import * as Toolkit from "@effect/ai/Toolkit";
+import * as Layer from "effect/Layer";
+import { AnthropicWebSearchTool, OpaqueToolkit } from "@dxos/ai";
+var WebSearchToolkit = Toolkit.make(AnthropicWebSearchTool);
+var WebSearchToolkitOpaque = OpaqueToolkit.make(WebSearchToolkit, Layer.empty);
+
+// src/skills/websearch/skill.ts
+var SKILL_KEY13 = "org.dxos.skill.webSearch";
+var make14 = () => Skill13.make({
+  key: SKILL_KEY13,
   name: "Web Search",
   description: "Search the web.",
   agentCanEnable: true,
   instructions: {
-    source: Ref7.make(Text7.make())
+    source: Ref10.make(Text9.make())
   },
-  tools: Blueprint11.toolDefinitions({
+  tools: Skill13.toolDefinitions({
     operations: [
       Fetch
+    ],
+    tools: [
+      WebSearchToolkit.tools.AnthropicWebSearch.name
     ]
   })
 });
-var blueprint11 = {
-  key: BLUEPRINT_KEY11,
-  make: make11
-};
-var blueprint_default12 = blueprint11;
-
-// src/blueprints/websearch/toolkit.ts
-import * as AnthropicTool from "@effect/ai-anthropic/AnthropicTool";
-import * as Toolkit from "@effect/ai/Toolkit";
-import * as Layer from "effect/Layer";
-import { OpaqueToolkit } from "@dxos/ai";
-var WebSearchToolkit = Toolkit.make(AnthropicTool.WebSearch_20250305({}));
-var WebSearchToolkitOpaque = OpaqueToolkit.make(WebSearchToolkit, Layer.empty);
-
-// src/blueprints/websearch/operations/index.ts
-import { OperationHandlerSet as OperationHandlerSet9 } from "@dxos/compute";
-var WebSearchHandlers = OperationHandlerSet9.lazy(() => import("./fetch-O6G46HJH.mjs"));
-
-// src/crud/graph.ts
-import * as Tool from "@effect/ai/Tool";
-import * as Toolkit2 from "@effect/ai/Toolkit";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Function from "effect/Function";
-import * as Option from "effect/Option";
-import * as Schema from "effect/Schema";
-import * as SchemaAST from "effect/SchemaAST";
-import { Database, Entity, Feed, Filter, Query as Query2, Relation, Scope, Type as Type2 } from "@dxos/echo";
-import { isEncodedReference } from "@dxos/echo-protocol";
-import { ReferenceAnnotationId, getTypeAnnotation, getTypeIdentifierAnnotation } from "@dxos/echo/Annotation";
-import { createObject } from "@dxos/echo/internal";
-import { SchemaEx } from "@dxos/effect";
-import { DXN as DXN2, EID, EntityId } from "@dxos/keys";
-import { log } from "@dxos/log";
-import { deepMapValues, isNonNullable, trim as trim9 } from "@dxos/util";
-var __dxlog_file = "/__w/dxos/dxos/packages/core/compute/assistant-toolkit/src/crud/graph.ts";
-var Subgraph = Schema.Struct({
-  /** Objects and relations. */
-  objects: Schema.Array(Schema.Any)
-});
-var findRelatedSchema = async (db, anchor) => {
-  const allSchemas = await db.query(Query2.select(Filter.type(Type2.Type)).from(Scope.space(), Scope.registry())).run();
-  return allSchemas.filter((schema) => {
-    const annotation = getTypeAnnotation(Type2.getSchema(schema));
-    if (annotation?.kind !== Entity.Kind.Relation) {
-      return false;
-    }
-    return isSchemaAddressableByDXN(anchor, annotation.sourceSchema) || isSchemaAddressableByDXN(anchor, annotation.targetSchema);
-  }).map((schema) => ({
-    kind: "relation",
-    schema
-  }));
-};
-var isSchemaAddressableByDXN = (type, dxn) => {
-  if (getTypeIdentifierAnnotation(Type2.getSchema(type)) === dxn) {
-    return true;
-  }
-  return DXN2.getName(dxn) === Type2.getTypename(type);
-};
-var LocalSearchToolkit = Toolkit2.make(Tool.make("search_local_search", {
-  description: "Search the local database for information using a vector index",
-  parameters: {
-    query: Schema.String.annotations({
-      description: "The query to search for. Could be a question or a topic or a set of keywords."
-    })
-  },
-  success: Schema.Unknown,
-  failure: Schema.Never,
-  dependencies: [
-    Database.Service,
-    Feed.FeedService
-  ]
-}));
-var LocalSearchHandler = LocalSearchToolkit.toLayer({
-  search_local_search: Effect.fn(function* ({ query }) {
-    const objects = yield* Database.query(Query2.select(Filter.text(query, {
-      type: "vector"
-    }))).run;
-    const results = [
-      ...objects
-    ];
-    const feedOption = yield* Effect.serviceOption(Feed.ContextFeedService);
-    if (Option.isSome(feedOption)) {
-      const feedObjects = yield* Feed.runQuery(feedOption.value.feed, Filter.everything());
-      results.push(...feedObjects);
-    }
-    return trim9`
-      <local_context>
-        ${JSON.stringify(results, null, 2)}
-      </local_context>
-    `;
-  })
-});
-var GraphWriterSchema = class extends Context.Tag("@dxos/assistant/GraphWriterSchema")() {
-};
-var makeGraphWriterToolkit = ({ schema }) => {
-  return Toolkit2.make(Tool.make("graph_writer", {
-    description: "Write to the local graph database",
-    parameters: createExtractionSchema(schema).fields,
-    success: Schema.Unknown,
-    failure: Schema.Never,
-    dependencies: [
-      Database.Service,
-      Feed.ContextFeedService,
-      Feed.FeedService
-    ]
-  }).annotateContext(Context.make(GraphWriterSchema, {
-    schema
-  })));
-};
-var makeGraphWriterHandler = (toolkit, { onAppend } = {}) => {
-  const { schema } = Context.get(toolkit.tools.graph_writer.annotations, GraphWriterSchema);
-  return toolkit.toLayer({
-    graph_writer: Effect.fn(function* (input) {
-      const { db } = yield* Database.Service;
-      const { feed } = yield* Feed.ContextFeedService;
-      const data = yield* sanitizeObjects(schema, input, db, feed);
-      yield* Feed.append(feed, data);
-      const dxns = data.map((obj) => Entity.getURI(obj));
-      onAppend?.(dxns);
-      return dxns;
-    })
-  });
-};
-var createExtractionSchema = (types) => {
-  return Schema.Struct({
-    ...Object.fromEntries(types.map((type) => preprocessSchema(Type2.getSchema(type))).map((schema, index) => [
-      `objects_${getSanitizedSchemaName(types[index])}`,
-      Schema.optional(Schema.Array(schema)).annotations({
-        description: `The objects of type: ${DXN2.getName(DXN2.tryMake(Type2.getURI(types[index])))}. ${SchemaAST.getDescriptionAnnotation(Type2.getSchema(types[index]).ast).pipe(Option.getOrElse(() => ""))}`
-      })
-    ]))
-  });
-};
-var getSanitizedSchemaName = (schema) => {
-  return DXN2.getName(DXN2.tryMake(Type2.getURI(schema))).replaceAll(/[^a-zA-Z0-9]+/g, "_");
-};
-var sanitizeObjects = (types, data, db, feed) => Effect.gen(function* () {
-  const entries = types.map((type) => data[`objects_${getSanitizedSchemaName(type)}`]?.map((object) => ({
-    data: object,
-    schema: type
-  })) ?? []).flat();
-  const idMap = /* @__PURE__ */ new Map();
-  const existingIds = /* @__PURE__ */ new Set();
-  const enitties = /* @__PURE__ */ new Map();
-  const resolveId = (id) => {
-    if (EntityId.isValid(id)) {
-      existingIds.add(id);
-      return EID.make({
-        entityId: id
-      });
-    }
-    const mappedId = idMap.get(id);
-    if (mappedId && EntityId.isValid(mappedId)) {
-      return EID.make({
-        entityId: mappedId
-      });
-    }
-    return void 0;
-  };
-  const res = entries.map((entry) => {
-    if (EntityId.isValid(entry.data.id)) {
-      return entry;
-    }
-    idMap.set(entry.data.id, EntityId.random());
-    entry.data.id = idMap.get(entry.data.id);
-    return entry;
-  }).map((entry) => {
-    const data2 = deepMapValues(entry.data, (value, recurse) => {
-      if (isEncodedReference(value)) {
-        const ref = value["/"];
-        const id = resolveId(ref);
-        if (id) {
-          return {
-            "/": id.toString()
-          };
-        } else {
-          return {
-            "/": `search:?q=${encodeURIComponent(ref)}`
-          };
-        }
-      }
-      return recurse(value);
-    });
-    let sourceUri;
-    let targetUri;
-    if (Entity.getKind(Type2.getSchema(entry.schema)) === "relation") {
-      sourceUri = resolveId(data2.source);
-      if (!sourceUri) {
-        log.warn("source not found", {
-          source: data2.source
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 196, S: this });
-      }
-      targetUri = resolveId(data2.target);
-      if (!targetUri) {
-        log.warn("target not found", {
-          target: data2.target
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 202, S: this });
-      }
-      delete data2.source;
-      delete data2.target;
-    }
-    return {
-      data: data2,
-      schema: entry.schema,
-      sourceUri,
-      targetUri
-    };
-  }).filter((object) => !existingIds.has(object.data.id));
-  const dbObjects = yield* Effect.promise(() => db.query(Query2.select(Filter.id(...existingIds))).run());
-  const feedObjects = feed && existingIds.size > 0 ? yield* Feed.runQuery(feed, Filter.id(...existingIds)) : [];
-  const objects = [
-    ...dbObjects,
-    ...feedObjects
-  ].filter(isNonNullable);
-  log.info("objects", {
-    dbObjects,
-    feedObjects,
-    existingIds
-  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 224, S: this });
-  const missing = Array.from(existingIds).filter((id) => !objects.some((object) => object.id === id));
-  if (missing.length > 0) {
-    throw new Error(`Object IDs do not point to existing objects: ${missing.join(", ")}`);
-  }
-  return res.flatMap(({ data: data2, schema, sourceUri, targetUri }) => {
-    let skip = false;
-    if (sourceUri) {
-      const id = EID.getEntityId(sourceUri);
-      const obj = objects.find((object) => object.id === id) ?? (id ? enitties.get(id) : void 0);
-      if (obj) {
-        data2[Relation.Source] = obj;
-      } else {
-        skip = true;
-      }
-    }
-    if (targetUri) {
-      const id = EID.getEntityId(targetUri);
-      const obj = objects.find((object) => object.id === id) ?? (id ? enitties.get(id) : void 0);
-      if (obj) {
-        data2[Relation.Target] = obj;
-      } else {
-        skip = true;
-      }
-    }
-    if (!skip) {
-      const obj = createObject(schema, data2);
-      enitties.set(obj.id, obj);
-      return [
-        obj
-      ];
-    }
-    return [];
-  });
-});
-var SoftRef = Schema.Struct({
-  "/": Schema.String
-}).annotations({
-  description: "Reference to another object."
-});
-var preprocessSchema = (schema) => {
-  const isRelationSchema = Entity.getKind(schema) === "relation";
-  const go = (ast, visited = /* @__PURE__ */ new Set()) => {
-    if (visited.has(ast)) {
-      return ast;
-    }
-    visited.add(ast);
-    if (SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option.isSome)) {
-      return SoftRef.ast;
-    }
-    return SchemaEx.mapAst(ast, (child) => go(child, visited));
-  };
-  return Schema.make(SchemaEx.mapAst(schema.ast, (ast) => go(ast))).pipe(Schema.omit("id"), Schema.extend(Schema.Struct({
-    id: Schema.String.annotations({
-      description: "The id of this object. Come up with a unique id based on your judgement."
-    })
-  })), isRelationSchema ? Schema.extend(Schema.Struct({
-    source: Schema.String.annotations({
-      description: "The id of the source object for this relation."
-    }),
-    target: Schema.String.annotations({
-      description: "The id of the target object for this relation."
-    })
-  })) : Function.identity);
+var skill13 = {
+  key: SKILL_KEY13,
+  make: make14
 };
+var skill_default14 = skill13;
 
-// src/functions/agent/index.ts
+// src/skills/websearch/operations/index.ts
 import { OperationHandlerSet as OperationHandlerSet10 } from "@dxos/compute";
-var AgentHandlers = OperationHandlerSet10.lazy(() => import("./prompt-37GJGKNM.mjs"));
+var WebSearchHandlers = OperationHandlerSet10.lazy(() => import("./fetch-5LY25EBR.mjs"));
+
+// src/operations/index.ts
+import { OperationHandlerSet as OperationHandlerSet11 } from "@dxos/compute";
+var AgentHandlers = OperationHandlerSet11.lazy(() => import("./run-instructions-72ASH5EZ.mjs"));
 
 // src/supervisor/delegation-strategy.ts
 import * as Cause from "effect/Cause";
-import * as Effect2 from "effect/Effect";
+import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import { AiContext } from "@dxos/assistant";
-import { Routine } from "@dxos/compute";
+import { Instructions } from "@dxos/compute";
 import { ProcessManager } from "@dxos/compute-runtime";
-import { Database as Database2, Feed as Feed2, Filter as Filter2, Obj, Ref as Ref8 } from "@dxos/echo";
+import { Database, Feed, Filter, Obj, Ref as Ref11 } from "@dxos/echo";
 import { EffectEx } from "@dxos/effect";
-import { log as log2 } from "@dxos/log";
+import { log } from "@dxos/log";
 import { Message } from "@dxos/types";
-import { trim as trim10 } from "@dxos/util";
-var __dxlog_file2 = "/__w/dxos/dxos/packages/core/compute/assistant-toolkit/src/supervisor/delegation-strategy.ts";
-var findAgentForFeed = (feed) => Effect2.gen(function* () {
-  const agents = yield* Database2.query(Filter2.type(Agent_exports.Agent)).run;
+import { trim as trim11 } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/compute/assistant-toolkit/src/supervisor/delegation-strategy.ts";
+var findChatForFeed = (feed) => Effect.gen(function* () {
+  const chats = yield* Database.query(Filter.type(Chat_exports.Chat)).run;
+  for (const chat of chats) {
+    const matches = yield* Effect.gen(function* () {
+      const chatFeed = yield* Database.load(chat.feed);
+      return chatFeed.id === feed.id;
+    }).pipe(Effect.orElseSucceed(() => false));
+    if (matches) {
+      return chat;
+    }
+  }
+  return void 0;
+});
+var findAgentForFeed = (feed) => Effect.gen(function* () {
+  const agents = yield* Database.query(Filter.type(Agent_exports.Agent)).run;
   for (const agent of agents) {
     if (!agent.chat) {
       continue;
     }
-    const matches = yield* Effect2.gen(function* () {
-      const chat = yield* Database2.load(agent.chat);
-      const chatFeed = yield* Database2.load(chat.feed);
+    const matches = yield* Effect.gen(function* () {
+      const chat = yield* Database.load(agent.chat);
+      const chatFeed = yield* Database.load(chat.feed);
       return chatFeed.id === feed.id;
-    }).pipe(Effect2.orElseSucceed(() => false));
+    }).pipe(Effect.orElseSucceed(() => false));
     if (matches) {
       return agent;
     }
@@ -872,12 +712,12 @@ var extractArtifactIds = (value) => {
   return ids.filter((id) => typeof id === "string");
 };
 var makeDelegationStrategy = () => ({
-  reconcile: (feed, activeIds) => Effect2.gen(function* () {
-    const agent = yield* findAgentForFeed(feed);
-    if (!agent) {
+  reconcile: (feed, activeIds) => Effect.gen(function* () {
+    const chat = yield* findChatForFeed(feed);
+    if (!chat) {
       return [];
     }
-    const plan = yield* Database2.load(agent.plan).pipe(Effect2.orElseSucceed(() => void 0));
+    const plan = chat.plan ? yield* Database.load(chat.plan).pipe(Effect.orElseSucceed(() => void 0)) : void 0;
     if (!plan) {
       return [];
     }
@@ -885,20 +725,20 @@ var makeDelegationStrategy = () => ({
     if (pending.length === 0) {
       return [];
     }
-    const inheritedBlueprints = yield* Effect2.gen(function* () {
-      const runtime2 = yield* Effect2.runtime();
+    const inheritedSkills = yield* Effect.gen(function* () {
+      const runtime2 = yield* Effect.runtime();
       const binder = yield* EffectEx.acquireReleaseResource(() => new AiContext.Binder({
         feed,
         runtime: runtime2
       }));
-      return binder.getBlueprints().filter((blueprint12) => Obj.getMeta(blueprint12).key !== blueprint_default7.key);
-    }).pipe(Effect2.scoped);
-    const blueprints = inheritedBlueprints.map((blueprint12) => Ref8.make(blueprint12));
+      return binder.getSkills().filter((skill14) => Obj.getMeta(skill14).key !== skill_default9.key);
+    }).pipe(Effect.scoped);
+    const skills = inheritedSkills.map((skill14) => Ref11.make(skill14));
     const delegations = [];
     for (const task of pending) {
-      const routine = yield* Database2.add(Routine.make({
+      const instructions9 = yield* Database.add(Instructions.make({
         name: task.title,
-        instructions: trim10`
+        text: trim11`
               Complete the following task and report the result concisely.
 
               If you create any documents or artifacts, call completeJob with a JSON object of the
@@ -907,14 +747,14 @@ var makeDelegationStrategy = () => ({
 
               Task: ${task.title}
             `,
-        blueprints
+        skills
       }));
       delegations.push({
         id: task.id,
-        spawn: Effect2.gen(function* () {
+        spawn: Effect.gen(function* () {
           const invoker = yield* ProcessManager.ProcessOperationInvoker.Service;
-          const fiber = yield* invoker.invokeFiber(AgentPrompt, {
-            prompt: Ref8.make(routine),
+          const fiber = yield* invoker.invokeFiber(RunInstructions, {
+            instructions: Ref11.make(instructions9),
             input: {}
           });
           const pid = fiber.pid;
@@ -930,9 +770,10 @@ var makeDelegationStrategy = () => ({
     }
     return delegations;
   }),
-  onComplete: (feed, id, exit) => Effect2.gen(function* () {
+  onComplete: (feed, id, exit) => Effect.gen(function* () {
+    const chat = yield* findChatForFeed(feed);
     const agent = yield* findAgentForFeed(feed);
-    const plan = agent ? yield* Database2.load(agent.plan).pipe(Effect2.orElseSucceed(() => void 0)) : void 0;
+    const plan = chat?.plan != null ? yield* Database.load(chat.plan).pipe(Effect.orElseSucceed(() => void 0)) : void 0;
     let title = id;
     if (plan) {
       Obj.update(plan, (plan2) => {
@@ -949,7 +790,7 @@ var makeDelegationStrategy = () => ({
         const ref = yield* Agent_exports.addArtifact(agent, {
           name: title,
           id: artifactId
-        }).pipe(Effect2.orElseSucceed(() => void 0));
+        }).pipe(Effect.orElseSucceed(() => void 0));
         if (ref) {
           artifactRefs.push(ref);
         }
@@ -957,11 +798,11 @@ var makeDelegationStrategy = () => ({
     }
     const failureCause = Exit.isFailure(exit) ? Cause.pretty(exit.cause) : void 0;
     if (failureCause) {
-      log2.warn("sub-agent failed", {
+      log.warn("sub-agent failed", {
         taskId: id,
         title,
         cause: failureCause
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 156, S: this });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 172, S: this });
     }
     const text = Exit.isSuccess(exit) ? `The sub-agent completed "${title}".${artifactRefs.length === 0 ? ` ${formatResult(exit.value)}` : ""}` : `The sub-agent failed to complete "${title}": ${failureCause ?? "unknown error"}`;
     const blocks = [
@@ -974,7 +815,7 @@ var makeDelegationStrategy = () => ({
         reference
       }))
     ];
-    yield* Feed2.append(feed, [
+    yield* Feed.append(feed, [
       Message.make({
         sender: "assistant",
         blocks
@@ -982,129 +823,53 @@ var makeDelegationStrategy = () => ({
     ]);
   })
 });
-
-// src/supervisor/plan-completion-guard.ts
-import * as Effect3 from "effect/Effect";
-import { Database as Database3, Filter as Filter3 } from "@dxos/echo";
-var findAgentForFeed2 = (feed) => Effect3.gen(function* () {
-  const agents = yield* Database3.query(Filter3.type(Agent_exports.Agent)).run;
-  for (const agent of agents) {
-    if (!agent.chat) {
-      continue;
-    }
-    const matches = yield* Effect3.gen(function* () {
-      const chat = yield* Database3.load(agent.chat);
-      const chatFeed = yield* Database3.load(chat.feed);
-      return chatFeed.id === feed.id;
-    }).pipe(Effect3.orElseSucceed(() => false));
-    if (matches) {
-      return agent;
-    }
-  }
-  return void 0;
-});
-var hasIncompleteTasks = (plan) => plan.tasks.some((task) => task.status === "todo" || task.status === "in-progress");
-var makePlanCompletionGuard = () => ({
-  getIncompletePlanSummary: (feed) => Effect3.gen(function* () {
-    const agent = yield* findAgentForFeed2(feed);
-    if (!agent?.plan) {
-      return void 0;
-    }
-    const plan = yield* Database3.load(agent.plan).pipe(Effect3.orElseSucceed(() => void 0));
-    if (!plan || !hasIncompleteTasks(plan)) {
-      return void 0;
-    }
-    return Plan_exports.formatPlan(plan);
-  })
-});
-
-// src/toolkits/WebToolkit.ts
-var WebToolkit_exports = {};
-__export(WebToolkit_exports, {
-  WebToolkit: () => WebToolkit,
-  layer: () => layer
-});
-import * as AnthropicTool2 from "@effect/ai-anthropic/AnthropicTool";
-import * as Tool2 from "@effect/ai/Tool";
-import * as Toolkit3 from "@effect/ai/Toolkit";
-import * as Effect4 from "effect/Effect";
-import * as Schema2 from "effect/Schema";
-import { proxyFetchLegacy } from "@dxos/edge-client/cors-proxy";
-var WebToolkit = Toolkit3.make(AnthropicTool2.WebSearch_20250305({}).pipe(), Tool2.make("WebFetch", {
-  parameters: {
-    url: Schema2.String
-  },
-  success: Schema2.String
-}));
-var layer = WebToolkit.toLayer({
-  WebFetch: Effect4.fnUntraced(function* ({ url }) {
-    return yield* Effect4.tryPromise({
-      try: async () => {
-        const response = await proxyFetchLegacy(new URL(url));
-        if (!response.ok) {
-          const body = await response.text();
-          return `Fetch failed with status ${response.status}: ${body.slice(0, 256)}`;
-        }
-        return await response.text();
-      },
-      catch: (cause) => new Error(String(cause))
-    }).pipe(Effect4.catchAll((err) => Effect4.succeed(err.message)));
-  })
-});
 export {
   Agent_exports as Agent,
-  blueprint_default as AgentBlueprint,
-  AgentBlueprintHandlers,
-  definitions_exports as AgentBlueprintOperations,
   AgentHandlers,
-  AgentPrompt,
-  blueprint_default2 as AgentWizardBlueprint,
+  skill_default as AgentSkill,
+  AgentSkillHandlers,
+  definitions_exports as AgentSkillOperations,
   AgentWizardHandlers,
   definitions_exports2 as AgentWizardOperations,
-  blueprint_default3 as AutomationBlueprint,
-  blueprint_default4 as BlueprintManagerBlueprint,
-  BlueprintManagerHandlers,
-  definitions_exports3 as BlueprintManagerOperations,
-  blueprint_default5 as BrowserBlueprint,
+  skill_default2 as AgentWizardSkill,
+  AlarmHandlers,
+  definitions_exports3 as AlarmOperations,
+  skill_default3 as AlarmSkill,
+  skill_default4 as AutomationSkill,
+  skill_default6 as BrowserSkill,
   Chat_exports as Chat,
-  blueprint_default6 as DatabaseBlueprint,
+  skill_default7 as ConnectorsSkill,
   DatabaseHandlers,
-  definitions_exports4 as DatabaseOperations,
-  blueprint_default7 as DelegationBlueprint,
+  definitions_exports5 as DatabaseOperations,
+  skill_default8 as DatabaseSkill,
   DelegationHandlers,
   delegate_task_exports as DelegationOperations,
-  blueprint_default8 as DiscordBlueprint,
+  skill_default9 as DelegationSkill,
   DiscordHandlers,
-  definitions_exports5 as DiscordOperations,
-  blueprint_default9 as LinearBlueprint,
+  definitions_exports6 as DiscordOperations,
+  skill_default10 as DiscordSkill,
   LinearHandlers,
-  definitions_exports6 as LinearOperations,
-  LocalSearchHandler,
-  LocalSearchToolkit,
+  definitions_exports7 as LinearOperations,
+  skill_default11 as LinearSkill,
   McpServer_exports as McpServer,
   Memory_exports as Memory,
-  blueprint_default10 as MemoryBlueprint,
   MemoryHandlers,
-  definitions_exports7 as MemoryOperations,
+  definitions_exports8 as MemoryOperations,
+  skill_default12 as MemorySkill,
   Plan_exports as Plan,
-  blueprint_default11 as PlanningBlueprint,
   PlanningHandlers,
-  update_tasks_exports as PlanningOperations,
-  Subgraph,
-  blueprint_default12 as WebSearchBlueprint,
+  definitions_exports9 as PlanningOperations,
+  skill_default13 as PlanningSkill,
+  RunInstructions,
+  SkillManagerHandlers,
+  definitions_exports4 as SkillManagerOperations,
+  skill_default5 as SkillManagerSkill,
   WebSearchHandlers,
-  definitions_exports8 as WebSearchOperations,
+  definitions_exports10 as WebSearchOperations,
+  skill_default14 as WebSearchSkill,
   WebSearchToolkit,
   WebSearchToolkitOpaque,
-  WebToolkit_exports as WebToolkit,
-  createExtractionSchema,
-  findRelatedSchema,
-  getSanitizedSchemaName,
   makeDelegationStrategy,
-  makeGraphWriterHandler,
-  makeGraphWriterToolkit,
-  makePlanCompletionGuard,
-  sanitizeObjects,
   syncObjects
 };
 //# sourceMappingURL=index.mjs.map