@dxos/assistant-toolkit 0.10.0 → 0.11.0

package/dist/lib/index.mjs

@@ -0,0 +1,614 @@
+import { t as skill } from "./chunk-agent.mjs";
+import { c as peekOutlineRef, n as Chat_exports, t as Chat } from "./chunk-Chat.mjs";
+import { a as loadForChat, r as Agent_exports, t as McpServer_exports } from "./chunk-types.mjs";
+import { n as Memory_exports } from "./chunk-Memory.mjs";
+import { A as SkillManagerHandlers, B as CreateAgent, C as RelationCreate, D as TagAdd, E as SchemaList, F as GetCurrentDate, H as definitions_exports$1, I as SetAlarm, K as definitions_exports, L as definitions_exports$2, M as QuerySkills, N as definitions_exports$9, O as TagRemove, P as AlarmHandlers, R as AgentWizardHandlers, S as Query$1, T as SchemaAdd, U as AgentSkillHandlers, V as SyncAutomation, _ as ContextRemove, a as UpdateTasks, b as ObjectDelete, c as DeleteMemory, d as definitions_exports$6, f as DelegationHandlers, g as ContextAdd, h as DatabaseHandlers, i as PlanReminder, j as EnableSkills, k as definitions_exports$3, l as QueryMemories, m as delegate_task_exports, n as RunInstructions, o as definitions_exports$7, p as DelegateTask, r as PlanningHandlers, s as MemoryHandlers, t as AgentHandlers, u as SaveMemory, v as Load, w as RelationDelete, x as ObjectUpdate, y as ObjectCreate, z as AgentRules } from "./chunk-operations.mjs";
+import { r as definitions_exports$4, t as FetchMessages } from "./chunk-definitions.mjs";
+import { n as SyncIssues, r as definitions_exports$5, t as syncObjects } from "./chunk-sync.mjs";
+import { n as ArtifactList, r as definitions_exports$8, t as ArtifactAdd } from "./chunk-definitions2.mjs";
+import { n as definitions_exports$10, t as Fetch } from "./chunk-definitions3.mjs";
+import { Instructions, Operation, OperationHandlerSet, Skill, Template, Trigger } from "@dxos/compute";
+import { trim } from "@dxos/util";
+import { AnthropicWebSearchTool, OpaqueToolkit } from "@dxos/ai";
+import { AiContext } from "@dxos/assistant";
+import { Database, Feed, Filter, Obj, Query, Ref, Type } from "@dxos/echo";
+import { DXN as DXN$1, EID, EntityId } from "@dxos/keys";
+import * as Effect from "effect/Effect";
+import { EffectEx } from "@dxos/effect";
+import { Message, Outline, Task } from "@dxos/types";
+import { Text } from "@dxos/schema";
+import * as Toolkit from "@effect/ai/Toolkit";
+import * as Layer from "effect/Layer";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import { ProcessManager } from "@dxos/compute-runtime";
+import { log } from "@dxos/log";
+//#region src/skills/agent-wizard/skill.ts
+var SKILL_KEY$13 = "org.dxos.skill.agentWizard";
+/**
+* Creates the Agent Wizard skill. This is a function to avoid circular dependency issues.
+*/
+var make$13 = () => Skill.make({
+	key: SKILL_KEY$13,
+	name: "Agent Wizard",
+	description: "Help the user create a new agent (subscriptions and optional cron compile to routines).",
+	agentCanEnable: true,
+	instructions: Template.make({ source: trim`
+        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).
+        Agents can subscribe to emails, and durable work products belong to a project's artifacts.
+
+        Automation (subscriptions and an optional cron schedule) is compiled into routines, not stored
+        on the agent: pass subscriptions when creating the agent, and use the sync-automation tool with
+        the FULL desired config to change automation later (a cron expression schedules periodic wakes,
+        e.g. \`0 9 * * *\` for daily at 09:00; \`enabled\` on the agent is applied to every trigger).
+
+        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, you MUST call sync-automation afterward so triggers pick it up.
+
+        IMPORTANT: Before attempting to create an agent call the [agent-rules] tool to get the rules for creating an agent.
+      ` }),
+	tools: Skill.toolDefinitions({ operations: [
+		AgentRules,
+		CreateAgent,
+		SyncAutomation
+	] })
+});
+var skill$1 = {
+	key: SKILL_KEY$13,
+	make: make$13
+};
+//#endregion
+//#region src/skills/alarm/skill.ts
+var SKILL_KEY$12 = "org.dxos.skill.alarm";
+var instructions$8 = trim`
+  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 make$12 = () => Skill.make({
+	key: SKILL_KEY$12,
+	name: "Alarm",
+	description: "Schedule a self-wake and inspect the current time.",
+	agentCanEnable: true,
+	instructions: { source: Ref.make(Text.make({ content: instructions$8 })) },
+	tools: Skill.toolDefinitions({ operations: [SetAlarm, GetCurrentDate] })
+});
+var skill$2 = {
+	key: SKILL_KEY$12,
+	make: make$12
+};
+//#endregion
+//#region src/skills/automation/skill.ts
+var SKILL_KEY$11 = "org.dxos.skill.automation";
+var instructions$7 = trim`
+  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 ${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.
+
+  ## 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: { '/': '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 skill 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 make$11 = () => Skill.make({
+	key: SKILL_KEY$11,
+	name: "Triggers",
+	description: "Trigger management and automation.",
+	instructions: { source: Ref.make(Text.make({ content: instructions$7 })) }
+});
+var skill$3 = {
+	key: SKILL_KEY$11,
+	make: make$11
+};
+//#endregion
+//#region src/skills/skill-manager/skill.ts
+var SKILL_KEY$10 = "org.dxos.skill.skillManager";
+var make$10 = () => Skill.make({
+	key: SKILL_KEY$10,
+	name: "Skill Manager",
+	description: "Query and enable skills in the current conversation.",
+	instructions: Template.make({
+		source: trim`
+        The list below is the current set of available skills — it is rendered fresh into this prompt,
+        so do NOT call [query-skills] to obtain it. Call [enable-skills] directly with the keys you
+        need; only skills marked [agent-can-enable] can be enabled by the agent.
+        Reach for [query-skills] only to re-read the list after something has changed it.
+
+        <available_skills>
+        {{#each skills}}
+        - {{key}} "{{name}}"{{#if description}} -- {{description}}{{/if}}{{#if agentCanEnable}} [agent-can-enable]{{/if}}
+        {{/each}}
+        </available_skills>
+
+        NOTE: A skill's tools only appear once it is enabled. Skills already enabled in this
+        conversation expose their tools to you directly — do not re-enable a skill whose tools you
+        can already see.
+      `,
+		inputs: [{
+			name: "skills",
+			kind: "operation",
+			operation: DXN$1.getName(QuerySkills.meta.key)
+		}]
+	}),
+	tools: Skill.toolDefinitions({ operations: [QuerySkills, EnableSkills] })
+});
+var skill$13 = {
+	key: SKILL_KEY$10,
+	make: make$10
+};
+//#endregion
+//#region src/skills/browser/skill.ts
+var SKILL_KEY$9 = "org.dxos.skill.browser";
+var instructions$6 = trim`
+  You are able to connect and use a virtual browser with persistent session.
+  Browser tools are provided via MCP.
+`;
+var make$9 = () => Skill.make({
+	key: SKILL_KEY$9,
+	name: "Browser",
+	description: "Access to a real isolated browser.",
+	agentCanEnable: true,
+	instructions: { source: Ref.make(Text.make({ content: instructions$6 })) },
+	mcpServers: [{
+		url: "https://playwright-mcp-example.dxos.workers.dev/sse",
+		protocol: "sse"
+	}]
+});
+var skill$4 = {
+	key: SKILL_KEY$9,
+	make: make$9
+};
+//#endregion
+//#region src/skills/connectors/skill.ts
+var SKILL_KEY$8 = "org.dxos.skill.connectors";
+/**
+* Instructs the model to surface a connector prompt when a request needs a service the user has not
+* connected, rather than failing silently. The prompt is rendered inline in the conversation by the
+* `integration-prompt` surface, which offers to authenticate the matching connector.
+*/
+var instructions$5 = trim`
+  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 make$8 = () => Skill.make({
+	key: SKILL_KEY$8,
+	name: "Connectors",
+	description: "Prompt the user to connect external services when a connector is required but unavailable.",
+	agentCanEnable: true,
+	instructions: { source: Ref.make(Text.make({ content: instructions$5 })) }
+});
+var skill$5 = {
+	key: SKILL_KEY$8,
+	make: make$8
+};
+//#endregion
+//#region src/skills/database/skill.ts
+var SKILL_KEY$7 = "org.dxos.skill.database";
+var instructions$4 = trim`
+  You can query, create, update, and delete objects in ECHO.
+  You can manage schemas, relations, tags, and add objects to the chat context.
+`;
+var make$7 = () => Skill.make({
+	key: SKILL_KEY$7,
+	name: "Database",
+	description: "Query and manipulate objects in the ECHO database.",
+	agentCanEnable: true,
+	instructions: { source: Ref.make(Text.make({ content: instructions$4 })) },
+	tools: Skill.toolDefinitions({ operations: [
+		ContextAdd,
+		ContextRemove,
+		Load,
+		ObjectCreate,
+		ObjectDelete,
+		ObjectUpdate,
+		Query$1,
+		RelationCreate,
+		RelationDelete,
+		SchemaAdd,
+		SchemaList,
+		TagAdd,
+		TagRemove
+	] })
+});
+var skill$6 = {
+	key: SKILL_KEY$7,
+	make: make$7
+};
+//#endregion
+//#region src/skills/delegation/skill.ts
+var SKILL_KEY$6 = "org.dxos.skill.delegation";
+var make$6 = () => Skill.make({
+	key: SKILL_KEY$6,
+	name: "Delegation",
+	description: "Delegates work to sub-agents and tracks it as plan tasks.",
+	tools: Skill.toolDefinitions({ operations: [DelegateTask] })
+});
+var skill$7 = {
+	key: SKILL_KEY$6,
+	make: make$6
+};
+//#endregion
+//#region src/skills/discord/skill.ts
+var SKILL_KEY$5 = "org.dxos.skill.discord";
+/**
+* Agent prompt instructions for managing hierarchical task lists.
+*/
+var instructions$3 = trim`
+  You are able to fetch messages from Discord servers.
+
+  Known servers:
+
+  DXOS serverId: 837138313172353095
+`;
+var make$5 = () => Skill.make({
+	key: SKILL_KEY$5,
+	name: "Discord",
+	description: "Discord integration.",
+	instructions: { source: Ref.make(Text.make({ content: instructions$3 })) },
+	tools: Skill.toolDefinitions({ operations: [FetchMessages] })
+});
+var skill$8 = {
+	key: SKILL_KEY$5,
+	make: make$5
+};
+//#endregion
+//#region src/skills/discord/operations/index.ts
+var DiscordHandlers = OperationHandlerSet.lazy(() => import("./chunk-fetch-messages.mjs"));
+//#endregion
+//#region src/skills/linear/skill.ts
+var SKILL_KEY$4 = "org.dxos.skill.linear";
+/**
+* Agent prompt instructions for managing hierarchical task lists.
+*/
+var instructions$2 = trim`
+  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 make$4 = () => Skill.make({
+	key: SKILL_KEY$4,
+	name: "Linear",
+	description: "Syncs Linear workspaces.",
+	instructions: { source: Ref.make(Text.make({ content: instructions$2 })) },
+	tools: Skill.toolDefinitions({ operations: [SyncIssues] })
+});
+var skill$9 = {
+	key: SKILL_KEY$4,
+	make: make$4
+};
+//#endregion
+//#region src/skills/linear/operations/index.ts
+var LinearHandlers = OperationHandlerSet.lazy(() => import("./chunk-sync-issues.mjs"));
+//#endregion
+//#region src/skills/memory/skill.ts
+var SKILL_KEY$3 = "org.dxos.skill.memory";
+var instructions$1 = trim`
+  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.
+
+  When the user asks you to remember something, save it as a memory with a descriptive title.
+  When the user asks about something you might have stored, query your memories first.
+  You can also delete outdated or incorrect memories.
+`;
+var make$3 = () => Skill.make({
+	key: SKILL_KEY$3,
+	name: "Memory",
+	description: "Persistent memory storage and retrieval.",
+	agentCanEnable: true,
+	instructions: { source: Ref.make(Text.make({ content: instructions$1 })) },
+	tools: Skill.toolDefinitions({ operations: [
+		SaveMemory,
+		QueryMemories,
+		DeleteMemory
+	] })
+});
+var skill$10 = {
+	key: SKILL_KEY$3,
+	make: make$3
+};
+//#endregion
+//#region src/skills/planning/skill.ts
+var SKILL_KEY$2 = "org.dxos.skill.planning";
+var make$2 = () => Skill.make({
+	key: SKILL_KEY$2,
+	name: "Planning",
+	description: "Plans and tracks complex tasks using artifacts.",
+	agentCanEnable: true,
+	tools: Skill.toolDefinitions({ operations: [UpdateTasks] }),
+	hooks: [{
+		spec: { _tag: "end-request" },
+		function: Ref.make(Operation.serialize(PlanReminder))
+	}]
+});
+var skill$11 = {
+	key: SKILL_KEY$2,
+	make: make$2
+};
+//#endregion
+//#region src/skills/project/skill.ts
+var SKILL_KEY$1 = "org.dxos.skill.project";
+var instructions = trim`
+  You are working in the context of a project (its reference is bound into this chat).
+  The project owns a collection of artifacts: the durable work products of this project.
+  When you create an object the user asked for (a document, outline, sheet, contact, …), file it
+  into the project's artifacts with the add-artifact tool so the project owns it.
+  When looking for the project's existing material, list its artifacts first rather than searching
+  the whole space.
+`;
+var make$1 = () => Skill.make({
+	key: SKILL_KEY$1,
+	name: "Project",
+	description: "Manage a project's artifacts: file created objects and find existing ones.",
+	agentCanEnable: true,
+	instructions: { source: Ref.make(Text.make({ content: instructions })) },
+	tools: Skill.toolDefinitions({ operations: [ArtifactAdd, ArtifactList] })
+});
+var skill$12 = {
+	key: SKILL_KEY$1,
+	make: make$1
+};
+//#endregion
+//#region src/skills/project/operations/index.ts
+var ProjectHandlers = OperationHandlerSet.lazy(() => import("./chunk-artifact-add.mjs"), () => import("./chunk-artifact-list.mjs"));
+//#endregion
+//#region src/skills/websearch/toolkit.ts
+var WebSearchToolkit = Toolkit.make(AnthropicWebSearchTool);
+var WebSearchToolkitOpaque = OpaqueToolkit.make(WebSearchToolkit, Layer.empty);
+//#endregion
+//#region src/skills/websearch/skill.ts
+var SKILL_KEY = "org.dxos.skill.webSearch";
+var make = () => Skill.make({
+	key: SKILL_KEY,
+	name: "Web Search",
+	description: "Search the web.",
+	agentCanEnable: true,
+	instructions: { source: Ref.make(Text.make()) },
+	tools: Skill.toolDefinitions({
+		operations: [Fetch],
+		tools: [WebSearchToolkit.tools.AnthropicWebSearch.name]
+	})
+});
+var skill$14 = {
+	key: SKILL_KEY,
+	make
+};
+//#endregion
+//#region src/skills/websearch/operations/index.ts
+var WebSearchHandlers = OperationHandlerSet.lazy(() => import("./chunk-fetch.mjs"));
+//#endregion
+//#region src/supervisor/delegation-strategy.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/compute/assistant-toolkit/src/supervisor/delegation-strategy.ts";
+/**
+* Resolves the chat backed by the given conversation feed, if any.
+*/
+var findChatForFeed = (feed) => Effect.gen(function* () {
+	const chats = yield* Database.query(Filter.type(Chat)).run;
+	for (const chat of chats) if (yield* Effect.gen(function* () {
+		return (yield* Database.load(chat.feed)).id === feed.id;
+	}).pipe(Effect.orElseSucceed(() => false))) return chat;
+});
+/**
+* Normalizes an LLM-reported artifact reference (bare entity id or full ECHO URI) to a
+* fully-qualified ref in the current space. Not resolved here — it resolves lazily when read.
+*/
+var resolveArtifactRef = (id) => Effect.gen(function* () {
+	const parsed = EID.tryParse(id);
+	const candidate = (parsed ? EID.getEntityId(parsed) : void 0) ?? id;
+	if (!EntityId.isValid(candidate)) return yield* Effect.fail(/* @__PURE__ */ new Error(`Invalid artifact id: ${id}`));
+	const { db } = yield* Database.Service;
+	return db.makeRef(EID.make({
+		spaceId: db.spaceId,
+		entityId: candidate
+	}));
+});
+/**
+* Renders a sub-agent result for inclusion in a notification message.
+*/
+var formatResult = (value) => typeof value === "string" ? value : JSON.stringify(value);
+/**
+* Extracts artifact ids a sub-agent reported in its result (see the synthesized instructions
+* instructions). Tolerates the result being a string, or an object with `artifactIds`/`artifactId`.
+*/
+var extractArtifactIds = (value) => {
+	if (typeof value !== "object" || value === null) return [];
+	const record = value;
+	return (Array.isArray(record.artifactIds) ? record.artifactIds : typeof record.artifactId === "string" ? [record.artifactId] : []).filter((id) => typeof id === "string");
+};
+/**
+* The durable agent tasks awaiting a sub-agent for this conversation: in-progress children of the
+* working outline's task set whose assignee is an agent. Ordinary checklist items (markdown) are
+* never spawned — delegation happens only through the promotion the delegate-task tool performs.
+*/
+var findPendingTasks = (chat, activeIds) => Effect.gen(function* () {
+	const outlineRef = peekOutlineRef(chat);
+	const outline = outlineRef ? yield* Database.load(outlineRef).pipe(Effect.orElseSucceed(() => void 0)) : void 0;
+	const taskSet = outline?.taskSet ? yield* Database.load(outline.taskSet).pipe(Effect.orElseSucceed(() => void 0)) : void 0;
+	if (!taskSet) return [];
+	return (yield* Database.query(Query.select(Filter.id(taskSet.id)).children()).run.pipe(Effect.orElseSucceed(() => []))).filter((child) => Obj.instanceOf(Task.Task, child) && child.assignee?.role === "assistant" && child.status === "in-progress" && !activeIds.has(child.id));
+});
+/**
+* Supervisor behaviour for the conversational agent: after each turn, every in-progress agent
+* task not already running is run by a sub-agent (a synthesized minimal `Routine` executed via
+* `RunInstructions`); on completion the task status is updated, the checklist line is checked
+* off, and a templated message is posted back to the conversation.
+*/
+var makeDelegationStrategy = () => ({
+	reconcile: (feed, activeIds) => Effect.gen(function* () {
+		const chat = yield* findChatForFeed(feed);
+		if (!chat) return [];
+		const pending = yield* findPendingTasks(chat, activeIds);
+		if (pending.length === 0) return [];
+		const skills = (yield* Effect.gen(function* () {
+			const runtime = yield* Effect.runtime();
+			return (yield* EffectEx.acquireReleaseResource(() => new AiContext.Binder({
+				feed,
+				runtime
+			}))).getSkills().filter((skill) => Obj.getMeta(skill).key !== skill$7.key);
+		}).pipe(Effect.scoped)).map((skill) => Ref.make(skill));
+		const delegations = [];
+		for (const task of pending) {
+			const instructions = yield* Database.add(Instructions.make({
+				name: task.title,
+				text: trim`
+              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}
+            `,
+				skills
+			}));
+			delegations.push({
+				id: task.id,
+				spawn: Effect.gen(function* () {
+					return (yield* (yield* ProcessManager.ProcessOperationInvoker.Service).invokeFiber(RunInstructions, {
+						instructions: Ref.make(instructions),
+						input: {}
+					})).pid;
+				})
+			});
+		}
+		return delegations;
+	}),
+	onComplete: (feed, id, exit) => Effect.gen(function* () {
+		const chat = yield* findChatForFeed(feed);
+		const agent = chat ? yield* loadForChat(chat) : void 0;
+		let title = id;
+		const task = (yield* Database.query(Query.select(Filter.id(id))).run.pipe(Effect.orElseSucceed(() => []))).find((candidate) => Obj.instanceOf(Task.Task, candidate));
+		if (task) {
+			Obj.update(task, (task) => {
+				task.status = Exit.isSuccess(exit) ? "done" : "failed";
+			});
+			title = task.title;
+			if (chat && Exit.isSuccess(exit)) {
+				const outlineRef = peekOutlineRef(chat);
+				const outline = outlineRef ? yield* Database.load(outlineRef).pipe(Effect.orElseSucceed(() => void 0)) : void 0;
+				const text = outline ? yield* Database.load(outline.content).pipe(Effect.orElseSucceed(() => void 0)) : void 0;
+				if (text) Obj.update(text, (text) => {
+					text.content = Outline.upsertChecklistItems(text.content, [{
+						title: task.title,
+						done: true
+					}]);
+				});
+			}
+		}
+		const artifactRefs = [];
+		if (agent && Exit.isSuccess(exit)) for (const artifactId of extractArtifactIds(exit.value)) {
+			const ref = yield* resolveArtifactRef(artifactId).pipe(Effect.orElseSucceed(() => void 0));
+			if (ref) artifactRefs.push(ref);
+		}
+		const failureCause = Exit.isFailure(exit) ? Cause.pretty(exit.cause) : void 0;
+		if (failureCause) log.warn("sub-agent failed", {
+			taskId: id,
+			title,
+			cause: failureCause
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 238,
+			S: this
+		});
+		const blocks = [{
+			_tag: "text",
+			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"}`
+		}, ...artifactRefs.map((reference) => ({
+			_tag: "reference",
+			reference
+		}))];
+		yield* Feed.append(feed, [Message.make({
+			sender: "assistant",
+			blocks
+		})]);
+	})
+});
+//#endregion
+export { Agent_exports as Agent, AgentHandlers, skill as AgentSkill, AgentSkillHandlers, definitions_exports as AgentSkillOperations, AgentWizardHandlers, definitions_exports$1 as AgentWizardOperations, skill$1 as AgentWizardSkill, AlarmHandlers, definitions_exports$2 as AlarmOperations, skill$2 as AlarmSkill, skill$3 as AutomationSkill, skill$4 as BrowserSkill, Chat_exports as Chat, skill$5 as ConnectorsSkill, DatabaseHandlers, definitions_exports$3 as DatabaseOperations, skill$6 as DatabaseSkill, DelegationHandlers, delegate_task_exports as DelegationOperations, skill$7 as DelegationSkill, DiscordHandlers, definitions_exports$4 as DiscordOperations, skill$8 as DiscordSkill, LinearHandlers, definitions_exports$5 as LinearOperations, skill$9 as LinearSkill, McpServer_exports as McpServer, Memory_exports as Memory, MemoryHandlers, definitions_exports$6 as MemoryOperations, skill$10 as MemorySkill, PlanningHandlers, definitions_exports$7 as PlanningOperations, skill$11 as PlanningSkill, ProjectHandlers, definitions_exports$8 as ProjectOperations, skill$12 as ProjectSkill, RunInstructions, SkillManagerHandlers, definitions_exports$9 as SkillManagerOperations, skill$13 as SkillManagerSkill, WebSearchHandlers, definitions_exports$10 as WebSearchOperations, skill$14 as WebSearchSkill, WebSearchToolkit, WebSearchToolkitOpaque, makeDelegationStrategy, syncObjects };
+
+//# sourceMappingURL=index.mjs.map