@dxos/assistant 0.14.0 → 0.16.0

package/dist/lib/session/SkillHooks.mjs

@@ -1,47 +1 @@
-import { t as __exportAll } from "../chunk-rolldown-runtime.mjs";
-import * as Effect from "effect/Effect";
-import * as Operation from "@dxos/compute/Operation";
-import { Database, Obj } from "@dxos/echo";
-import { invariant } from "@dxos/invariant";
-import { log } from "@dxos/log";
-//#region src/session/SkillHooks.ts
-var SkillHooks_exports = /* @__PURE__ */ __exportAll({ runHooks: () => runHooks });
-var __dxlog_file = "/__w/dxos/dxos/packages/core/compute/assistant/src/session/SkillHooks.ts";
-/**
-* Runs every {@link Skill.Hook} on `skills` whose spec matches `phase`. Each hook resolves its
-* `function` ref to a {@link Operation.PersistentOperation}, deserializes it to a definition, and
-* invokes it with the templated `input` via `invoke`. Hooks without a function ref are skipped.
-*
-* Hook failures are isolated: a throwing hook logs and is swallowed so one skill's hook cannot
-* abort the request lifecycle (or the sibling hooks).
-*/
-var runHooks = ({ skills, phase, invoke }) => Effect.gen(function* () {
-	for (const skill of skills) for (const hook of skill.hooks ?? []) {
-		if (hook.spec._tag !== phase) continue;
-		if (!hook.function) continue;
-		yield* Effect.gen(function* () {
-			const record = yield* Database.load(hook.function);
-			invariant(Obj.instanceOf(Operation.PersistentOperation, record), "Hook function must be an operation.", {
-				"~LogMeta": "~LogMeta",
-				F: __dxlog_file,
-				L: 61,
-				S: this,
-				A: ["Obj.instanceOf(Operation.PersistentOperation, record)", "'Hook function must be an operation.'"]
-			});
-			yield* invoke(Operation.deserialize(record), { ...hook.input }, hook);
-		}).pipe(Effect.catchCause((cause) => Effect.sync(() => log.warn("skill hook failed", {
-			phase,
-			skill: Obj.getMeta(skill).key,
-			cause
-		}, {
-			"~LogMeta": "~LogMeta",
-			F: __dxlog_file,
-			L: 70,
-			S: this
-		}))));
-	}
-});
-//#endregion
-export { runHooks, SkillHooks_exports as t };
-
-//# sourceMappingURL=SkillHooks.mjs.map
+export { n as runHooks } from "../chunk-SkillHooks.mjs";

package/dist/lib/types/Agent.mjs

@@ -1,202 +1 @@
-import { t as __exportAll } from "../chunk-rolldown-runtime.mjs";
-import { r as HarnessContextError } from "../chunk-errors.mjs";
-import { Chat, linkCompanion, make } from "./Chat.mjs";
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import { Annotation, DXN, Database, Feed, Filter, Obj, Ref, Type } from "@dxos/echo";
-import { IdentityDid } from "@dxos/keys";
-import * as Skill from "@dxos/compute/Skill";
-import * as EffectEx from "@dxos/effect/EffectEx";
-import * as Instructions from "@dxos/compute/Instructions";
-//#region src/types/Agent.ts
-var Agent_exports = /* @__PURE__ */ __exportAll({
-	Agent: () => Agent,
-	chatLocation: () => chatLocation,
-	getFromChatContext: () => getFromChatContext,
-	isAgentChat: () => isAgentChat,
-	loadChat: () => loadChat,
-	loadForChat: () => loadForChat,
-	loadInstructions: () => loadInstructions,
-	makeInitialized: () => makeInitialized,
-	resetChatHistory: () => resetChatHistory
-});
-/**
-* An agent identity: a personality (attribution DID) plus its preset payload (instructions with
-* text, skills, objects, and commands). Owns no conversation state — a chat is linked to the agent
-* it runs as by the ECHO parent edge (the agent parents its chats), and durable work products live on a Project
-* (plugin-projects DESIGN.md, "Agent ↔ Project convergence").
-*/
-/**
-* The AI session runtime (MCP SDK, Anthropic client, ~280 KB) is loaded lazily: this module holds
-* the Agent *schema*, which core plugins reference for operation definitions, so the runtime loads
-* only when an agent operation actually runs.
-*/
-var aiContextRuntime = () => import("../session/AiContext.mjs");
-var harnessRuntime = () => import("../session/Harness.mjs");
-var Agent = class extends Type.makeObject(DXN.make("org.dxos.type.agent", "0.2.0"))(Schema.Struct({
-	name: Schema.optional(Schema.String),
-	/**
-	* Stable identity DID for the agent, used to attribute content it authors (e.g. suggestion
-	* branches) as its own author — distinct from any human or other agent. Provisioned
-	* externally, never minted by {@link makeInitialized} (see the note there); the slot a real
-	* HALO identity DID takes once agents get first-class identities. Optional because nothing
-	* populates it yet.
-	*/
-	did: Schema.optional(IdentityDid.annotate({
-		title: "DID",
-		description: "The agent's identity DID; attributes content the agent authors."
-	})).annotate({
-		title: "DID",
-		description: "The agent's DID."
-	}),
-	/**
-	* Master switch for the agent's automation (propagated onto its compiled routine triggers).
-	*/
-	enabled: Schema.optional(Schema.Boolean).annotate({
-		title: "Enabled",
-		description: "Master switch for agent automation; propagated to all triggers on sync."
-	}),
-	/**
-	* Instructions for the agent — the preset payload (text, skills, objects, commands) a chat
-	* receives when the agent is applied to it. Owned: `SetParent` cascades it with the agent.
-	*/
-	instructions: Ref.Ref(Instructions.Instructions).pipe(Annotation.SetParent.set(), Annotation.FormInlineAnnotation.set(true), Schema.annotate({ title: "Instructions" }))
-}).pipe(Annotation.LabelAnnotation.set(["name"]), Annotation.IconAnnotation.set({
-	icon: "ph--drone--regular",
-	hue: "amber"
-}), Annotation.UserType.set())) {};
-/**
-* Resolves the agent's instructions and their markdown text.
-*/
-var loadInstructions = (agent) => Effect.gen(function* () {
-	const instructions = yield* Database.load(agent.instructions);
-	return {
-		text: yield* Database.load(instructions.text).pipe(Effect.map((doc) => doc.content), Effect.catchTag("EntityNotFoundError", () => Effect.succeed(""))),
-		instructions
-	};
-});
-/**
-* Resolves the agent's primary chat (the agent holds no chat ref): the latest chat parented to the
-* agent. Entity ids are ULIDs, so the id order is creation order — `resetChatHistory` makes the
-* replacement chat primary simply by creating it later.
-*/
-var loadChat = (agent) => Effect.gen(function* () {
-	return (yield* Database.query(Filter.and(Filter.type(Chat), Filter.childOf(agent))).run).filter((chat) => Obj.getMeta(chat).keys.length === 0).sort((left, right) => left.id.localeCompare(right.id)).at(-1);
-}).pipe(Effect.orDie);
-/**
-* Resolves the agent a chat runs as, if any. Plain (agentless) chats yield `undefined`.
-* The parent is loaded with the object, so this is synchronous — no query.
-*/
-var loadForChat = (chat) => Effect.sync(() => {
-	const parent = Obj.getParent(chat);
-	return parent && Obj.instanceOf(Agent, parent) ? parent : void 0;
-});
-/**
-* Where a chat's turns run: as its `remote` flag says, else on EDGE for an agent's chat, since its chats share
-* the agent's one brain, which only EDGE holds. An explicit `remote: false` keeps an agent's chats local, for
-* a runtime with no EDGE to reach (a story or test), where every chat shares the client's brain instead.
-*/
-var chatLocation = (chat) => chat.remote ?? isAgentChat(chat) ? "edge" : "local";
-/** Whether the chat runs as an agent (the agent parents it); synchronous, like {@link loadForChat}. */
-var isAgentChat = (chat) => {
-	const parent = Obj.getParent(chat);
-	return parent !== void 0 && Obj.instanceOf(Agent, parent);
-};
-/**
-* Creates a fully initialized Agent with its first chat and context bindings.
-*
-* @param props - Agent properties including spec, skills, and context objects.
-* @param skill - The skill to use for the agent context: a skill object is cloned into the space, a ref
-*   (e.g. a registry URI) is bound as-is so the agent follows the compiled skill until customized.
-* @returns An Effect that yields the initialized Agent.
-*/
-var makeInitialized = (props, skill) => Effect.gen(function* () {
-	const { skills: propsSkills, contextObjects, ...agentProps } = props;
-	const AiContextRuntime = yield* Effect.promise(aiContextRuntime);
-	const persistedPropsSkills = yield* Effect.all((propsSkills ?? []).map((ref) => {
-		const target = ref.peek();
-		return target !== void 0 ? Database.add(target).pipe(Effect.map((persisted) => Ref.make(persisted))) : Effect.succeed(ref);
-	}));
-	const instructions = yield* Database.add(Instructions.make({
-		text: props.instructions,
-		skills: persistedPropsSkills
-	}));
-	const agent = yield* Database.add(Obj.make(Agent, {
-		...agentProps,
-		instructions: Ref.make(instructions),
-		enabled: props.enabled ?? true
-	}));
-	const feed = yield* Database.add(Feed.make());
-	const runtime = yield* Effect.context();
-	const contextBinder = yield* EffectEx.acquireReleaseResource(() => new AiContextRuntime.Binder({
-		feed,
-		runtime
-	}));
-	const agentSkill = Ref.isRef(skill) ? skill : Ref.make(yield* Database.add(Obj.clone(skill, { deep: "all" })));
-	const chat = yield* Database.add(make({
-		feed: Ref.make(feed),
-		instructions: Ref.make(instructions)
-	}));
-	linkCompanion({
-		chat,
-		subject: agent
-	});
-	yield* Effect.promise(() => contextBinder.bind({
-		skills: [agentSkill, ...persistedPropsSkills],
-		objects: [
-			Ref.make(agent),
-			Ref.make(chat),
-			...contextObjects ?? []
-		]
-	}));
-	return agent;
-}).pipe(Effect.scoped);
-/**
-* Resets the agent's chat history by rebuilding the chat context.
-* Preserves the existing skills and objects from the current chat context.
-*
-* @param agent - The agent whose chat history should be reset. Must have an existing chat.
-* @returns An Effect that resets the chat history.
-*/
-var resetChatHistory = (agent) => Effect.gen(function* () {
-	const existingChat = yield* loadChat(agent);
-	if (!existingChat) return yield* Effect.die(/* @__PURE__ */ new Error("Agent must have an existing chat to reset."));
-	const existingFeed = yield* Database.load(existingChat.feed);
-	const runtime = yield* Effect.context();
-	const AiContextRuntime = yield* Effect.promise(aiContextRuntime);
-	const existingContextBinder = yield* EffectEx.acquireReleaseResource(() => new AiContextRuntime.Binder({
-		feed: existingFeed,
-		runtime
-	}));
-	const skills = existingContextBinder.getSkills().map(Skill.makeRef);
-	const objects = existingContextBinder.getObjects().filter((object) => !Obj.instanceOf(Chat, object)).map((object) => Ref.make(object));
-	const feed = yield* Database.add(Feed.make());
-	const contextBinder = yield* EffectEx.acquireReleaseResource(() => new AiContextRuntime.Binder({
-		feed,
-		runtime
-	}));
-	const chat = yield* Database.add(make({
-		feed: Ref.make(feed),
-		instructions: agent.instructions
-	}));
-	linkCompanion({
-		chat,
-		subject: agent
-	});
-	yield* Effect.promise(() => contextBinder.bind({
-		skills,
-		objects: [...objects, Ref.make(chat)]
-	}));
-}).pipe(Effect.scoped);
-var getFromChatContext = Effect.gen(function* () {
-	const agents = yield* (yield* Effect.promise(harnessRuntime)).queryContext(Filter.type(Agent));
-	if (agents.length !== 1) return yield* Effect.fail(new HarnessContextError({
-		type: "agent",
-		count: agents.length
-	}));
-	return agents[0];
-});
-//#endregion
-export { Agent, chatLocation, getFromChatContext, isAgentChat, loadChat, loadForChat, loadInstructions, makeInitialized, resetChatHistory, Agent_exports as t };
-
-//# sourceMappingURL=Agent.mjs.map
+export { t as Agent, r as chatLocation, i as getFromChatContext, a as isAgentChat, o as loadChat, s as loadForChat, c as loadInstructions, l as makeInitialized, u as resetChatHistory } from "../chunk-Agent.mjs";

package/dist/lib/types/Chat.mjs

@@ -1,258 +1 @@
-import { t as __exportAll } from "../chunk-rolldown-runtime.mjs";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import * as Schema from "effect/Schema";
-import { SessionConfig } from "@dxos/ai";
-import { Annotation, DXN, Database, Feed, Filter, Obj, Ref, Type } from "@dxos/echo";
-import { log } from "@dxos/log";
-import { Task } from "@dxos/types";
-import * as Cause from "effect/Cause";
-import * as Instructions from "@dxos/compute/Instructions";
-import * as Project from "@dxos/compute/Project";
-import { ArchivableAnnotation } from "@dxos/schema";
-//#region src/types/Chat.ts
-var Chat_exports = /* @__PURE__ */ __exportAll({
-	Chat: () => Chat,
-	CompanionChatAnnotation: () => CompanionChatAnnotation,
-	addTask: () => addTask,
-	assignTasks: () => assignTasks,
-	deleteTask: () => deleteTask,
-	feedEntityId: () => feedEntityId,
-	fields: () => fields,
-	formatChecklist: () => formatChecklist,
-	isOpenTask: () => isOpenTask,
-	linkCompanion: () => linkCompanion,
-	loadForFeed: () => loadForFeed,
-	loadTasks: () => loadTasks,
-	make: () => make,
-	peekProject: () => peekProject,
-	resolveTasks: () => resolveTasks,
-	seedSession: () => seedSession,
-	unassignTasks: () => unassignTasks
-});
-var __dxlog_file = "/__w/dxos/dxos/packages/core/compute/assistant/src/types/Chat.ts";
-/**
-* AI chat session.
-*/
-var Chat = class extends Type.makeObject(DXN.make("org.dxos.type.assistant.chat", "0.2.0"))(Schema.Struct({
-	name: Schema.String.pipe(Schema.optional),
-	viewType: Schema.String.pipe(Schema.optional),
-	/**
-	* Runs this conversation's agent on the edge rather than locally, mirroring a trigger's own
-	* `remote` flag. When unset, the agent runs locally on the client.
-	*/
-	remote: Schema.Boolean.pipe(Schema.annotate({ title: "Remote" }), Schema.optional),
-	/** Message feed, owned by the chat so `SetParent` cascades it. */
-	feed: Ref.Ref(Feed.Feed).pipe(Annotation.SetParent.set(), Annotation.FormInputAnnotation.set(false)),
-	/**
-	* Instructions steering this conversation, rendered into the system prompt at request time.
-	* Held by reference (never copied), so a project's chats follow edits to its instructions.
-	*/
-	instructions: Schema.optional(Ref.Ref(Instructions.Instructions).pipe(Annotation.FormInputAnnotation.set(false))),
-	/**
-	* How this conversation runs (its model), chosen in the chat rather than globally so it survives
-	* a remount and travels with the chat. Unset fields fall back to the project's, then the agent's.
-	*/
-	session: Schema.optional(SessionConfig.SessionConfig.pipe(Annotation.FormInputAnnotation.set(false))),
-	/**
-	* The working checklist, flat and ordered. Deliberately NOT an owning (`SetParent`) field: a
-	* chat may work on a task that belongs somewhere else — a project's task set delegates one here
-	* — and an owning field re-parents every resolved member on each update of the chat, which
-	* would silently move that task out of the set that owns it. Tasks the chat itself creates are
-	* parented to it explicitly; see {@link addTask}.
-	*/
-	tasks: Schema.Array(Ref.Ref(Task.Task)).pipe(Annotation.FormInputAnnotation.set(false))
-}).pipe(Annotation.LabelAnnotation.set(["name"]), Annotation.IconAnnotation.set({
-	icon: "ph--sparkle--regular",
-	hue: "amber"
-}), Annotation.UserType.set(), ArchivableAnnotation.set(true))) {};
-/** Module-level alias so callers importing the namespace avoid the doubled `Chat.Chat.fields`. */
-var fields = Chat.fields;
-var make = (props) => Obj.make(Chat, {
-	...props,
-	tasks: props.tasks ?? []
-});
-/**
-* Refs to the chats accompanying an object, stored on the subject itself (replaces the former
-* `CompanionTo` relation): the annotation is deleted with the subject, and its refs make the
-* parented chats real children — referenced and cascaded — rather than ref-less parent-edge
-* orphans reachable only by index query.
-*/
-var CompanionChatAnnotation = Annotation.make({
-	id: "org.dxos.assistant.companionChats",
-	schema: Schema.Array(Ref.Ref(Chat))
-});
-/**
-* Links a chat to the subject it accompanies (a Project, an Agent, a document, ...): a ref on the
-* subject via {@link CompanionChatAnnotation} plus the ECHO parent edge. Idempotent per chat.
-*/
-var linkCompanion = ({ chat, subject }) => {
-	const existing = Annotation.get(subject, CompanionChatAnnotation);
-	if (!existing.pipe(Option.getOrElse(() => [])).some((ref) => ref.uri === Ref.make(chat).uri)) {
-		if (Option.isNone(existing)) Obj.update(subject, (subject) => {
-			Annotation.set(subject, CompanionChatAnnotation, [Ref.make(chat)]);
-		});
-		else Annotation.update(subject, CompanionChatAnnotation, (chats) => {
-			chats.push(Ref.make(chat));
-		});
-	}
-	Obj.setParent(chat, subject);
-};
-/**
-* Starts a chat on a default session config — a project's, say — copied rather than referenced, so
-* a model later picked in the chat is the chat's own. A chat already carrying a config keeps it.
-*/
-var seedSession = (chat, session) => {
-	if (!session || chat.session) return;
-	Obj.update(chat, (chat) => {
-		chat.session = { ...session };
-	});
-};
-/** Creates a task the chat owns and appends it to the checklist. */
-var addTask = (db, chat, title, props = {}) => {
-	const task = db.add(Task.make({
-		title: title.trim(),
-		status: "todo",
-		...props,
-		[Obj.Parent]: chat
-	}));
-	Obj.update(chat, (chat) => {
-		chat.tasks.push(Ref.make(task));
-	});
-	return task;
-};
-/**
-* Appends existing tasks to the checklist. Ownership is deliberately untouched — the task keeps the
-* parent it arrived with (contrast {@link addTask}, which parents what the chat creates), so a task
-* borrowed from a project's set stays in that set. Refs already on the checklist are skipped.
-* Returns the refs actually appended.
-*/
-var assignTasks = (chat, tasks) => {
-	const added = [];
-	Obj.update(chat, (chat) => {
-		const present = new Set(chat.tasks.map((ref) => Task.refEntityId(ref)).filter((id) => id !== void 0));
-		for (const ref of tasks) {
-			const id = Task.refEntityId(ref);
-			if (id === void 0 || present.has(id)) continue;
-			present.add(id);
-			added.push(ref);
-		}
-		chat.tasks.push(...added);
-	});
-	return added;
-};
-/**
-* Takes tasks off the checklist without destroying them — the inverse of {@link assignTasks}, and
-* distinct from {@link deleteTask}, which also removes the members the chat owns. Returns the refs
-* actually removed.
-*/
-var unassignTasks = (chat, tasks) => {
-	const ids = new Set(tasks.map((ref) => Task.refEntityId(ref)).filter((id) => id !== void 0));
-	const removed = chat.tasks.filter((ref) => {
-		const id = Task.refEntityId(ref);
-		return id !== void 0 && ids.has(id);
-	});
-	if (removed.length > 0) Obj.update(chat, (chat) => {
-		chat.tasks = chat.tasks.filter((ref) => {
-			const id = Task.refEntityId(ref);
-			return id === void 0 || !ids.has(id);
-		});
-	});
-	return [...removed];
-};
-/**
-* Remove a task and its sub-tasks from `tasks`, the chat's checklist loaded in full (see
-* {@link loadTasks}) — an unloaded child is invisible to the walk and would be left orphaned in
-* the array. Returns everything dropped from the checklist.
-*
-* Only members the chat owns are destroyed: a delegated task belongs to the set that parents it,
-* so taking it off this checklist must not delete it from there.
-*/
-var deleteTask = (db, chat, tasks, task) => {
-	const subtree = Task.subtree(tasks, task);
-	const ids = new Set(subtree.map((member) => member.id));
-	Obj.update(chat, (chat) => {
-		chat.tasks = chat.tasks.filter((ref) => {
-			const id = Task.refEntityId(ref);
-			return id === void 0 || !ids.has(id);
-		});
-	});
-	for (const member of subtree) if (Obj.getParent(member)?.id === chat.id) db.remove(member);
-	return subtree;
-};
-/** The chat's feed entity id, readable without resolving the ref. */
-var feedEntityId = (chat) => Task.refEntityId(chat.feed);
-/**
-* The chat that owns `feed`. The chat owns its feed (`SetParent`), so the parent edge answers this
-* without a query; the scan is the fallback for a feed whose parent was never stamped.
-*/
-var loadForFeed = (feed) => Effect.gen(function* () {
-	const parent = Obj.getParent(feed);
-	if (parent && Obj.instanceOf(Chat, parent)) return parent;
-	return (yield* Database.query(Filter.type(Chat)).run).find((chat) => feedEntityId(chat) === feed.id);
-}).pipe(Effect.catchCause((cause) => Effect.sync(() => {
-	log.warn("chat lookup failed; treating feed as chat-less", {
-		feed: feed.id,
-		cause: Cause.pretty(cause)
-	}, {
-		"~LogMeta": "~LogMeta",
-		F: __dxlog_file,
-		L: 238,
-		S: void 0
-	});
-})));
-/** Bound on the parent walk below; a conversation sits one or two edges under its project. */
-var MAX_OWNER_DEPTH = 8;
-/**
-* The project a conversation belongs to, if any.
-*
-* Walks the parent chain rather than reading the immediate parent, because a chat reaches its project
-* through whatever owns it — directly for a project chat, through the agent for an agent's chat.
-*/
-var peekProject = (chat) => {
-	let owner = Obj.getParent(chat);
-	for (let depth = 0; owner && depth < MAX_OWNER_DEPTH; depth++) {
-		if (Obj.instanceOf(Project.Project, owner)) return owner;
-		owner = Obj.getParent(owner);
-	}
-};
-/** Loads the checklist in order, de-duplicated: a concurrent merge can land the same ref twice. */
-var loadTasks = (chat) => Effect.gen(function* () {
-	const tasks = yield* Effect.forEach(chat.tasks, (task) => Database.load(task).pipe(Effect.orElseSucceed(() => void 0)));
-	return Task.dedupeById(tasks);
-});
-/** Sync twin of {@link loadTasks}; an unresolved ref contributes nothing rather than throwing. */
-var resolveTasks = (chat) => Task.dedupeById(chat.tasks.filter((ref) => ref.isAvailable).map((ref) => ref.target));
-/** A task is open until it reaches a terminal status. */
-var isOpenTask = (task) => (task.status ?? "todo") === "todo" || task.status === "started";
-/**
-* The conversation's tasks rendered as a numbered checklist (the format the planning prompts
-* speak), or a placeholder when none exist. Ordinals match the task list UI, and non-default
-* status/dependencies are noted so the model can reason about readiness.
-*/
-var formatChecklist = (chat) => Effect.gen(function* () {
-	const tasks = yield* loadTasks(chat);
-	if (tasks.length === 0) return "No checklist found.";
-	return formatTasks(tasks);
-});
-/**
-* Renders tasks as `1. [ ] Title` lines, ordinals in checklist order, each followed by an indented
-* note line carrying the task's ref and any status/dependency notes — appended to the title, models
-* paste the notes back into it. The ref renders as `[MNEMONIC](uri)` so the mnemonic the user reads
-* and the handle the tools take travel together and get pasted back verbatim.
-*/
-var formatTasks = (tasks) => {
-	const ordinals = new Map(tasks.map((task, index) => [task.id, index + 1]));
-	return tasks.map((task, index) => {
-		const line = `${index + 1}. [${task.status === "done" ? "x" : " "}] ${task.title}`;
-		const notes = [`ref: [${Obj.getMnemonic(task)}](${Obj.getURI(task)})`];
-		if (task.status && task.status !== "todo" && task.status !== "done") notes.push(task.status);
-		const deps = (task.dependsOn ?? []).map((ref) => ref.target).filter((target) => target !== void 0).map((target) => ordinals.get(target.id) ?? target.title);
-		if (deps.length > 0) notes.push(`depends on ${deps.join(", ")}`);
-		return `${line}\n   (${notes.join("; ")})`;
-	}).join("\n");
-};
-//#endregion
-export { Chat, CompanionChatAnnotation, addTask, assignTasks, deleteTask, feedEntityId, fields, formatChecklist, isOpenTask, linkCompanion, loadForFeed, loadTasks, make, peekProject, resolveTasks, seedSession, Chat_exports as t, unassignTasks };
-
-//# sourceMappingURL=Chat.mjs.map
+export { t as Chat, r as CompanionChatAnnotation, i as addTask, a as assignTasks, o as deleteTask, s as feedEntityId, c as fields, l as formatChecklist, u as isOpenTask, d as linkCompanion, f as loadForFeed, p as loadTasks, m as make, h as peekProject, g as resolveTasks, _ as seedSession, v as unassignTasks } from "../chunk-Chat.mjs";