@dsh-electron/dsh-plugin-multi-root-workspace 0.1.8 → 0.1.10

package/lib/skills.js

@@ -0,0 +1,790 @@
+import { t as wrapMethod } from "./method-wrapper-CFY3p3j2.js";
+import { r as isPackageInstalled, t as createInstructionMessage } from "./llm-message-fYORacvh.js";
+import { n as skillsMetadataValid } from "./metadata-DgqSdVX_.js";
+import { constants, statSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { Service } from "@deepseek-ai/cordis";
+import { canonicalPath } from "@deepseek-ai/dsh-sandbox";
+import { lstat, open, readdir, stat } from "node:fs/promises";
+import { AsyncLocalStorage } from "node:async_hooks";
+import z from "@deepseek-ai/schemastery";
+//#region \0@oxc-project+runtime@0.149.0/helpers/esm/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	}, e = {}, n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o, t = this.e, s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
+//#endregion
+//#region src/compat/skills.ts
+/** Never infer authority from cwd, a preset key, or a lookalike Agent. */
+function skillAgent(ctx, options) {
+	const scope = options.scope;
+	if (typeof scope !== "object" || scope === null || !("id" in scope) || typeof scope.id !== "string") return void 0;
+	const agent = ctx.get("agents")?.get(scope.id);
+	return agent === scope ? agent : void 0;
+}
+function skillOrigin(ctx, options) {
+	const cwd = skillAgent(ctx, options)?.session.header.cwd;
+	return typeof cwd === "string" && cwd !== "" ? canonicalPath(cwd) : void 0;
+}
+/** Absence is optional; a present but broken module must fail visibly. */
+async function filesystemSkillsApi() {
+	if (!isPackageInstalled("@deepseek-ai/dsh-skill-filesystem")) return void 0;
+	const api = await import("@deepseek-ai/dsh-skill-filesystem");
+	if (typeof api.FileSystemSkillProvider !== "function") throw new Error("multi-root skills: FileSystemSkillProvider is unavailable");
+	return api;
+}
+function volatileField(schema) {
+	const method = schema.volatile;
+	return typeof method === "function" ? method.call(schema) : schema;
+}
+function configValue(value) {
+	if (typeof value === "object" && value !== null && Symbol.for("cosmokit.volatile.write") in value) {
+		const get = value.get;
+		if (typeof get === "function") return get.call(value);
+	}
+	return value;
+}
+/** Cold Browser Catalog supplies a Session header, never a fabricated Agent. */
+async function observedSkillOrigin(ctx, sessionId) {
+	try {
+		var _usingCtx$1 = _usingCtx();
+		const query = ctx.get("sessionQuery");
+		if (query === void 0) throw new Error("multi-root skills: SessionQuery is unavailable");
+		const cwd = _usingCtx$1.u(await query.observeSession(sessionId)).header.cwd;
+		if (typeof cwd !== "string" || cwd === "") throw new Error("multi-root skills: Session has no origin");
+		return canonicalPath(cwd);
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
+	}
+}
+//#endregion
+//#region src/skills/reader.ts
+/** Constrain the native parser before discovery can read a candidate's body. */
+function containsPath(root, target) {
+	const rel = relative(root, target);
+	return rel === "" || !isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`);
+}
+async function rootReader(ctx, root, signal, valid) {
+	const api = await filesystemSkillsApi();
+	if (api === void 0) return void 0;
+	const fs = ctx.fs;
+	const guard = (value) => {
+		signal.throwIfAborted();
+		const path = typeof value === "string" ? value : fs.processPath(value);
+		const canonical = canonicalPath(path);
+		if (!valid() || !containsPath(root, resolve(path)) || !containsPath(root, canonical)) throw Object.assign(/* @__PURE__ */ new Error("multi-root skills: path is outside the authorized root"), { code: "ENOENT" });
+		return canonical;
+	};
+	const guarded = new Proxy(fs, { get(target, key) {
+		if (key === "readText") return async (path, requestSignal) => {
+			requestSignal?.throwIfAborted();
+			const canonical = guard(path);
+			const handle = await open(canonical, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+			try {
+				const before = await handle.stat();
+				if (!before.isFile()) throw new Error("multi-root skills: candidate is not a regular file");
+				const text = await handle.readFile("utf8");
+				requestSignal?.throwIfAborted();
+				if (guard(path) !== canonical) throw new Error("multi-root skills: candidate changed during read");
+				const after = await handle.stat(), current = await stat(canonical);
+				if (before.dev !== current.dev || before.ino !== current.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) throw new Error("multi-root skills: candidate changed during read");
+				return text;
+			} finally {
+				await handle.close();
+			}
+		};
+		if (key === "resolve" || key === "stat" || key === "listDir") return async (...args) => {
+			guard(args[0]);
+			const method = Reflect.get(target, key);
+			return await Reflect.apply(method, target, args);
+		};
+		const value = Reflect.get(target, key);
+		return typeof value === "function" ? value.bind(target) : value;
+	} });
+	const delegateContext = {
+		get: (name) => name === "fs" ? guarded : void 0,
+		logger: ctx.logger
+	};
+	return new api.FileSystemSkillProvider(delegateContext, {
+		signal,
+		invalidate() {}
+	}, {
+		includeDefaultRoots: false,
+		watch: false,
+		providerName: "multi-root-skills-filesystem",
+		customSkillDirs: [resolve(root, ".dsh/skills"), resolve(root, ".agents/skills")]
+	});
+}
+//#endregion
+//#region src/skills/pool.ts
+/** Bounded shared native delegates and one polling scheduler, never per-delegate watchers. */
+var SkillReaderPool = class {
+	invalidate;
+	capacity;
+	entries = /* @__PURE__ */ new Map();
+	waiters = /* @__PURE__ */ new Set();
+	closing = false;
+	polling;
+	timer;
+	constructor(invalidate, capacity = 128, intervalMs = 2e3) {
+		this.invalidate = invalidate;
+		this.capacity = capacity;
+		this.timer = setInterval(() => {
+			this.poll().catch(() => this.invalidate());
+		}, intervalMs);
+		this.timer.unref();
+	}
+	get size() {
+		return this.entries.size;
+	}
+	get roots() {
+		return [...this.entries.keys()];
+	}
+	async use(key, create, run, signal) {
+		for (;;) {
+			signal?.throwIfAborted();
+			if (this.closing) throw new Error("multi-root skills: reader pool is closing");
+			let entry = this.entries.get(key);
+			if (entry === void 0 && this.entries.size >= this.capacity) {
+				const idle = [...this.entries.values()].find((entry) => entry.busy === 0);
+				if (idle === void 0) {
+					await new Promise((resolve, reject) => {
+						const wake = () => {
+							signal?.removeEventListener("abort", abort);
+							this.waiters.delete(wake);
+							resolve();
+						};
+						const abort = () => {
+							this.waiters.delete(wake);
+							reject(signal?.reason);
+						};
+						this.waiters.add(wake);
+						signal?.addEventListener("abort", abort, { once: true });
+						if (signal?.aborted) abort();
+					});
+					continue;
+				}
+				this.entries.delete(idle.key);
+				await this.closeEntry(idle);
+				continue;
+			}
+			if (entry === void 0) {
+				const controller = new AbortController();
+				entry = {
+					key,
+					controller,
+					reader: create(controller.signal),
+					busy: 0
+				};
+				this.entries.set(key, entry);
+			}
+			this.entries.delete(key);
+			this.entries.set(key, entry);
+			entry.busy++;
+			try {
+				if (entry.stamp === void 0) entry.stamp = await skillTreeStamp(key);
+				signal?.throwIfAborted();
+				return await run(await entry.reader);
+			} finally {
+				entry.busy--;
+				for (const wake of [...this.waiters]) wake();
+			}
+		}
+	}
+	async poll() {
+		if (this.closing) return;
+		this.polling ??= (async () => {
+			let changed = false;
+			for (const entry of [...this.entries.values()]) {
+				const stamp = await skillTreeStamp(entry.key);
+				if (entry.stamp !== void 0 && entry.stamp !== stamp) changed = true;
+				entry.stamp = stamp;
+			}
+			if (changed && !this.closing) this.invalidate();
+		})().finally(() => {
+			this.polling = void 0;
+		});
+		await this.polling;
+	}
+	async dispose() {
+		this.closing = true;
+		clearInterval(this.timer);
+		for (const wake of [...this.waiters]) wake();
+		for (const entry of this.entries.values()) entry.controller.abort();
+		await this.polling?.catch(() => {});
+		while ([...this.entries.values()].some((entry) => entry.busy > 0)) await new Promise((resolve) => {
+			const wake = () => {
+				this.waiters.delete(wake);
+				resolve();
+			};
+			this.waiters.add(wake);
+		});
+		await Promise.allSettled([...this.entries.values()].map((entry) => this.closeEntry(entry)));
+		this.entries.clear();
+	}
+	async closeEntry(entry) {
+		entry.controller.abort();
+		try {
+			await (await entry.reader)?.dispose();
+		} catch {}
+	}
+};
+/** No symlink target outside the Root is read or enumerated. Content reads stay on demand. */
+async function skillTreeStamp(root) {
+	const rows = [canonicalPath(root)];
+	const stamp = async (path) => {
+		try {
+			const link = await lstat(path, { bigint: true });
+			rows.push(`${path}:${link.dev}:${link.ino}:${link.size}:${link.mtimeNs}:${link.ctimeNs}:${canonicalPath(path)}`);
+			if (!containsPath(root, canonicalPath(path))) return void 0;
+			return await stat(path);
+		} catch {
+			rows.push(`${path}:missing`);
+			return;
+		}
+	};
+	await stamp(root);
+	for (const directory of [".dsh/skills", ".agents/skills"]) {
+		const path = join(root, directory);
+		if (!(await stamp(path))?.isDirectory()) continue;
+		const entries = await readdir(path).catch(() => []);
+		for (const name of entries.sort()) {
+			const candidate = join(path, name);
+			if ((await stamp(candidate))?.isDirectory()) await stamp(join(candidate, "SKILL.md"));
+		}
+	}
+	return rows.join("\n");
+}
+//#endregion
+//#region src/skills/catalog.ts
+/** Origin-scoped metadata discovery; Registry remains the only registration source. */
+const SKILLS_PROVIDER = "multi-root-workspace";
+function internalSkillName(primary, rootId, skillName) {
+	return `mr-${createHash("sha256").update(`${primary}\0${rootId}`).digest("hex")}-${skillName}`;
+}
+var AdditionalSkillCatalog = class {
+	ctx;
+	signal;
+	enabled;
+	generation;
+	loadedReceipts = /* @__PURE__ */ new WeakMap();
+	locators = /* @__PURE__ */ new WeakSet();
+	requests = new AsyncLocalStorage();
+	pool;
+	constructor(ctx, signal, enabled, generation = () => 0, invalidate = () => {}) {
+		this.ctx = ctx;
+		this.signal = signal;
+		this.enabled = enabled;
+		this.generation = generation;
+		this.pool = new SkillReaderPool(invalidate);
+	}
+	/** Read synchronously after awaited receipt checks, immediately before batch delivery. */
+	get revision() {
+		return this.generation();
+	}
+	current(primary, id) {
+		if (this.signal.aborted || !this.enabled() || this.ctx.multiRootRegistry.authority.kind !== "active" || this.ctx.multiRootScope.resolve({
+			mode: "read-only",
+			workspaceRoot: primary
+		}).authority !== "available") return void 0;
+		const rows = this.ctx.multiRootRegistry.list(primary);
+		const root = rows.find((row) => row.id === id);
+		if (root === void 0 || root.state !== "available" || root.skillsEnabled !== true || !skillsMetadataValid(root, rows)) return void 0;
+		const recorded = root.recordedPath ?? root.readOnlyRecordedPath ?? root.readWriteRecordedPath;
+		try {
+			return recorded === canonicalPath(root.path) && statSync(root.path).isDirectory() ? root : void 0;
+		} catch {
+			return;
+		}
+	}
+	async withReader(primary, id, options, run) {
+		const root = this.current(primary, id);
+		if (root === void 0) return await run(void 0);
+		return await this.requests.run({
+			primary,
+			id
+		}, () => this.pool.use(root.path, (signal) => rootReader(this.ctx, root.path, AbortSignal.any([signal, this.signal]), () => {
+			const request = this.requests.getStore();
+			return request !== void 0 && this.current(request.primary, request.id)?.path === root.path;
+		}), run, options.signal));
+	}
+	async list(primary, options) {
+		options.signal?.throwIfAborted();
+		if (!this.enabled()) return [];
+		const roots = await this.ctx.multiRootRegistry.refresh(primary);
+		const revision = this.generation();
+		const candidates = [];
+		for (const root of roots) {
+			if (this.current(primary, root.id) === void 0) continue;
+			try {
+				const observed = await this.withReader(primary, root.id, options, async (reader) => await reader?.list(options));
+				if (observed === void 0) continue;
+				options.signal?.throwIfAborted();
+				const fresh = this.current(primary, root.id);
+				if (fresh === void 0 || fresh.aliasId !== root.aliasId) continue;
+				const seen = /* @__PURE__ */ new Set();
+				for (const candidate of Array.isArray(observed) ? observed : observed.candidates) {
+					if (seen.has(candidate.name)) continue;
+					seen.add(candidate.name);
+					const locator = {
+						primary,
+						rootId: root.id,
+						aliasId: root.aliasId,
+						candidate
+					};
+					this.locators.add(locator);
+					candidates.push({
+						...candidate,
+						provider: SKILLS_PROVIDER,
+						description: `/${locator.aliasId}:${candidate.name} — ${candidate.description}`,
+						name: internalSkillName(primary, root.id, candidate.name),
+						rank: Number.MAX_SAFE_INTEGER,
+						invocation: {
+							modelInvocable: candidate.invocation.modelInvocable,
+							userInvocable: false
+						},
+						locator
+					});
+				}
+			} catch (error) {
+				options.signal?.throwIfAborted();
+				this.ctx.logger.warn(`multi-root skills: discovery withheld for ${root.path}: ${String(error)}`);
+			}
+		}
+		return revision === this.generation() ? candidates : [];
+	}
+	/** Locators are created here and are not accepted from a client path or object. */
+	async load(primary, entry, options, user) {
+		const locator = entry.locator;
+		if (typeof locator !== "object" || locator === null || !this.locators.has(locator) || locator.primary !== primary) return void 0;
+		const root = this.current(primary, locator.rootId);
+		if (root === void 0 || root.aliasId !== locator.aliasId || entry.name !== internalSkillName(primary, root.id, locator.candidate.name)) return void 0;
+		const revision = this.generation();
+		let loaded;
+		let stamp;
+		try {
+			stamp = await fileStamp(locator.candidate.path);
+			loaded = await this.withReader(primary, root.id, options, async (reader) => await reader?.get(locator.candidate, options));
+			if (stamp !== await fileStamp(locator.candidate.path)) return void 0;
+		} catch (error) {
+			options.signal?.throwIfAborted();
+			this.ctx.logger.warn(`multi-root skills: load withheld: ${String(error)}`);
+			return;
+		}
+		options.signal?.throwIfAborted();
+		const current = this.current(primary, root.id);
+		if (loaded === void 0 || revision !== this.generation() || current === void 0 || current.aliasId !== locator.aliasId || loaded.name !== locator.candidate.name) return void 0;
+		if (!(user ? loaded.invocation.userInvocable : loaded.invocation.modelInvocable)) return void 0;
+		const definition = {
+			...loaded,
+			name: user ? `${locator.aliasId}:${loaded.name}` : entry.name,
+			provider: SKILLS_PROVIDER,
+			invocation: user ? loaded.invocation : {
+				modelInvocable: loaded.invocation.modelInvocable,
+				userInvocable: false
+			}
+		};
+		this.loadedReceipts.set(definition, {
+			revision,
+			locator,
+			stamp
+		});
+		return definition;
+	}
+	async admissionValid(definition) {
+		const receipt = this.loadedReceipts.get(definition);
+		if (receipt === void 0) return false;
+		const current = this.current(receipt.locator.primary, receipt.locator.rootId);
+		if (current === void 0 || current.aliasId !== receipt.locator.aliasId || receipt.revision !== this.generation()) return false;
+		try {
+			return receipt.stamp === await fileStamp(definition.path) && receipt.revision === this.generation() && this.current(receipt.locator.primary, receipt.locator.rootId)?.aliasId === receipt.locator.aliasId;
+		} catch {
+			return false;
+		}
+	}
+	async dispose() {
+		await this.pool.dispose();
+	}
+};
+async function fileStamp(path) {
+	if (path === void 0) throw new Error("multi-root skills: missing file identity");
+	const value = await stat(path, { bigint: true });
+	return [
+		value.dev,
+		value.ino,
+		value.size,
+		value.mtimeNs,
+		value.ctimeNs
+	].join(":");
+}
+//#endregion
+//#region src/compat/skill-content.ts
+async function renderAdditionalSkill(skill) {
+	const { renderSkillContent } = await import("@deepseek-ai/dsh-skill");
+	return renderSkillContent(skill);
+}
+//#endregion
+//#region src/skills/invocation.ts
+function installSkillInvocations(ctx, catalog, known) {
+	ctx.inject(["agents"], (scope) => {
+		scope.on("agent/pre-step", async ({ agent, messages, signal }, next) => {
+			const decision = await next();
+			if (decision.kind === "reject") return decision;
+			const primary = skillOrigin(scope, { scope: agent });
+			if (primary === void 0) return decision;
+			const invoked = /* @__PURE__ */ new Set();
+			for (const message of messages) {
+				if (message.source.kind !== "user") continue;
+				for (const block of message.content) {
+					if (block.type !== "text") continue;
+					for (const match of block.text.matchAll(/(?<!\S)\/([a-z0-9]+(?:-[a-z0-9]+)*):([a-z0-9]+(?:-[a-z0-9]+)*)(?!\S)/g)) invoked.add(`${match[1]}:${match[2]}`);
+				}
+			}
+			const previous = known.get(agent);
+			if (invoked.size === 0 && (previous === void 0 || previous.size === 0)) return decision;
+			const options = {
+				scope: agent,
+				signal
+			};
+			const entries = await catalog.list(primary, options);
+			const revision = catalog.revision;
+			const injections = [], pending = [];
+			if (previous !== void 0) {
+				const remaining = new Set(entries.map((entry) => entry.name));
+				const revoked = [];
+				for (const [name, locator] of previous) {
+					if (remaining.has(name) && catalog.current(primary, locator.rootId)?.aliasId === locator.aliasId) continue;
+					revoked.push(`${locator.aliasId}:${locator.candidate.name}`);
+					previous.delete(name);
+				}
+				if (revoked.length > 0) injections.push(await createInstructionMessage({
+					plugin: "multi-root-skills",
+					text: `The following additional-root Skills are no longer available for new invocations: ${revoked.join(", ")}. Previously delivered content remains in the conversation history.`
+				}));
+			}
+			for (const name of invoked) {
+				signal.throwIfAborted();
+				const entry = entries.find((entry) => {
+					const locator = entry.locator;
+					return `${locator.aliasId}:${locator.candidate.name}` === name;
+				});
+				if (entry === void 0) continue;
+				const loaded = await catalog.load(primary, entry, options, true);
+				if (loaded === void 0) continue;
+				const rendered = await renderAdditionalSkill(loaded);
+				signal.throwIfAborted();
+				const message = await createInstructionMessage({
+					plugin: "multi-root-skills",
+					text: rendered
+				});
+				pending.push({
+					entry,
+					loaded,
+					message
+				});
+			}
+			const admitted = await Promise.all(pending.map(({ loaded }) => catalog.admissionValid(loaded)));
+			signal.throwIfAborted();
+			if (revision === catalog.revision && admitted.every(Boolean)) for (const { entry, message } of pending) {
+				let tracked = known.get(agent);
+				if (tracked === void 0) {
+					tracked = /* @__PURE__ */ new Map();
+					known.set(agent, tracked);
+				}
+				tracked.set(entry.name, entry.locator);
+				injections.push(message);
+			}
+			return {
+				...decision,
+				messages: [...decision.messages, ...injections]
+			};
+		}, { prepend: true });
+	});
+}
+//#endregion
+//#region src/skills/routing.ts
+/** Public native reads must not discover an additional Root as an unqualified project. */
+function installSkillRouting(ctx) {
+	const fibers = [];
+	const cold = new AsyncLocalStorage();
+	const optionsFor = (options) => {
+		const primary = skillOrigin(ctx, options) ?? cold.getStore();
+		if (primary === void 0 || options.cwd === void 0) return options;
+		const rows = ctx.multiRootRegistry.list(primary);
+		if (rows.length === 0) return options;
+		const lexical = resolve(options.cwd), canonical = canonicalPath(options.cwd);
+		return rows.some((root) => containsPath(root.path, lexical) || containsPath(root.path, canonical)) ? {
+			...options,
+			cwd: primary
+		} : options;
+	};
+	fibers.push(ctx.inject(["skills"], (scope) => {
+		const registry = scope.skills;
+		scope.effect(() => wrapMethod(registry, "snapshot", (original) => async function(options = {}) {
+			const result = await original.call(this, optionsFor(options));
+			const primary = skillOrigin(scope, options);
+			if (primary !== void 0) for (const skill of result.skills) {
+				if (skill.provider === "multi-root-workspace") continue;
+				if (scope.multiRootRegistry.list(primary).some((root) => skill.name.startsWith(internalSkillName(primary, root.id, "")))) scope.logger.warn(`multi-root skills: internal ID conflict; native winner retained: ${skill.name} (${skill.provider})`);
+			}
+			return result;
+		}));
+		scope.effect(() => wrapMethod(registry, "get", (original) => function(name, options = {}) {
+			return original.call(this, name, optionsFor(options));
+		}));
+	}));
+	fibers.push(ctx.inject(["sessionSkillCatalog", "sessionQuery"], (scope) => {
+		scope.effect(() => wrapMethod(scope.sessionSkillCatalog, "list", (original) => async function(request, signal) {
+			const primary = await observedSkillOrigin(scope, request.sessionId);
+			return await cold.run(primary, () => original.call(this, request, signal));
+		}));
+	}));
+	return fibers;
+}
+//#endregion
+//#region src/compat/skills-settings.ts
+const SKILLS_SETTINGS_ID = "multi-root-skills";
+function installSkillsSettings(ctx, initial, changed) {
+	let source;
+	return {
+		fiber: ctx.inject(["settings"], (scope) => {
+			const settings = scope.get("settings");
+			if (typeof settings.installSection === "function") {
+				settings.installSection(scope, SKILLS_SETTINGS_ID, z.object({ enabled: z.boolean().default(true) }), { enabled: configValue(initial()) !== false }, {
+					setSource: (current) => {
+						source = current;
+					},
+					onChange: changed,
+					validate: (value) => {
+						if (typeof value.enabled !== "boolean") throw new Error("multi-root skills: enabled must be boolean");
+					}
+				});
+				return () => {
+					source = void 0;
+					changed();
+				};
+			}
+			if (typeof settings.configure !== "function") throw new Error("multi-root skills: unsupported Settings service");
+			const stop = settings.configure({ auto: false }, scope.fiber);
+			const stopEvent = scope.on("settings/document-updated", (id) => {
+				if (id === "multi-root-skills") changed();
+			});
+			return () => {
+				stopEvent();
+				stop();
+			};
+		}),
+		read: () => source === void 0 ? initial() : source().enabled
+	};
+}
+//#endregion
+//#region src/skills.ts
+/** Optional Skills host entry. Kept outside the carrier's module evaluation graph. */
+const Config = z.object({ enabled: volatileField(z.boolean().default(true)) });
+/** Assembly owner; discovery is installed only after native services arrive. */
+var MultiRootSkills = class extends Service {
+	settingsConfig;
+	static Config = Config;
+	static provide = "multiRootSkills";
+	static inject = [
+		"multiRootCompat",
+		"multiRootProviders",
+		"multiRootRegistry",
+		"multiRootScope"
+	];
+	constructor(ctx, settingsConfig = {}) {
+		super(ctx, "multiRootSkills");
+		this.settingsConfig = settingsConfig;
+	}
+	settingsRead;
+	revision = 0;
+	catalog;
+	changed = /* @__PURE__ */ new Set();
+	closing = false;
+	get generation() {
+		return this.revision;
+	}
+	invalidate() {
+		this.revision++;
+		for (const notify of [...this.changed]) notify();
+	}
+	status(sessionId) {
+		return {
+			sessionId,
+			generation: this.revision,
+			enabled: this.enabled && !this.closing
+		};
+	}
+	async listSession(sessionId, signal) {
+		signal?.throwIfAborted();
+		const primary = await observedSkillOrigin(this.ctx, sessionId), revision = this.revision;
+		const entries = await this.catalog?.list(primary, { signal }) ?? [];
+		signal?.throwIfAborted();
+		if (this.closing || primary !== await observedSkillOrigin(this.ctx, sessionId) || revision !== this.revision) throw new Error("multi-root skills: stale Session catalog; retry");
+		return {
+			...this.status(sessionId),
+			skills: entries.flatMap((entry) => {
+				const locator = entry.locator;
+				return locator.candidate.invocation.userInvocable ? [{
+					name: `${locator.aliasId}:${locator.candidate.name}`,
+					description: locator.candidate.description,
+					modelInvocable: entry.invocation.modelInvocable
+				}] : [];
+			})
+		};
+	}
+	async previewSession(sessionId, name, signal) {
+		signal?.throwIfAborted();
+		const primary = await observedSkillOrigin(this.ctx, sessionId), catalog = this.catalog;
+		const entry = (await catalog?.list(primary, { signal }) ?? []).find((entry) => {
+			const locator = entry.locator;
+			return `${locator.aliasId}:${locator.candidate.name}` === name;
+		});
+		const loaded = entry === void 0 ? void 0 : await catalog?.load(primary, entry, { signal }, true);
+		signal?.throwIfAborted();
+		if (loaded === void 0 || primary !== await observedSkillOrigin(this.ctx, sessionId) || !await catalog.admissionValid(loaded) || this.closing) throw new Error("multi-root skills: Skill is unavailable");
+		return {
+			...this.status(sessionId),
+			name,
+			content: loaded.content
+		};
+	}
+	async changes(sessionId, generation, signal) {
+		await observedSkillOrigin(this.ctx, sessionId);
+		signal?.throwIfAborted();
+		if (this.closing) throw new Error("multi-root skills: closing");
+		if (generation === this.revision) await new Promise((resolve, reject) => {
+			const finish = () => {
+				clearTimeout(timer);
+				this.changed.delete(finish);
+				signal?.removeEventListener("abort", abort);
+				resolve();
+			};
+			const abort = () => {
+				finish();
+				reject(signal?.reason);
+			};
+			const timer = setTimeout(finish, 2e4);
+			timer.unref();
+			this.changed.add(finish);
+			signal?.addEventListener("abort", abort, { once: true });
+			if (signal?.aborted) abort();
+		});
+		signal?.throwIfAborted();
+		await observedSkillOrigin(this.ctx, sessionId);
+		return this.status(sessionId);
+	}
+	async [Service.init]() {
+		const owner = this, ctx = this.ctx;
+		await ctx.effect(async function* () {
+			const settings = installSkillsSettings(ctx, () => owner.settingsConfig.enabled, () => owner.invalidate());
+			owner.settingsRead = settings.read;
+			yield settings.fiber.dispose;
+			yield ctx.multiRootRegistry.onChange(() => owner.invalidate());
+			yield ctx.multiRootScope.subscribe(() => owner.invalidate());
+			for (const fiber of installSkillRouting(ctx)) yield fiber.dispose;
+			yield ctx.inject(["skills", "fs"], (scope) => {
+				const controller = new AbortController();
+				const catalog = new AdditionalSkillCatalog(scope, controller.signal, () => owner.enabled, () => owner.revision, () => owner.invalidate());
+				owner.catalog = catalog;
+				scope.effect(() => () => {
+					controller.abort();
+					if (owner.catalog === catalog) owner.catalog = void 0;
+					return catalog.dispose();
+				});
+				const known = /* @__PURE__ */ new WeakMap();
+				installSkillInvocations(scope, catalog, known);
+				scope.skills.registerProvider((control) => {
+					scope.effect(() => {
+						owner.changed.add(control.invalidate);
+						return () => {
+							owner.changed.delete(control.invalidate);
+						};
+					});
+					return {
+						name: SKILLS_PROVIDER,
+						list: async (options) => {
+							const primary = skillOrigin(scope, options);
+							if (primary === void 0) return [];
+							const entries = await catalog.list(primary, options);
+							const agent = skillAgent(scope, options);
+							let tracked = known.get(agent);
+							if (tracked === void 0) {
+								tracked = /* @__PURE__ */ new Map();
+								known.set(agent, tracked);
+							}
+							for (const entry of entries) tracked.set(entry.name, entry.locator);
+							return entries;
+						},
+						get: async (entry, options) => {
+							const primary = skillOrigin(scope, options);
+							return primary === void 0 ? void 0 : await catalog.load(primary, entry, options, false);
+						}
+					};
+				});
+			}).dispose;
+			yield () => {
+				owner.closing = true;
+				owner.invalidate();
+			};
+		}, "multi-root skills: ordered owner");
+	}
+	get enabled() {
+		return !this.closing && configValue(this.settingsRead?.() ?? this.settingsConfig.enabled) !== false;
+	}
+};
+//#endregion
+export { Config, MultiRootSkills, MultiRootSkills as default };