@dxos/assistant-toolkit 0.8.4-main.fcc0d83b33 → 0.8.4-staging.60fe92afc8

package/dist/lib/neutral/index.mjs

@@ -1,31 +1,38 @@
 import {
-  AgentPrompt
-} from "./chunk-JN4GARRQ.mjs";
+  Fetch,
+  definitions_exports as definitions_exports8
+} from "./chunk-FQNZX2SH.mjs";
 import {
-  DeleteMemory,
-  QueryMemories,
-  SaveMemory
-} from "./chunk-EJAQUAKM.mjs";
+  AgentPrompt
+} from "./chunk-BOB6M2YM.mjs";
 import {
-  EnableBlueprints,
-  QueryBlueprints,
-  UpdateBlueprints
-} from "./chunk-YSYNXOZA.mjs";
+  DelegateTask,
+  delegate_task_exports
+} from "./chunk-U5FCQXA2.mjs";
 import {
-  AgentRules,
-  CreateAgent,
-  SyncTriggers
-} from "./chunk-4T3LJGXI.mjs";
+  FetchMessages,
+  definitions_exports as definitions_exports5
+} from "./chunk-ZQDWSV26.mjs";
 import {
   SyncIssues,
+  definitions_exports as definitions_exports6,
   syncObjects
-} from "./chunk-WIV7ZVRS.mjs";
+} from "./chunk-24L572PJ.mjs";
+import {
+  DeleteMemory,
+  QueryMemories,
+  SaveMemory,
+  definitions_exports as definitions_exports7
+} from "./chunk-DLVIJSH6.mjs";
 import {
-  UpdateTasks
-} from "./chunk-P5LAPHCG.mjs";
+  UpdateTasks,
+  update_tasks_exports
+} from "./chunk-KC2LPECT.mjs";
 import {
-  Fetch
-} from "./chunk-WLR3BGO4.mjs";
+  EnableBlueprints,
+  QueryBlueprints,
+  definitions_exports as definitions_exports3
+} from "./chunk-NSAUN2IX.mjs";
 import {
   ContextAdd,
   ContextRemove,
@@ -39,65 +46,73 @@ import {
   SchemaAdd,
   SchemaList,
   TagAdd,
-  TagRemove
-} from "./chunk-CVUA23QI.mjs";
-import {
-  FetchMessages
-} from "./chunk-VSDP6SRY.mjs";
+  TagRemove,
+  definitions_exports as definitions_exports4
+} from "./chunk-4LFE5PQ3.mjs";
 import {
   AgentBlueprintHandlers,
   blueprint_default
-} from "./chunk-YXOVSRFU.mjs";
+} from "./chunk-JRUTUKPS.mjs";
+import {
+  AgentRules,
+  CreateAgent,
+  SyncTriggers,
+  definitions_exports as definitions_exports2
+} from "./chunk-3YH7MWSD.mjs";
 import {
-  AddArtifact,
-  AgentWorker,
-  GetContext,
-  Qualifier
-} from "./chunk-GSG4JGIY.mjs";
+  definitions_exports
+} from "./chunk-RNIUE4LK.mjs";
 import {
   Agent_exports,
   McpServer_exports,
   Plan_exports
-} from "./chunk-SVI25Z2Y.mjs";
+} from "./chunk-URUJQGI6.mjs";
 import {
   Chat_exports
-} from "./chunk-NR3GTWRC.mjs";
+} from "./chunk-Z3KITY4U.mjs";
 import {
   Memory_exports
-} from "./chunk-KGU725LW.mjs";
+} from "./chunk-SYUTQPSB.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
 
-// src/blueprints/discord/blueprint.ts
-import { Blueprint } from "@dxos/compute";
-import { Ref } from "@dxos/echo";
-import { Text } from "@dxos/schema";
+// src/blueprints/agent-wizard/blueprint.ts
+import { Blueprint, Template } from "@dxos/compute";
 import { trim } from "@dxos/util";
+var BLUEPRINT_KEY = "org.dxos.blueprint.agentWizard";
+var make = () => Blueprint.make({
+  key: BLUEPRINT_KEY,
+  name: "Agent Wizard",
+  description: "Help the user create a new agent (subscriptions, optional cron timer, sync-triggers after edits).",
+  agentCanEnable: true,
+  instructions: Template.make({
+    source: trim`
+        You are a wizard that helps the user create a new agent.
 
-// src/blueprints/discord/functions/index.ts
-import { OperationHandlerSet } from "@dxos/compute";
-var DiscordHandlers = OperationHandlerSet.lazy(() => import("./fetch-messages-OS74FP76.mjs"));
+        Agents are goal oriented and autonomously driven.
+        Each agent has instructions - the goal of the agent.
+        The instructions also typically describe what actions to perform in reaction to events (emails).
+        The agent has a number of associated artifacts to work with.
+        Agents can subscribe to emails.
 
-// src/blueprints/discord/blueprint.ts
-var BLUEPRINT_KEY = "org.dxos.blueprint.discord";
-var instructions = trim`
-  You are able to fetch messages from Discord servers.
+        Agents have a \`cron\` field: when set, the agent runs on a timer on that schedule (standard cron syntax).
+        Use \`cron\` when the user wants the agent to run periodically (e.g. "every morning", "once a day", "every 5 minutes").
+        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.
 
-  Known servers:
+        The agent itself is an ECHO object and can be edited like any other object using the database blueprint.
+        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).
 
-  DXOS serverId: 837138313172353095
-`;
-var make = () => Blueprint.make({
-  key: BLUEPRINT_KEY,
-  name: "Discord",
-  description: "Discord integration.",
-  instructions: {
-    source: Ref.make(Text.make(instructions))
-  },
+        IMPORTANT: Before attempting to create an agent call the [agent-rules] tool to get the rules for creating an agent.
+      `
+  }),
   tools: Blueprint.toolDefinitions({
     operations: [
-      FetchMessages
+      AgentRules,
+      CreateAgent,
+      SyncTriggers
     ]
   })
 });
@@ -107,38 +122,102 @@ var blueprint = {
 };
 var blueprint_default2 = blueprint;
 
-// src/blueprints/linear/blueprint.ts
-import { Blueprint as Blueprint2 } from "@dxos/compute";
-import { Ref as Ref2 } from "@dxos/echo";
-import { Text as Text2 } from "@dxos/schema";
+// src/blueprints/agent-wizard/operations/index.ts
+import { OperationHandlerSet } from "@dxos/compute";
+var AgentWizardHandlers = OperationHandlerSet.lazy(() => import("./create-agent-KUTBEXLJ.mjs"), () => import("./agent-rules-3TBAIVTS.mjs"), () => import("./sync-triggers-JEVTYIGU.mjs"));
+
+// src/blueprints/automation/blueprint.ts
+import { Blueprint as Blueprint2, Trigger, Operation } from "@dxos/compute";
+import { Ref, Type } from "@dxos/echo";
+import { Text } from "@dxos/schema";
 import { trim as trim2 } from "@dxos/util";
+var BLUEPRINT_KEY2 = "dxos.org/blueprint/automation";
+var instructions = trim2`
+  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.
 
-// src/blueprints/linear/functions/index.ts
-import { OperationHandlerSet as OperationHandlerSet2 } from "@dxos/compute";
-var LinearHandlers = OperationHandlerSet2.lazy(() => import("./sync-issues-A2RJNPEF.mjs"));
+  ## Configuration
 
-// src/blueprints/linear/blueprint.ts
-var BLUEPRINT_KEY2 = "org.dxos.blueprint.linear";
-var instructions2 = trim2`
-  You are able to sync Linear workspaces.
-  Sometimes sync does not complete in one go and you need to call the function again.
+  Triggers are configured by the properties of the Trigger object.
+  - enabled: Must be true for trigger to run.
+  - spec: Events that the trigger matches.
+  - function: Ref to a ${Type.getTypename(Operation.PersistentOperation)} object that will be invoked. Query the functions present in the space first, and reference them in the trigger.
+  - input: The spec of the input data that will be passed to the function.
 
-  Known workspaces:
+  ## Input patterns
 
-  DXOS teamId: 1127c63a-6f77-4725-9229-50f6cd47321c
+  Input to the invoked function is defined by the input property of the Trigger object.
+  It's an object that supports constants or template strings.
+
+  Example:
+
+  {
+    item: '{{event.item}}',
+    instructions: 'Summarize and perform entity-extraction'
+    mailbox: { '/': 'echo://AAA/ZZZ' }
+  }
+
+  ## Trigger kinds
+
+  - Timer: Triggered by a cron schedule.
+  - Queue: Subscribes and processes items begginging to end.
+            Note: queues are the same as feeds. The queue EID should be of form: echo://<space-id>/<queue-id>.
+  - Subscription: Subscribes and processes database items based on a query.
+
+  Avoid: email and webhook triggers.
+
+  ## Editing triggers
+
+  Triggers are represented as objects of type ${Type.getTypename(Trigger.Trigger)}.
+  You need access to the Database blueprint to manipulate triggers.
+  Read trigger schema before manipulating triggers.
+  Having a Trigger object in the database is enough to setup an automation. 
+
+  ## Examples
+
+  Timer:
+
+  {
+    "function": { "/": "echo://AAA/ZZZ" },
+    "enabled": true,
+    "spec": {
+      "kind": "timer",
+      "cron": "*/5 * * * *"
+    }
+  }
+
+  Queue:
+
+  {
+    "function": { "/": "echo://AAA/ZZZ" },
+    "enabled": true,
+    "spec": {
+      "kind": "queue",
+      "queue": "echo://XXX/YYY"
+    }
+  }
+
+  Subscription:
+
+  {
+    "function": { "/": "echo://AAA/ZZZ" },
+    "enabled": true,
+    "spec": {
+      "kind": "subscription",
+      "query": { "ast": { "type": "select", "filter": { "type": "object", "typename": "dxn:org.dxos.type.person" } } }
+    }
+  }
 `;
 var make2 = () => Blueprint2.make({
   key: BLUEPRINT_KEY2,
-  name: "Linear",
-  description: "Syncs Linear workspaces.",
+  name: "Triggers",
+  description: "Trigger management and automation.",
   instructions: {
-    source: Ref2.make(Text2.make(instructions2))
-  },
-  tools: Blueprint2.toolDefinitions({
-    operations: [
-      SyncIssues
-    ]
-  })
+    source: Ref.make(Text.make({
+      content: instructions
+    }))
+  }
 });
 var blueprint2 = {
   key: BLUEPRINT_KEY2,
@@ -146,22 +225,42 @@ var blueprint2 = {
 };
 var blueprint_default3 = blueprint2;
 
-// src/blueprints/planning/blueprint.ts
-import { Blueprint as Blueprint3 } from "@dxos/compute";
-
-// src/blueprints/planning/functions/index.ts
-import { OperationHandlerSet as OperationHandlerSet3 } from "@dxos/compute";
-var PlanningHandlers = OperationHandlerSet3.lazy(() => import("./update-tasks-UGGHWXT5.mjs"));
-
-// src/blueprints/planning/blueprint.ts
-var BLUEPRINT_KEY3 = "org.dxos.blueprint.planning";
+// src/blueprints/blueprint-manager/blueprint.ts
+import { Blueprint as Blueprint3, 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: "Planning",
-  description: "Plans and tracks complex tasks with artifact management.",
+  name: "Blueprint Manager",
+  description: "Query and enable blueprints 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}}
+        - {{key}} "{{name}}"{{#if description}} -- {{description}}{{/if}}{{#if agentCanEnable}} [agent-can-enable]{{/if}}
+        {{/each}}
+        </available_blueprints>
+
+        NOTE: You must enable the blueprint to use it, only then the tools from that blueprint will appear.
+      `,
+    inputs: [
+      {
+        name: "blueprints",
+        kind: "operation",
+        operation: DXN.getName(QueryBlueprints.meta.key)
+      }
+    ]
+  }),
   tools: Blueprint3.toolDefinitions({
     operations: [
-      UpdateTasks
+      QueryBlueprints,
+      EnableBlueprints
     ]
   })
 });
@@ -171,65 +270,29 @@ var blueprint3 = {
 };
 var blueprint_default4 = blueprint3;
 
-// src/blueprints/websearch/blueprint.ts
-import { Blueprint as Blueprint4 } from "@dxos/compute";
-import { Ref as Ref3 } from "@dxos/echo";
-import { Text as Text3 } from "@dxos/schema";
-
-// src/blueprints/websearch/functions/index.ts
-import { OperationHandlerSet as OperationHandlerSet4 } from "@dxos/compute";
-var WebSearchHandlers = OperationHandlerSet4.lazy(() => import("./fetch-KHMHV7JR.mjs"));
-
-// src/blueprints/websearch/blueprint.ts
-var BLUEPRINT_KEY4 = "org.dxos.blueprint.web-search";
-var make4 = () => Blueprint4.make({
-  key: BLUEPRINT_KEY4,
-  name: "Web Search",
-  description: "Search the web.",
-  agentCanEnable: true,
-  instructions: {
-    source: Ref3.make(Text3.make())
-  },
-  tools: Blueprint4.toolDefinitions({
-    operations: [
-      Fetch
-    ],
-    tools: [
-      "AnthropicWebSearch"
-    ]
-  })
-});
-var blueprint4 = {
-  key: BLUEPRINT_KEY4,
-  make: make4
-};
-var blueprint_default5 = blueprint4;
-
-// 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/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/blueprints/browser/blueprint.ts
-import { Blueprint as Blueprint5 } from "@dxos/compute";
-import { Ref as Ref4 } from "@dxos/echo";
-import { Text as Text4 } from "@dxos/schema";
-import { trim as trim3 } from "@dxos/util";
-var BLUEPRINT_KEY5 = "org.dxos.blueprint.browser";
-var instructions3 = trim3`
+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`
   You are able to connect and use a virtual browser with persistent session.
   Browser tools are provided via MCP.
 `;
-var make6 = () => Blueprint5.make({
-  key: BLUEPRINT_KEY5,
+var make4 = () => Blueprint4.make({
+  key: BLUEPRINT_KEY4,
   name: "Browser",
   description: "Access to a real isolated browser.",
   agentCanEnable: true,
   instructions: {
-    source: Ref4.make(Text4.make(instructions3))
+    source: Ref2.make(Text2.make({
+      content: instructions2
+    }))
   },
   mcpServers: [
     {
@@ -239,37 +302,33 @@ var make6 = () => Blueprint5.make({
     }
   ]
 });
-var blueprint5 = {
-  key: BLUEPRINT_KEY5,
-  make: make6
+var blueprint4 = {
+  key: BLUEPRINT_KEY4,
+  make: make4
 };
-var blueprint_default6 = blueprint5;
-
-// src/blueprints/database/blueprint.ts
-import { Blueprint as Blueprint6 } from "@dxos/compute";
-import { Ref as Ref5 } from "@dxos/echo";
-import { Text as Text5 } from "@dxos/schema";
-import { trim as trim4 } from "@dxos/util";
-
-// src/blueprints/database/functions/index.ts
-import { OperationHandlerSet as OperationHandlerSet5 } from "@dxos/compute";
-var DatabaseHandlers = OperationHandlerSet5.lazy(() => import("./context-add-IIDPRRVB.mjs"), () => import("./context-remove-RDYV4PD4.mjs"), () => import("./load-LI7HHVD6.mjs"), () => import("./object-create-52Z7YKIA.mjs"), () => import("./object-delete-I266YAXI.mjs"), () => import("./object-update-HY4GI7LA.mjs"), () => import("./query-B3NOYFCK.mjs"), () => import("./relation-create-Z3NGW4VU.mjs"), () => import("./relation-delete-LXY7W2YO.mjs"), () => import("./schema-add-4TXJO2V7.mjs"), () => import("./schema-list-Q7HRRKGR.mjs"), () => import("./tag-add-5NOHUTIE.mjs"), () => import("./tag-remove-QTKYDJAW.mjs"));
+var blueprint_default5 = blueprint4;
 
 // src/blueprints/database/blueprint.ts
-var BLUEPRINT_KEY6 = "org.dxos.blueprint.database";
-var instructions4 = trim4`
+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`
   You can query, create, update, and delete objects in ECHO.
   You can manage schemas, relations, tags, and add objects to the chat context.
 `;
-var make7 = () => Blueprint6.make({
-  key: BLUEPRINT_KEY6,
+var make5 = () => Blueprint5.make({
+  key: BLUEPRINT_KEY5,
   name: "Database",
   description: "Query and manipulate objects in the ECHO database.",
   agentCanEnable: true,
   instructions: {
-    source: Ref5.make(Text5.make(instructions4))
+    source: Ref3.make(Text3.make({
+      content: instructions3
+    }))
   },
-  tools: Blueprint6.toolDefinitions({
+  tools: Blueprint5.toolDefinitions({
     operations: [
       ContextAdd,
       ContextRemove,
@@ -287,25 +346,123 @@ var make7 = () => Blueprint6.make({
     ]
   })
 });
-var blueprint6 = {
-  key: BLUEPRINT_KEY6,
-  make: make7
+var blueprint5 = {
+  key: BLUEPRINT_KEY5,
+  make: make5
+};
+var blueprint_default6 = blueprint5;
+
+// 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/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,
+  name: "Delegation",
+  description: "Delegates work to sub-agents and tracks it as plan tasks.",
+  tools: Blueprint6.toolDefinitions({
+    operations: [
+      DelegateTask
+    ]
+  })
+});
+var blueprint6 = {
+  key: BLUEPRINT_KEY6,
+  make: make6
+};
+var blueprint_default7 = blueprint6;
+
+// src/blueprints/delegation/operations/index.ts
+import { OperationHandlerSet as OperationHandlerSet4 } from "@dxos/compute";
+var DelegationHandlers = OperationHandlerSet4.lazy(() => import("./delegate-task-E7WLHT6S.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`
+  You are able to fetch messages from Discord servers.
+
+  Known servers:
+
+  DXOS serverId: 837138313172353095
+`;
+var make7 = () => Blueprint7.make({
+  key: BLUEPRINT_KEY7,
+  name: "Discord",
+  description: "Discord integration.",
+  instructions: {
+    source: Ref4.make(Text4.make({
+      content: instructions4
+    }))
+  },
+  tools: Blueprint7.toolDefinitions({
+    operations: [
+      FetchMessages
+    ]
+  })
+});
+var blueprint7 = {
+  key: BLUEPRINT_KEY7,
+  make: make7
+};
+var blueprint_default8 = blueprint7;
+
+// src/blueprints/discord/operations/index.ts
+import { OperationHandlerSet as OperationHandlerSet5 } from "@dxos/compute";
+var DiscordHandlers = OperationHandlerSet5.lazy(() => import("./fetch-messages-4EVGVEQK.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`
+  You are able to sync Linear workspaces.
+  Sometimes sync does not complete in one go and you need to call the function again.
+
+  Known workspaces:
+
+  DXOS teamId: 1127c63a-6f77-4725-9229-50f6cd47321c
+`;
+var make8 = () => Blueprint8.make({
+  key: BLUEPRINT_KEY8,
+  name: "Linear",
+  description: "Syncs Linear workspaces.",
+  instructions: {
+    source: Ref5.make(Text5.make({
+      content: instructions5
+    }))
+  },
+  tools: Blueprint8.toolDefinitions({
+    operations: [
+      SyncIssues
+    ]
+  })
+});
+var blueprint8 = {
+  key: BLUEPRINT_KEY8,
+  make: make8
 };
-var blueprint_default7 = blueprint6;
-
-// src/blueprints/memory/blueprint.ts
-import { Blueprint as Blueprint7 } from "@dxos/compute";
-import { Ref as Ref6 } from "@dxos/echo";
-import { Text as Text6 } from "@dxos/schema";
-import { trim as trim5 } from "@dxos/util";
+var blueprint_default9 = blueprint8;
 
-// src/blueprints/memory/functions/index.ts
+// src/blueprints/linear/operations/index.ts
 import { OperationHandlerSet as OperationHandlerSet6 } from "@dxos/compute";
-var MemoryHandlers = OperationHandlerSet6.lazy(() => import("./save-GWAPLT3Z.mjs"), () => import("./query-U56GNEV6.mjs"), () => import("./delete-J3PMWP7Z.mjs"));
+var LinearHandlers = OperationHandlerSet6.lazy(() => import("./sync-issues-VUX4OWPO.mjs"));
 
 // src/blueprints/memory/blueprint.ts
-var BLUEPRINT_KEY7 = "org.dxos.blueprint.memory";
-var instructions5 = trim5`
+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`
   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.
@@ -314,15 +471,17 @@ var instructions5 = trim5`
   When the user asks about something you might have stored, query your memories first.
   You can also delete outdated or incorrect memories.
 `;
-var make8 = () => Blueprint7.make({
-  key: BLUEPRINT_KEY7,
+var make9 = () => Blueprint9.make({
+  key: BLUEPRINT_KEY9,
   name: "Memory",
   description: "Persistent memory storage and retrieval.",
   agentCanEnable: true,
   instructions: {
-    source: Ref6.make(Text6.make(instructions5))
+    source: Ref6.make(Text6.make({
+      content: instructions6
+    }))
   },
-  tools: Blueprint7.toolDefinitions({
+  tools: Blueprint9.toolDefinitions({
     operations: [
       SaveMemory,
       QueryMemories,
@@ -330,213 +489,75 @@ var make8 = () => Blueprint7.make({
     ]
   })
 });
-var blueprint7 = {
-  key: BLUEPRINT_KEY7,
-  make: make8
-};
-var blueprint_default8 = blueprint7;
-
-// src/blueprints/automation/blueprint.ts
-import { Blueprint as Blueprint8 } from "@dxos/compute";
-import { Trigger } from "@dxos/compute";
-import { Operation } from "@dxos/compute";
-import { Ref as Ref7 } from "@dxos/echo";
-import { Text as Text7 } from "@dxos/schema";
-import { trim as trim6 } from "@dxos/util";
-var BLUEPRINT_KEY8 = "dxos.org/blueprint/automation";
-var instructions6 = trim6`
-  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.
-
-  ## Configuration
-
-  Triggers are configured by the properties of the Trigger object.
-  - enabled: Must be true for trigger to run.
-  - spec: Events that the trigger matches.
-  - function: Ref to a ${Operation.PersistentOperation.typename} object that will be invoked. Query the functions present in the space first, and reference them in the trigger.
-  - input: The spec of the input data that will be passed to the function.
-
-  ## Input patterns
-
-  Input to the invoked function is defined by the input property of the Trigger object.
-  It's an object that supports constants or template strings.
-
-  Example:
-
-  {
-    item: '{{event.item}}',
-    instructions: 'Summarize and perform entity-extraction'
-    mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
-  }
-
-  ## Trigger kinds
-
-  - Timer: Triggered by a cron schedule.
-  - Queue: Subscribes and processes items begginging to end.
-            Note: queues are the same as feeds. The queue DXN should be of form: dxn:queue:data:<space-id>:<queue-id>.
-  - Subscription: Subscribes and processes database items based on a query.
-
-  Avoid: email and webhook triggers.
-
-  ## Editing triggers
-
-  Triggers are represented as objects of type ${Trigger.Trigger.typename}.
-  You need access to the Database blueprint to manipulate triggers.
-  Read trigger schema before manipulating triggers.
-  Having a Trigger object in the database is enough to setup an automation. 
-
-  ## Examples
-
-  Timer:
-
-  {
-    "function": { "/": "dxn:echo:AAA:ZZZ" },
-    "enabled": true,
-    "spec": {
-      "kind": "timer",
-      "cron": "*/5 * * * *"
-    }
-  }
-
-  Queue:
-
-  {
-    "function": { "/": "dxn:echo:AAA:ZZZ" },
-    "enabled": true,
-    "spec": {
-      "kind": "queue",
-      "queue": "dxn:queue:data:XXX:YYY"
-    }
-  }
-
-  Subscription:
-
-  {
-    "function": { "/": "dxn:echo:AAA:ZZZ" },
-    "enabled": true,
-    "spec": {
-      "kind": "subscription",
-      "query": { "ast": { "type": "select", "filter": { "type": "object", "typename": "dxn:type:org.dxos.type.person" } } }
-    }
-  }
-`;
-var make9 = () => Blueprint8.make({
-  key: BLUEPRINT_KEY8,
-  name: "Triggers",
-  description: "Trigger management and automation.",
-  instructions: {
-    source: Ref7.make(Text7.make(instructions6))
-  }
-});
-var blueprint8 = {
-  key: BLUEPRINT_KEY8,
+var blueprint9 = {
+  key: BLUEPRINT_KEY9,
   make: make9
 };
-var blueprint_default9 = blueprint8;
-
-// src/blueprints/blueprint-manager/blueprint.ts
-import { Blueprint as Blueprint9, Template } from "@dxos/compute";
-import { trim as trim7 } from "@dxos/util";
+var blueprint_default10 = blueprint9;
 
-// src/blueprints/blueprint-manager/functions/index.ts
+// src/blueprints/memory/operations/index.ts
 import { OperationHandlerSet as OperationHandlerSet7 } from "@dxos/compute";
-var BlueprintManagerHandlers = OperationHandlerSet7.lazy(() => import("./query-blueprints-Z576ABT5.mjs"), () => import("./enable-blueprints-LELPQHY5.mjs"), () => import("./update-blueprints-K7A5SHBZ.mjs"));
-
-// src/blueprints/blueprint-manager/blueprint.ts
-var BLUEPRINT_KEY9 = "org.dxos.blueprint.blueprint-manager";
-var make10 = () => Blueprint9.make({
-  key: BLUEPRINT_KEY9,
-  name: "Blueprint Manager",
-  description: "Query and enable blueprints in the current conversation.",
-  instructions: Template.make({
-    source: trim7`
-        You can query available blueprints and enable them in the current conversation.
-        Use [query-blueprints] to refresh the list of available blueprints.
-        Use [refresh-blueprints] to update blueprint objects stored in the database from the built-in registry when they have drifted.
-        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}}
-        - {{key}} "{{name}}"{{#if description}} -- {{description}}{{/if}}{{#if agentCanEnable}} [agent-can-enable]{{/if}}
-        {{/each}}
-        </available_blueprints>
+var MemoryHandlers = OperationHandlerSet7.lazy(() => import("./save-HQY35ACW.mjs"), () => import("./query-6XCQIIZC.mjs"), () => import("./delete-QHGM7N23.mjs"));
 
-        NOTE: You must enable the blueprint to use it, only then the tools from that blueprint will appear.
-      `,
-    inputs: [
-      {
-        name: "blueprints",
-        kind: "function",
-        function: QueryBlueprints.meta.key
-      }
-    ]
-  }),
-  tools: Blueprint9.toolDefinitions({
+// 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,
+  name: "Planning",
+  description: "Plans and tracks complex tasks using artifacts.",
+  tools: Blueprint10.toolDefinitions({
     operations: [
-      QueryBlueprints,
-      EnableBlueprints,
-      UpdateBlueprints
+      UpdateTasks
     ]
   })
 });
-var blueprint9 = {
-  key: BLUEPRINT_KEY9,
+var blueprint10 = {
+  key: BLUEPRINT_KEY10,
   make: make10
 };
-var blueprint_default10 = blueprint9;
-
-// src/blueprints/project-wizard/blueprint.ts
-import { Blueprint as Blueprint10, Template as Template2 } from "@dxos/compute";
-import { trim as trim8 } from "@dxos/util";
+var blueprint_default11 = blueprint10;
 
-// src/blueprints/project-wizard/functions/index.ts
+// src/blueprints/planning/operations/index.ts
 import { OperationHandlerSet as OperationHandlerSet8 } from "@dxos/compute";
-var AgentWizardHandlers = OperationHandlerSet8.lazy(() => import("./create-project-MPAMKQ3T.mjs"), () => import("./project-rules-FLUQQRPB.mjs"), () => import("./sync-triggers-NV4JCRN5.mjs"));
+var PlanningHandlers = OperationHandlerSet8.lazy(() => import("./update-tasks-N65UQUHS.mjs"));
 
-// src/blueprints/project-wizard/blueprint.ts
-var BLUEPRINT_KEY10 = "org.dxos.blueprint.agent-wizard";
-var make11 = () => Blueprint10.make({
-  key: BLUEPRINT_KEY10,
-  name: "Agent Wizard",
-  description: "Help the user create a new agent (subscriptions, optional cron timer, sync-triggers after edits).",
+// 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,
+  name: "Web Search",
+  description: "Search the web.",
   agentCanEnable: true,
-  instructions: Template2.make({
-    source: trim8`
-        You are a wizard that helps the user create a new agent.
-
-        Agents are goal oriented and autonomously driven.
-        Each agent has instructions - the goal of the agent.
-        The instructions also typically describe what actions to perform in reaction to events (emails).
-        The agent has a number of associated artifacts to work with.
-        Agents can subscribe to emails.
-
-        Agents have a \`cron\` field: when set, the agent runs on a timer on that schedule (standard cron syntax).
-        Use \`cron\` when the user wants the agent to run periodically (e.g. "every morning", "once a day", "every 5 minutes").
-        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.
-        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: Blueprint10.toolDefinitions({
+  instructions: {
+    source: Ref7.make(Text7.make())
+  },
+  tools: Blueprint11.toolDefinitions({
     operations: [
-      AgentRules,
-      CreateAgent,
-      SyncTriggers
+      Fetch
     ]
   })
 });
-var blueprint10 = {
-  key: BLUEPRINT_KEY10,
+var blueprint11 = {
+  key: BLUEPRINT_KEY11,
   make: make11
 };
-var blueprint_default11 = blueprint10;
+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";
@@ -547,41 +568,37 @@ 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 { ContextQueueService } from "@dxos/compute";
-import { Entity, Filter, Obj, Query as Query2, Type } from "@dxos/echo";
-import { Database } from "@dxos/echo";
+import { Database, Entity, Feed, Filter, Query as Query2, Relation, Scope, Type as Type2 } from "@dxos/echo";
 import { isEncodedReference } from "@dxos/echo-protocol";
-import { ReferenceAnnotationId, RelationSourceDXNId, RelationSourceId, RelationTargetDXNId, RelationTargetId, createObject, getTypeAnnotation, getTypeIdentifierAnnotation } from "@dxos/echo/internal";
-import { mapAst } from "@dxos/effect";
-import { DXN, ObjectId } from "@dxos/keys";
+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/assistant-toolkit/src/crud/graph.ts";
+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.graph.schemaRegistry.query().run();
+  const allSchemas = await db.query(Query2.select(Filter.type(Type2.Type)).from(Scope.space(), Scope.registry())).run();
   return allSchemas.filter((schema) => {
-    if (getTypeAnnotation(schema)?.kind !== Entity.Kind.Relation) {
+    const annotation = getTypeAnnotation(Type2.getSchema(schema));
+    if (annotation?.kind !== Entity.Kind.Relation) {
       return false;
     }
-    return isSchemaAddressableByDxn(anchor, DXN.parse(getTypeAnnotation(schema).sourceSchema)) || isSchemaAddressableByDxn(anchor, DXN.parse(getTypeAnnotation(schema).targetSchema));
+    return isSchemaAddressableByDXN(anchor, annotation.sourceSchema) || isSchemaAddressableByDXN(anchor, annotation.targetSchema);
   }).map((schema) => ({
     kind: "relation",
     schema
   }));
 };
-var isSchemaAddressableByDxn = (schema, dxn) => {
-  if (getTypeIdentifierAnnotation(schema) === dxn.toString()) {
+var isSchemaAddressableByDXN = (type, dxn) => {
+  if (getTypeIdentifierAnnotation(Type2.getSchema(type)) === dxn) {
     return true;
   }
-  const t = dxn.asTypeDXN();
-  if (t) {
-    return t.type === Type.getTypename(schema);
-  }
-  return false;
+  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",
@@ -593,21 +610,22 @@ var LocalSearchToolkit = Toolkit2.make(Tool.make("search_local_search", {
   success: Schema.Unknown,
   failure: Schema.Never,
   dependencies: [
-    Database.Service
+    Database.Service,
+    Feed.FeedService
   ]
 }));
 var LocalSearchHandler = LocalSearchToolkit.toLayer({
   search_local_search: Effect.fn(function* ({ query }) {
-    const objects = yield* Database.runQuery(Query2.select(Filter.text(query, {
+    const objects = yield* Database.query(Query2.select(Filter.text(query, {
       type: "vector"
-    })));
+    }))).run;
     const results = [
       ...objects
     ];
-    const option = yield* Effect.serviceOption(ContextQueueService);
-    if (Option.isSome(option)) {
-      const queueObjects = yield* Effect.promise(() => option.value.queue.queryObjects());
-      results.push(...queueObjects);
+    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>
@@ -626,7 +644,8 @@ var makeGraphWriterToolkit = ({ schema }) => {
     failure: Schema.Never,
     dependencies: [
       Database.Service,
-      ContextQueueService
+      Feed.ContextFeedService,
+      Feed.FeedService
     ]
   }).annotateContext(Context.make(GraphWriterSchema, {
     schema
@@ -637,10 +656,10 @@ var makeGraphWriterHandler = (toolkit, { onAppend } = {}) => {
   return toolkit.toLayer({
     graph_writer: Effect.fn(function* (input) {
       const { db } = yield* Database.Service;
-      const { queue } = yield* ContextQueueService;
-      const data = yield* Effect.promise(() => sanitizeObjects(schema, input, db, queue));
-      yield* Effect.promise(() => queue.append(data));
-      const dxns = data.map((obj) => Obj.getDXN(obj));
+      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;
     })
@@ -648,18 +667,18 @@ var makeGraphWriterHandler = (toolkit, { onAppend } = {}) => {
 };
 var createExtractionSchema = (types) => {
   return Schema.Struct({
-    ...Object.fromEntries(types.map(preprocessSchema).map((schema, index) => [
+    ...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: ${Type.getDXN(types[index])?.asTypeDXN().type}. ${SchemaAST.getDescriptionAnnotation(types[index].ast).pipe(Option.getOrElse(() => ""))}`
+        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 Type.getDXN(schema).asTypeDXN().type.replaceAll(/[^a-zA-Z0-9]+/g, "_");
+  return DXN2.getName(DXN2.tryMake(Type2.getURI(schema))).replaceAll(/[^a-zA-Z0-9]+/g, "_");
 };
-var sanitizeObjects = async (types, data, db, queue) => {
+var sanitizeObjects = (types, data, db, feed) => Effect.gen(function* () {
   const entries = types.map((type) => data[`objects_${getSanitizedSchemaName(type)}`]?.map((object) => ({
     data: object,
     schema: type
@@ -668,21 +687,25 @@ var sanitizeObjects = async (types, data, db, queue) => {
   const existingIds = /* @__PURE__ */ new Set();
   const enitties = /* @__PURE__ */ new Map();
   const resolveId = (id) => {
-    if (ObjectId.isValid(id)) {
+    if (EntityId.isValid(id)) {
       existingIds.add(id);
-      return DXN.fromLocalObjectId(id);
+      return EID.make({
+        entityId: id
+      });
     }
     const mappedId = idMap.get(id);
-    if (mappedId) {
-      return DXN.fromLocalObjectId(mappedId);
+    if (mappedId && EntityId.isValid(mappedId)) {
+      return EID.make({
+        entityId: mappedId
+      });
     }
     return void 0;
   };
   const res = entries.map((entry) => {
-    if (ObjectId.isValid(entry.data.id)) {
+    if (EntityId.isValid(entry.data.id)) {
       return entry;
     }
-    idMap.set(entry.data.id, ObjectId.random());
+    idMap.set(entry.data.id, EntityId.random());
     entry.data.id = idMap.get(entry.data.id);
     return entry;
   }).map((entry) => {
@@ -702,64 +725,62 @@ var sanitizeObjects = async (types, data, db, queue) => {
       }
       return recurse(value);
     });
-    if (Entity.getKind(entry.schema) === "relation") {
-      const sourceDxn = resolveId(data2.source);
-      if (!sourceDxn) {
+    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: 193, S: void 0 });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 196, S: this });
       }
-      const targetDxn = resolveId(data2.target);
-      if (!targetDxn) {
+      targetUri = resolveId(data2.target);
+      if (!targetUri) {
         log.warn("target not found", {
           target: data2.target
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 199, S: void 0 });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 202, S: this });
       }
       delete data2.source;
       delete data2.target;
-      data2[RelationSourceDXNId] = sourceDxn;
-      data2[RelationTargetDXNId] = targetDxn;
     }
     return {
       data: data2,
-      schema: entry.schema
+      schema: entry.schema,
+      sourceUri,
+      targetUri
     };
   }).filter((object) => !existingIds.has(object.data.id));
-  const dbObjects = await db.query(Query2.select(Filter.id(...existingIds))).run();
-  const queueObjects = await queue?.getObjectsById([
-    ...existingIds
-  ]) ?? [];
+  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,
-    ...queueObjects
+    ...feedObjects
   ].filter(isNonNullable);
   log.info("objects", {
     dbObjects,
-    queueObjects,
+    feedObjects,
     existingIds
-  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 223, S: void 0 });
+  }, { "~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 }) => {
+  return res.flatMap(({ data: data2, schema, sourceUri, targetUri }) => {
     let skip = false;
-    if (RelationSourceDXNId in data2) {
-      const id = data2[RelationSourceDXNId].asEchoDXN()?.echoId;
-      const obj = objects.find((object) => object.id === id) ?? enitties.get(id);
+    if (sourceUri) {
+      const id = EID.getEntityId(sourceUri);
+      const obj = objects.find((object) => object.id === id) ?? (id ? enitties.get(id) : void 0);
       if (obj) {
-        delete data2[RelationSourceDXNId];
-        data2[RelationSourceId] = obj;
+        data2[Relation.Source] = obj;
       } else {
         skip = true;
       }
     }
-    if (RelationTargetDXNId in data2) {
-      const id = data2[RelationTargetDXNId].asEchoDXN()?.echoId;
-      const obj = objects.find((object) => object.id === id) ?? enitties.get(id);
+    if (targetUri) {
+      const id = EID.getEntityId(targetUri);
+      const obj = objects.find((object) => object.id === id) ?? (id ? enitties.get(id) : void 0);
       if (obj) {
-        delete data2[RelationTargetDXNId];
-        data2[RelationTargetId] = obj;
+        data2[Relation.Target] = obj;
       } else {
         skip = true;
       }
@@ -773,7 +794,7 @@ var sanitizeObjects = async (types, data, db, queue) => {
     }
     return [];
   });
-};
+});
 var SoftRef = Schema.Struct({
   "/": Schema.String
 }).annotations({
@@ -789,9 +810,9 @@ var preprocessSchema = (schema) => {
     if (SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option.isSome)) {
       return SoftRef.ast;
     }
-    return mapAst(ast, (child) => go(child, visited));
+    return SchemaEx.mapAst(ast, (child) => go(child, visited));
   };
-  return Schema.make(mapAst(schema.ast, (ast) => go(ast))).pipe(Schema.omit("id"), Schema.extend(Schema.Struct({
+  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."
     })
@@ -806,8 +827,154 @@ var preprocessSchema = (schema) => {
 };
 
 // src/functions/agent/index.ts
-import { OperationHandlerSet as OperationHandlerSet9 } from "@dxos/compute";
-var AgentHandlers = OperationHandlerSet9.lazy(() => import("./prompt-4UMXX6QU.mjs"));
+import { OperationHandlerSet as OperationHandlerSet10 } from "@dxos/compute";
+var AgentHandlers = OperationHandlerSet10.lazy(() => import("./prompt-QL7TTLM3.mjs"));
+
+// src/supervisor/delegation-strategy.ts
+import * as Cause from "effect/Cause";
+import * as Effect2 from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { AiContext } from "@dxos/assistant";
+import { Routine } 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 { EffectEx } from "@dxos/effect";
+import { log as log2 } 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;
+  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);
+      return chatFeed.id === feed.id;
+    }).pipe(Effect2.orElseSucceed(() => false));
+    if (matches) {
+      return agent;
+    }
+  }
+  return void 0;
+});
+var formatResult = (value) => typeof value === "string" ? value : JSON.stringify(value);
+var extractArtifactIds = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return [];
+  }
+  const record = value;
+  const ids = Array.isArray(record.artifactIds) ? record.artifactIds : typeof record.artifactId === "string" ? [
+    record.artifactId
+  ] : [];
+  return ids.filter((id) => typeof id === "string");
+};
+var makeDelegationStrategy = () => ({
+  reconcile: (feed, activeIds) => Effect2.gen(function* () {
+    const agent = yield* findAgentForFeed(feed);
+    if (!agent) {
+      return [];
+    }
+    const plan = yield* Database2.load(agent.plan).pipe(Effect2.orElseSucceed(() => void 0));
+    if (!plan) {
+      return [];
+    }
+    const pending = plan.tasks.filter((task) => task.delegated === true && task.status === "in-progress" && !activeIds.has(task.id));
+    if (pending.length === 0) {
+      return [];
+    }
+    const inheritedBlueprints = yield* Effect2.gen(function* () {
+      const runtime2 = yield* Effect2.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));
+    const delegations = [];
+    for (const task of pending) {
+      const routine = yield* Database2.add(Routine.make({
+        name: task.title,
+        instructions: trim10`
+              Complete the following task and report the result concisely.
+
+              If you create any documents or artifacts, call completeJob with a JSON object of the
+              form { "summary": string, "artifactIds": string[] }, where artifactIds are the exact
+              ids returned by the tools that created them. Otherwise return a short summary string.
+
+              Task: ${task.title}
+            `,
+        blueprints
+      }));
+      delegations.push({
+        id: task.id,
+        spawn: Effect2.gen(function* () {
+          const invoker = yield* ProcessManager.ProcessOperationInvoker.Service;
+          const fiber = yield* invoker.invokeFiber(AgentPrompt, {
+            prompt: Ref8.make(routine),
+            input: {}
+          });
+          return fiber.pid;
+        })
+      });
+    }
+    return delegations;
+  }),
+  onComplete: (feed, id, exit) => Effect2.gen(function* () {
+    const agent = yield* findAgentForFeed(feed);
+    const plan = agent ? yield* Database2.load(agent.plan).pipe(Effect2.orElseSucceed(() => void 0)) : void 0;
+    let title = id;
+    if (plan) {
+      Obj.update(plan, (plan2) => {
+        const task = plan2.tasks.find((task2) => task2.id === id);
+        if (task) {
+          task.status = Exit.isSuccess(exit) ? "done" : "failed";
+          title = task.title;
+        }
+      });
+    }
+    const artifactRefs = [];
+    if (agent && Exit.isSuccess(exit)) {
+      for (const artifactId of extractArtifactIds(exit.value)) {
+        const ref = yield* Agent_exports.addArtifact(agent, {
+          name: title,
+          id: artifactId
+        }).pipe(Effect2.orElseSucceed(() => void 0));
+        if (ref) {
+          artifactRefs.push(ref);
+        }
+      }
+    }
+    const failureCause = Exit.isFailure(exit) ? Cause.pretty(exit.cause) : void 0;
+    if (failureCause) {
+      log2.warn("sub-agent failed", {
+        taskId: id,
+        title,
+        cause: failureCause
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 149, 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 = [
+      {
+        _tag: "text",
+        text
+      },
+      ...artifactRefs.map((reference) => ({
+        _tag: "reference",
+        reference
+      }))
+    ];
+    yield* Feed2.append(feed, [
+      Message.make({
+        sender: "assistant",
+        blocks
+      })
+    ]);
+  })
+});
 
 // src/toolkits/WebToolkit.ts
 var WebToolkit_exports = {};
@@ -818,8 +985,9 @@ __export(WebToolkit_exports, {
 import * as AnthropicTool2 from "@effect/ai-anthropic/AnthropicTool";
 import * as Tool2 from "@effect/ai/Tool";
 import * as Toolkit3 from "@effect/ai/Toolkit";
-import * as Effect2 from "effect/Effect";
+import * as Effect3 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
@@ -827,77 +995,70 @@ var WebToolkit = Toolkit3.make(AnthropicTool2.WebSearch_20250305({}).pipe(), Too
   success: Schema2.String
 }));
 var layer = WebToolkit.toLayer({
-  WebFetch: Effect2.fnUntraced(function* ({ url }) {
-    const response = yield* Effect2.promise(() => fetch(url).then((response2) => response2.text()));
-    return response;
+  WebFetch: Effect3.fnUntraced(function* ({ url }) {
+    return yield* Effect3.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(Effect3.catchAll((err) => Effect3.succeed(err.message)));
   })
 });
 export {
-  AddArtifact,
   Agent_exports as Agent,
   blueprint_default as AgentBlueprint,
   AgentBlueprintHandlers,
+  definitions_exports as AgentBlueprintOperations,
   AgentHandlers,
   AgentPrompt,
-  AgentRules,
-  blueprint_default11 as AgentWizardBlueprint,
+  blueprint_default2 as AgentWizardBlueprint,
   AgentWizardHandlers,
-  AgentWorker,
-  blueprint_default9 as AutomationBlueprint,
-  blueprint_default10 as BlueprintManagerBlueprint,
+  definitions_exports2 as AgentWizardOperations,
+  blueprint_default3 as AutomationBlueprint,
+  blueprint_default4 as BlueprintManagerBlueprint,
   BlueprintManagerHandlers,
-  blueprint_default6 as BrowserBlueprint,
+  definitions_exports3 as BlueprintManagerOperations,
+  blueprint_default5 as BrowserBlueprint,
   Chat_exports as Chat,
-  ContextAdd,
-  ContextRemove,
-  CreateAgent,
-  blueprint_default7 as DatabaseBlueprint,
+  blueprint_default6 as DatabaseBlueprint,
   DatabaseHandlers,
-  Load as DatabaseLoad,
-  Query as DatabaseQuery,
-  DeleteMemory,
-  blueprint_default2 as DiscordBlueprint,
+  definitions_exports4 as DatabaseOperations,
+  blueprint_default7 as DelegationBlueprint,
+  DelegationHandlers,
+  delegate_task_exports as DelegationOperations,
+  blueprint_default8 as DiscordBlueprint,
   DiscordHandlers,
-  EnableBlueprints,
-  FetchMessages,
-  GetContext,
-  blueprint_default3 as LinearBlueprint,
+  definitions_exports5 as DiscordOperations,
+  blueprint_default9 as LinearBlueprint,
   LinearHandlers,
+  definitions_exports6 as LinearOperations,
   LocalSearchHandler,
   LocalSearchToolkit,
   McpServer_exports as McpServer,
   Memory_exports as Memory,
-  blueprint_default8 as MemoryBlueprint,
+  blueprint_default10 as MemoryBlueprint,
   MemoryHandlers,
-  ObjectCreate,
-  ObjectDelete,
-  ObjectUpdate,
+  definitions_exports7 as MemoryOperations,
   Plan_exports as Plan,
-  blueprint_default4 as PlanningBlueprint,
+  blueprint_default11 as PlanningBlueprint,
   PlanningHandlers,
-  UpdateTasks as PlanningUpdateTasks,
-  Qualifier,
-  QueryBlueprints,
-  QueryMemories,
-  RelationCreate,
-  RelationDelete,
-  SaveMemory,
-  SchemaAdd,
-  SchemaList,
+  update_tasks_exports as PlanningOperations,
   Subgraph,
-  SyncIssues,
-  SyncTriggers,
-  TagAdd,
-  TagRemove,
-  blueprint_default5 as WebSearchBlueprint,
-  Fetch as WebSearchFetch,
+  blueprint_default12 as WebSearchBlueprint,
   WebSearchHandlers,
+  definitions_exports8 as WebSearchOperations,
   WebSearchToolkit,
   WebSearchToolkitOpaque,
   WebToolkit_exports as WebToolkit,
   createExtractionSchema,
   findRelatedSchema,
   getSanitizedSchemaName,
+  makeDelegationStrategy,
   makeGraphWriterHandler,
   makeGraphWriterToolkit,
   sanitizeObjects,