@dxos/plugin-assistant 0.10.0 → 0.11.1

package/dist/lib/hooks.mjs

@@ -0,0 +1,674 @@
+import { a as resolveProvider, i as presetsForProvider, r as defaultsKeyForProvider, t as AiChatProcessor } from "./chunk-processor.mjs";
+import { n as useChatContext } from "./chunk-context.mjs";
+import { AppCapabilities, AppSpace } from "@dxos/app-toolkit";
+import { AiContext, AiSession } from "@dxos/assistant";
+import { AgentService, Credential, Process, ServiceResolver, Skill, Trace } from "@dxos/compute";
+import { Capabilities } from "@dxos/app-framework";
+import { distinctBy, isTruthy, trim } from "@dxos/util";
+import { Chat } from "@dxos/assistant-toolkit";
+import { AiService, OpaqueToolkit, Provider } from "@dxos/ai";
+import { EffectEx } from "@dxos/effect";
+import { Database, Filter, Obj, Query, Ref, Registry, Type } from "@dxos/echo";
+import { meta } from "#meta";
+import { Atom } from "@effect-atom/atom";
+import { AssistantCapabilities, AssistantOperation, Ollama } from "#types";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { useObject, useQuery } from "@dxos/echo-react";
+import { useAsyncEffect, useTranslation } from "@dxos/react-ui";
+import { Atom as Atom$1, RegistryContext, useAtomValue } from "@effect-atom/atom-react";
+import { log } from "@dxos/log";
+import { MenuBuilder, useMenuBuilder } from "@dxos/react-ui-menu";
+import * as Fiber from "effect/Fiber";
+import * as Stream from "effect/Stream";
+import { useCapabilities, useCapability, useOperationInvoker, useOptionalCapability } from "@dxos/app-framework/ui";
+import { keymap } from "@codemirror/view";
+import { pipe } from "effect/Function";
+import { Selection } from "@dxos/react-ui-attention";
+import { resolveEphemeralStatusUpdate } from "#execution-graph";
+import { Prec } from "@codemirror/state";
+import * as Layer from "effect/Layer";
+import { useClient } from "@dxos/react-client";
+import { invariant } from "@dxos/invariant";
+import { HiddenAnnotation, getTypeAnnotation } from "@dxos/echo/Annotation";
+import { Kind } from "@dxos/echo/Entity";
+import { AttentionCapabilities } from "@dxos/plugin-attention";
+import { FeedTraceSink, ProcessManager } from "@dxos/compute-runtime";
+//#region src/hooks/useSkillRegistry.ts
+var useSkills = ({ registry, db }) => {
+	const [registrySkills, setRegistrySkills] = useState(() => registry?.query(Filter.type(Skill.Skill)).runSync() ?? []);
+	useEffect(() => {
+		if (!registry) {
+			setRegistrySkills([]);
+			return;
+		}
+		setRegistrySkills(registry.query(Filter.type(Skill.Skill)).runSync());
+		return registry.changed.on(() => {
+			setRegistrySkills(registry.query(Filter.type(Skill.Skill)).runSync());
+		});
+	}, [registry]);
+	const spaceSkills = useQuery(db, Filter.type(Skill.Skill));
+	return useMemo(() => {
+		const skills = distinctBy([...registrySkills, ...spaceSkills], (b) => Obj.getMeta(b).key);
+		skills.sort(({ name: a }, { name: b }) => a.localeCompare(b));
+		return skills;
+	}, [registrySkills, spaceSkills]);
+};
+/**
+* Create reactive map of active skills (by key).
+*/
+var useActiveSkills = ({ context }) => {
+	const [active, setActive] = useState(/* @__PURE__ */ new Map());
+	useEffect(() => {
+		if (!context) {
+			setActive(/* @__PURE__ */ new Map());
+			return;
+		}
+		const updateActive = () => {
+			const skills = context.getSkills();
+			setActive(new Map(skills.map((skill) => [Obj.getMeta(skill).key, skill]).filter((entry) => entry[0] !== void 0)));
+		};
+		updateActive();
+		return context.subscribeSkills(updateActive);
+	}, [context]);
+	return active;
+};
+var useSkillHandlers = ({ db, context, registry }) => {
+	return { onUpdateSkill: useCallback(async (key, checked) => {
+		if (!context) return;
+		if (checked) if (registry?.query(Filter.type(Skill.Skill)).runSync().find((b) => Obj.getMeta(b).key === key)) await context.bind({ skills: [Ref.fromURI(Skill.registryURI(key))] });
+		else {
+			const storedSkill = (await db.query(Filter.type(Skill.Skill)).run()).find((skill) => Obj.getMeta(skill).key === key);
+			if (storedSkill) await context.bind({ skills: [Ref.make(storedSkill)] });
+		}
+		else if (registry?.query(Filter.type(Skill.Skill)).runSync().find((b) => Obj.getMeta(b).key === key)) await context.unbind({ skills: [Ref.fromURI(Skill.registryURI(key))] });
+		else {
+			const storedSkill = (await db.query(Filter.type(Skill.Skill)).run()).find((skill) => Obj.getMeta(skill).key === key);
+			if (storedSkill) await context.unbind({ skills: [Ref.make(storedSkill)] });
+		}
+	}, [
+		db,
+		context,
+		registry
+	]) };
+};
+//#endregion
+//#region src/hooks/useChatKeymap.ts
+/**
+* CodeMirror keymap shared by the chat document (Thread) and the prompt editor — pressing
+* Mod-Arrow keys when either editor is focused emits the corresponding `ChatEvent` on the
+* shared event bus.
+*/
+var useChatKeymapExtensions = ({ event }) => {
+	return useMemo(() => {
+		return [Prec.highest(keymap.of([{
+			key: "Mod-ArrowUp",
+			preventDefault: true,
+			run: () => {
+				event.emit({ type: "nav-previous" });
+				return true;
+			},
+			shift: () => {
+				event.emit({ type: "thread-open" });
+				return true;
+			}
+		}, {
+			key: "Mod-ArrowDown",
+			preventDefault: true,
+			run: () => {
+				event.emit({ type: "nav-next" });
+				return true;
+			},
+			shift: () => {
+				event.emit({ type: "thread-close" });
+				return true;
+			}
+		}]))].filter(isTruthy);
+	}, [event]);
+};
+//#endregion
+//#region src/hooks/useChatProcessor.ts
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useChatProcessor.ts";
+/**
+* Configure and create AiChatProcessor.
+*/
+var useChatProcessor = ({ space, chat, preset, runtime, registry, settings }) => {
+	const observableRegistry = useContext(RegistryContext);
+	const [feedSnapshot] = useObject(chat?.feed);
+	const feed = Obj.getReactiveOrUndefined(feedSnapshot);
+	const [session, setSession] = useState();
+	useAsyncEffect(async () => {
+		if (!space || !chat || !feed) return;
+		const runtime = await EffectEx.runAndForwardErrors(Effect.runtime().pipe(Effect.provide(Database.layer(space.db))));
+		const session = new AiSession.Session({
+			feed,
+			runtime,
+			registry: observableRegistry
+		});
+		await session.open();
+		setSession(session);
+		return () => {
+			session.close();
+			setSession(void 0);
+		};
+	}, [
+		space,
+		chat,
+		feed
+	]);
+	const serviceResolver = useCapability(Capabilities.ServiceResolver);
+	return useMemo(() => {
+		if (!runtime || !session || !chat || !feed || !space) return;
+		const spaceLayer = ServiceResolver.provide({ space: space.id }, Database.Service, Credential.CredentialsService, AiService.AiService, AgentService.AgentService, Registry.Service, OpaqueToolkit.OpaqueToolkitProvider).pipe(Layer.provide(Layer.succeed(ServiceResolver.ServiceResolver, serviceResolver)));
+		log("creating processor", {
+			preset,
+			model: preset?.model,
+			settings
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 92,
+			S: void 0
+		});
+		return new AiChatProcessor(session, runtime, feed, spaceLayer, {
+			chat: chat ? Ref.make(chat) : void 0,
+			observableRegistry,
+			registry,
+			model: preset?.model,
+			provider: preset?.provider
+		});
+	}, [
+		runtime,
+		session,
+		registry,
+		preset,
+		chat,
+		feed,
+		space?.id
+	]);
+};
+//#endregion
+//#region src/hooks/useChatServices.ts
+/**
+* Resolves the shared {@link Capabilities.ProcessManagerRuntime} for the given space.
+*
+* The runtime itself is space-agnostic; the returned value can be used to run
+* effects that pipe through {@link ServiceResolver.provide} (or the
+* `useSpaceCallback`/`useSpaceService` hooks) with the resolved {@link Key.SpaceId}.
+*/
+var useChatServices = ({ id }) => {
+	const client = useClient();
+	id ??= AppSpace.getPersonalSpace(client)?.id;
+	const runtime = useCapability(Capabilities.ProcessManagerRuntime);
+	return id ? runtime : void 0;
+};
+//#endregion
+//#region src/hooks/useChatToolbarActions.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useChatToolbarActions.ts";
+var useChatToolbarActions = ({ chat, companionTo }) => {
+	const { invoke } = useOperationInvoker();
+	const { db } = useChatContext("useChatToolbarActions");
+	return useMenuBuilder((get) => {
+		const chats = companionTo && db ? get(db.query(Query.select(Filter.id(companionTo.id)).targetOf(Chat.CompanionTo).source()).atom) : [];
+		const builder = MenuBuilder.make().root({ label: ["chat-toolbar.title", { ns: meta.profile.key }] });
+		if (companionTo) builder.action("new", {
+			label: ["new-thread.button", { ns: meta.profile.key }],
+			icon: "ph--plus--regular",
+			type: "new"
+		}, () => {
+			invariant(companionTo, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 49,
+				S: void 0,
+				A: ["companionTo", ""]
+			});
+			return invoke(AssistantOperation.SetCurrentChat, {
+				companionTo,
+				chat: void 0
+			}).pipe(EffectEx.runAndForwardErrors);
+		});
+		builder.action("branch", {
+			label: ["branch-thread.menu", { ns: meta.profile.key }],
+			icon: "ph--git-branch--regular",
+			type: "branch",
+			disabled: !chat || !db
+		}, () => Effect.gen(function* () {
+			invariant(chat, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 69,
+				S: this,
+				A: ["chat", ""]
+			});
+			yield* invoke(AssistantOperation.ForkChat, {
+				chat,
+				companionTo
+			}, { spaceId: db?.spaceId });
+		}).pipe(EffectEx.runAndForwardErrors)).action("rename", {
+			label: ["rename-thread.button", { ns: meta.profile.key }],
+			icon: "ph--magic-wand--regular",
+			type: "rename",
+			disabled: !chat
+		}, () => Effect.gen(function* () {
+			invariant(chat, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 83,
+				S: this,
+				A: ["chat", ""]
+			});
+			yield* invoke(AssistantOperation.UpdateChatName, { chat }, { spaceId: db?.spaceId });
+		}).pipe(EffectEx.runAndForwardErrors));
+		if (chats.length > 0) builder.group("chats", {
+			label: ["chat-history.label", { ns: meta.profile.key }],
+			icon: "ph--clock-counter-clockwise--regular",
+			selectCardinality: "single",
+			variant: "dropdownMenu"
+		}, (builder) => {
+			chats.toSorted((a, b) => a.id.localeCompare(b.id)).forEach((chat) => {
+				get(Obj.atomProperty(chat, "name"));
+				builder.action(chat.id, { label: Obj.getLabel(chat) ?? ["object-name.placeholder", { ns: Type.getTypename(Chat.Chat) }] }, () => Effect.gen(function* () {
+					invariant(companionTo, void 0, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file,
+						L: 111,
+						S: this,
+						A: ["companionTo", ""]
+					});
+					yield* invoke(AssistantOperation.SetCurrentChat, {
+						companionTo,
+						chat
+					});
+				}).pipe(EffectEx.runAndForwardErrors));
+			});
+		});
+		return builder.build();
+	}, [
+		db?.spaceId,
+		companionTo?.id,
+		chat?.id,
+		invoke
+	]);
+};
+//#endregion
+//#region src/hooks/useContextBinder.ts
+var useContextBinder = (space, feed) => {
+	const registry = useContext(RegistryContext);
+	const [binder, setBinder] = useState();
+	useAsyncEffect(async () => {
+		setBinder(void 0);
+		if (!space || !feed) return;
+		const runtime = await EffectEx.runAndForwardErrors(Effect.runtime().pipe(Effect.provide(Database.layer(space.db))));
+		const binder = new AiContext.Binder({
+			feed,
+			runtime,
+			registry
+		});
+		await binder.open();
+		setBinder(binder);
+		return () => {
+			binder.close();
+		};
+	}, [space, feed]);
+	return binder;
+};
+//#endregion
+//#region src/hooks/useContextObjects.ts
+var emptyObjectsAtom = Atom$1.make([]);
+/**
+* Create reactive map of active object references (by DXN string).
+*/
+var useContextObjects = ({ db, context }) => {
+	const boundObjects = useAtomValue(context?.objects ?? emptyObjectsAtom);
+	return {
+		objects: useMemo(() => boundObjects.filter((object) => !Obj.instanceOf(Chat.Chat, object)), [boundObjects]),
+		onUpdateObject: useCallback(async (dxn, checked) => {
+			if (!db || !context) return;
+			const ref = db.makeRef(dxn);
+			await ref.load();
+			if (checked) await context.bind({ objects: [ref] });
+			else await context.unbind({ objects: [ref] });
+		}, [db, context])
+	};
+};
+//#endregion
+//#region src/hooks/useDebug.ts
+/**
+* Returns an async callback that logs the chat's current context, system prompt,
+* and resolved tools to the browser console under a collapsible group.
+* Used by the chat's debug-toggle event handler.
+*/
+var useDebug = ({ processor }) => {
+	return useCallback(async () => {
+		const objects = processor.context.getObjects();
+		const skills = processor.context.getSkills();
+		const system = await processor.getSystemPrompt();
+		const tools = await processor.getTools() ?? {};
+		console.group("Chat", {
+			objects,
+			skills
+		});
+		try {
+			console.log(trim`
+        System Prompt:
+        ${system}
+      `);
+			console.log(trim`
+        Tools:
+        ${Object.values(tools).map((tool) => JSON.stringify(tool, null, 2)).join("\n")}
+      `);
+		} finally {
+			console.groupEnd();
+		}
+	}, [processor]);
+};
+//#endregion
+//#region src/hooks/useFilteredTypes.ts
+var getFilteredTypes = (db) => Array.from(new Set(db.graph.registry.list().filter(Type.isType).filter((schema) => getTypeAnnotation(Type.getSchema(schema))?.kind !== Kind.Relation).filter((schema) => !HiddenAnnotation.get(Type.getSchema(schema)).pipe(Option.getOrElse(() => false)))));
+var useFilteredTypes = (db) => {
+	const [types, setTypes] = useState([]);
+	useEffect(() => {
+		if (!db) return;
+		setTypes(getFilteredTypes(db));
+		return db.graph.registry.changed.on(() => {
+			setTypes(getFilteredTypes(db));
+		});
+	}, [db]);
+	return types;
+};
+//#endregion
+//#region src/hooks/usePresets.ts
+/**
+* Resolves the chat model presets for the provider selected in settings ({@link Assistant.Settings.modelProvider}),
+* defaulting the selection to the configured per-provider model.
+*/
+var usePresets = (settings) => {
+	const [preset, setPreset] = useState();
+	const ollamaManager = useOptionalCapability(AssistantCapabilities.OllamaManager);
+	const provider = resolveProvider(settings.modelProvider, !!ollamaManager);
+	const defaultModel = settings.modelDefaults?.[defaultsKeyForProvider(provider)];
+	const localModels = useAtomValue(ollamaManager?.state ?? Ollama.emptyState);
+	useEffect(() => {
+		if (provider === Provider.builtIn.id && ollamaManager && localModels.kind === "idle") EffectEx.runPromise(ollamaManager.refresh);
+	}, [
+		provider,
+		ollamaManager,
+		localModels.kind
+	]);
+	const lmStudioReachable = useEndpointReachable(provider === Provider.lmStudio.id && ollamaManager ? `${Provider.lmStudio.endpoint}/v1/models` : void 0);
+	const presets = useMemo(() => {
+		const base = presetsForProvider(provider);
+		if (provider === Provider.lmStudio.id && ollamaManager) return lmStudioReachable ? base : [];
+		if (provider === Provider.builtIn.id && ollamaManager) {
+			const installed = new Set(localModels.models.map((model) => model.name));
+			return base.filter((preset) => installed.has(preset.backend));
+		}
+		return base;
+	}, [
+		provider,
+		ollamaManager,
+		lmStudioReachable,
+		localModels
+	]);
+	const presetOptions = useMemo(() => presets.map(({ id, model, label }) => ({
+		id,
+		label: label ?? model
+	})), [presets]);
+	useEffect(() => {
+		const configured = defaultModel ? presets.find((preset) => preset.model === defaultModel) : void 0;
+		setPreset(configured ?? presets[0]);
+	}, [presets, defaultModel]);
+	return {
+		preset,
+		presets: presetOptions,
+		onPresetChange: useCallback((id) => {
+			const preset = presets.find((preset) => preset.id === id);
+			if (preset) setPreset(preset);
+		}, [presets])
+	};
+};
+/** Reactively reports whether an HTTP endpoint responds; `undefined` url disables the probe. */
+var useEndpointReachable = (url) => {
+	const [reachable, setReachable] = useState(false);
+	useEffect(() => {
+		if (!url) {
+			setReachable(false);
+			return;
+		}
+		let active = true;
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), 1500);
+		fetch(url, { signal: controller.signal }).then((response) => active && setReachable(response.ok)).catch(() => active && setReachable(false)).finally(() => clearTimeout(timer));
+		return () => {
+			active = false;
+			controller.abort();
+			clearTimeout(timer);
+		};
+	}, [url]);
+	return reachable;
+};
+//#endregion
+//#region src/hooks/useReferencesProvider.ts
+/**
+* Resolve references to objects in the space.
+*/
+var useReferencesProvider = (space) => {
+	return useMemo(() => {
+		if (!space) return;
+		return {
+			getReferences: async ({ query }) => {
+				return (await space.db.query(Filter.everything()).run()).filter(Obj.isObject).filter((object) => stringMatch(query, Obj.getLabel(object) ?? "")).map((object) => ({
+					uri: Obj.getURI(object),
+					label: Obj.getLabel(object) ?? ""
+				}));
+			},
+			resolveReference: async ({ uri }) => {
+				const object = await space.db.query(Filter.id(uri)).first();
+				return {
+					uri,
+					label: Obj.getLabel(object) ?? ""
+				};
+			}
+		};
+	}, [space]);
+};
+var stringMatch = (query, label) => label.toLowerCase().startsWith(query.toLowerCase());
+//#endregion
+//#region src/hooks/useSelectionContext.ts
+/** Resolve `object`'s selection to text via the AnchorResolver contributed for its typename. */
+var getSelectionContext = ({ object, selection, resolvers }) => {
+	const typename = Obj.getTypename(object);
+	const resolver = typename ? resolvers.find((candidate) => candidate.key === typename) : void 0;
+	if (!resolver) return;
+	const resolveAnchorText = (anchor) => {
+		try {
+			return resolver.getText(object, anchor);
+		} catch {
+			return;
+		}
+	};
+	const resolved = Selection.toAnchors(selection).flatMap((anchor) => {
+		const text = resolveAnchorText(anchor);
+		return text != null && text.length > 0 ? [{
+			anchor,
+			text
+		}] : [];
+	});
+	if (resolved.length === 0) return;
+	return { selection: {
+		anchors: resolved.map(({ anchor }) => anchor),
+		text: resolved.map(({ text }) => text).join("\n…\n")
+	} };
+};
+/** Submit-time provider of the companion object's current selection as request context. */
+var useSelectionContext = (companionTo) => {
+	const [viewState] = useCapabilities(AttentionCapabilities.ViewState);
+	const resolvers = useCapabilities(AppCapabilities.AnchorResolver);
+	return useCallback(() => {
+		if (!companionTo || !viewState) return;
+		return getSelectionContext({
+			object: companionTo,
+			selection: viewState.get(Selection.aspect, Obj.getURI(companionTo)),
+			resolvers
+		});
+	}, [
+		companionTo,
+		viewState,
+		resolvers
+	]);
+};
+//#endregion
+//#region src/hooks/useTraceMessages.ts
+var atomEmpty$1 = Atom.make(() => []);
+/**
+* Atom of raw trace messages for a space — the input to `buildExecutionGraph`.
+*/
+var getTraceMessagesAtom = (space) => pipe(space.db.query(FeedTraceSink.query).atom, Atom.map((feeds) => space.db.query(feeds.length > 0 ? Query.type(Trace.Message).from([...feeds]) : Query.select(Filter.nothing())).atom), (atom) => Atom.make((get) => get(get(atom))));
+/**
+* Subscribes to the space invocation trace feed.
+*/
+var useTraceMessages = (space) => {
+	return useAtomValue(useMemo(() => space ? getTraceMessagesAtom(space) : atomEmpty$1, [space]));
+};
+//#endregion
+//#region src/hooks/useHomeSuggestions.ts
+var FALLBACK_SUGGESTION_KEYS = [
+	"space-home.suggestion-magazine.label",
+	"space-home.suggestion-spreadsheet.label",
+	"space-home.suggestion-kanban.label"
+];
+/**
+* Returns starter prompts for the space Home page. Returns undefined while the request is in flight
+* so the section stays hidden until settled. On success yields generated prompts; on empty result or
+* error falls back to the hardcoded defaults.
+*/
+var useHomeSuggestions = (space) => {
+	const { t } = useTranslation(meta.profile.key);
+	const { invokePromise } = useOperationInvoker();
+	const fallbacks = useMemo(() => FALLBACK_SUGGESTION_KEYS.map((key) => t(key, { year: (/* @__PURE__ */ new Date()).getFullYear() })), [t]);
+	const [suggestions, setSuggestions] = useState(void 0);
+	useAsyncEffect(async (controller) => {
+		setSuggestions(void 0);
+		if (!space) return;
+		const result = await invokePromise(AssistantOperation.GenerateHomeSuggestions, { db: space.db }, { spaceId: space.db.spaceId });
+		if (controller.signal.aborted) return;
+		const prompts = result.data?.prompts;
+		setSuggestions(prompts && prompts.length > 0 ? prompts : fallbacks);
+	}, [space, invokePromise]);
+	return suggestions;
+};
+//#endregion
+//#region src/hooks/useProcessEphemeralStatus.ts
+var atomEmpty = Atom.make(() => []);
+var ACTIVE_PROCESS_STATES = /* @__PURE__ */ new Set([Process.State.RUNNING, Process.State.HYBERNATING]);
+/** Durable trace lines that represent finished work, not in-flight status. */
+var isTerminalActivityLine = (line) => line.endsWith(" - Success") || line.endsWith(" - Error") || line === "Agent completed request";
+var collectDescendantPids = (processes, rootPid) => {
+	const pids = /* @__PURE__ */ new Set([rootPid]);
+	let expanded = true;
+	while (expanded) {
+		expanded = false;
+		for (const process of processes) {
+			const pid = String(process.pid);
+			const parentPid = process.parentPid ? String(process.parentPid) : void 0;
+			if (parentPid && pids.has(parentPid) && !pids.has(pid)) {
+				pids.add(pid);
+				expanded = true;
+			}
+		}
+	}
+	return pids;
+};
+var resolveSubscribePids = (agentPid, processes) => {
+	const descendants = collectDescendantPids(processes, String(agentPid));
+	const activePids = processes.filter((process) => descendants.has(String(process.pid)) && ACTIVE_PROCESS_STATES.has(process.state)).map((process) => process.pid);
+	if (activePids.length > 0) return activePids;
+	return [agentPid];
+};
+var attachActiveHandle = (processManager, pid) => Effect.gen(function* () {
+	const maxAttempts = 15;
+	for (let attempt = 0; attempt < maxAttempts; attempt++) {
+		const handle = yield* processManager.attach(pid).pipe(Effect.catchAll(() => Effect.succeed(void 0)));
+		if (handle && ACTIVE_PROCESS_STATES.has(handle.status.state)) return handle;
+		if (handle) return;
+		yield* Effect.sleep(100);
+	}
+});
+/**
+* Subscribes to ephemeral trace events for a delegated sub-agent process subtree
+* and surfaces the latest pending text or tool-call block as a status line.
+*/
+var useProcessEphemeralStatus = (agentPid, space) => {
+	const runtime = useOptionalCapability(Capabilities.ProcessManagerRuntime);
+	const processes = useAtomValue(useOptionalCapability(Capabilities.ProcessMonitor)?.processTreeAtom ?? atomEmpty);
+	const [status, setStatus] = useState();
+	const fibersRef = useRef([]);
+	const subscribePidsKey = useMemo(() => {
+		if (!agentPid) return "";
+		return resolveSubscribePids(agentPid, processes).map((pid) => String(pid)).sort().join("|");
+	}, [agentPid, processes]);
+	useEffect(() => {
+		if (!agentPid || !space?.id || !runtime || !subscribePidsKey) {
+			setStatus(void 0);
+			return;
+		}
+		const pids = subscribePidsKey.split("|").map((pid) => Process.ID.make(pid));
+		let disposed = false;
+		let replaying = true;
+		let replayStatus;
+		const endReplay = () => {
+			replaying = false;
+			if (!disposed) setStatus(replayStatus);
+		};
+		queueMicrotask(endReplay);
+		fibersRef.current = [];
+		const handleEphemeralMessage = (message) => {
+			const update = resolveEphemeralStatusUpdate(message);
+			if (update === "unchanged") return;
+			if (replaying) {
+				replayStatus = update.line;
+				return;
+			}
+			setStatus(update.line);
+		};
+		const layer = ServiceResolver.provide({ space: space.id }, ProcessManager.ProcessManagerService);
+		const subscribe = (pid) => Effect.gen(function* () {
+			if (disposed) return;
+			const handle = yield* attachActiveHandle(yield* ProcessManager.ProcessManagerService, pid);
+			if (!handle || disposed) return;
+			const fiber = yield* handle.subscribeEphemeral().pipe(Stream.runForEach((message) => Effect.sync(() => {
+				if (disposed) return;
+				handleEphemeralMessage(message);
+			})), Effect.forkDaemon);
+			if (disposed) {
+				yield* Fiber.interrupt(fiber);
+				return;
+			}
+			fibersRef.current.push(fiber);
+		});
+		runtime.runPromise(Effect.forEach(pids, subscribe, {
+			concurrency: "unbounded",
+			discard: true
+		}).pipe(Effect.provide(layer))).catch(() => {
+			if (!disposed) setStatus(void 0);
+		});
+		return () => {
+			disposed = true;
+			const fibers = fibersRef.current;
+			fibersRef.current = [];
+			for (const fiber of fibers) runtime.runPromise(Fiber.interrupt(fiber).pipe(Effect.provide(layer)));
+		};
+	}, [
+		agentPid,
+		runtime,
+		space?.id,
+		subscribePidsKey
+	]);
+	return status;
+};
+//#endregion
+export { getSelectionContext, getTraceMessagesAtom, isTerminalActivityLine, useActiveSkills, useChatKeymapExtensions, useChatProcessor, useChatServices, useChatToolbarActions, useContextBinder, useContextObjects, useDebug, useFilteredTypes, useHomeSuggestions, usePresets, useProcessEphemeralStatus, useReferencesProvider, useSelectionContext, useSkillHandlers, useSkills, useTraceMessages };
+
+//# sourceMappingURL=hooks.mjs.map