@ftai/dsh-plugin-acn 0.0.0-stage → 0.1.0

package/lib/plugins/knowledge.js

@@ -0,0 +1,1111 @@
+import { o as RouteSchema, t as abortable } from "../structured-lyQCK-Zk.js";
+import { _ as JobError, c as readYamlOr, l as writeYamlAtomic, n as withFileLock, w as hasCode } from "../lock-DbmlKOoX.js";
+import { t as AcnDream } from "../service-C_i3BzdP.js";
+import { n as agentHomePath } from "../paths-CDYV5UH9.js";
+import { _ as unboundSession, a as identityOf, c as rememberConfiguration, d as sessionAllowed, f as sessionChanged, g as sessionUnbound, h as sessionSelection, i as forgetConfiguration, l as restoreSessionBinding, m as sessionHasWork, n as configurationActivation, o as markSessionEligible, p as sessionEligible, s as observeSelection, t as bindSession, u as runningConfiguration } from "../session-binding-BQrOGhZI.js";
+import { n as projectEvent, r as structuredBackend, t as compactionEnd } from "../formation-D4LO31WW.js";
+import { t as autonomousDreamRunner } from "../dream-agent-DBszTHXY.js";
+import { t as loadPromptRenderer } from "../render-CJaVcKKC.js";
+import { n as isSubagent, t as isEvidenceAgent } from "../subagent-yJsFxHmH.js";
+import { t as UploadScheduler } from "../scheduler-MaUEbXr3.js";
+import { t as AcnInbox } from "../service-BcHV5mc7.js";
+import { t as AcnFormation } from "../service-CNjqHCBR.js";
+import { n as formationReplay, r as connectArchives, t as formationOwnership } from "../formation-replay-CEOy5FkI.js";
+import { a as defaultUpstream, d as resolveConfig, f as upstreamsOf, i as canonicalProjectPath, n as teamCredentials, o as resolveUpstream, r as AcnKnowledge } from "../team-credentials-C9xHrPIi.js";
+import { t as KnowledgeSessions } from "../sessions-C2xuPFQv.js";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { appendPluginRecord } from "@deepseek-ai/dsh-session";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import Schema from "@deepseek-ai/schemastery";
+//#region src/dsh-adapter/knowledge-paths.ts
+const fileTools = /* @__PURE__ */ new Set([
+	"read",
+	"read_image",
+	"write",
+	"edit",
+	"grep",
+	"glob",
+	"str_replace_editor"
+]);
+const denial = "普通文件工具不能访问私有 Agent 数据或包含它的搜索根；请使用 Claim 专用工具，或缩小搜索目录。";
+const fingerprint = (execution) => createHash("sha256").update(JSON.stringify(execution.arguments) ?? "undefined").digest("hex");
+async function* linkedFiles(root, signal) {
+	const directories = [root];
+	while (directories.length > 0) {
+		signal.throwIfAborted();
+		const directory = directories.pop();
+		if (directory === void 0) break;
+		let entries;
+		try {
+			entries = await fs.readdir(directory, { withFileTypes: true });
+		} catch (error) {
+			if (hasCode(error, "ENOENT")) continue;
+			throw error;
+		}
+		for (const entry of entries) {
+			signal.throwIfAborted();
+			const path = join(directory, entry.name);
+			if (entry.isDirectory()) directories.push(path);
+			else if (entry.isFile()) try {
+				const info = await fs.lstat(path);
+				if (info.nlink > 1) yield `${info.dev}:${info.ino}`;
+			} catch (error) {
+				if (!hasCode(error, "ENOENT")) throw error;
+			}
+		}
+	}
+}
+function protectKnowledgePaths(ctx, knowledge) {
+	const privateHome = dirname(dirname(agentHomePath(knowledge.config.home, "private-root")));
+	const privateAlias = async (path, recursive, signal) => {
+		const privateLinks = /* @__PURE__ */ new Set();
+		for await (const identity of linkedFiles(privateHome, signal)) privateLinks.add(identity);
+		if (privateLinks.size === 0) return false;
+		if (recursive) {
+			for await (const identity of linkedFiles(path, signal)) if (privateLinks.has(identity)) return true;
+		} else {
+			const info = await fs.lstat(path);
+			return privateLinks.has(`${info.dev}:${info.ino}`);
+		}
+		return false;
+	};
+	const validated = /* @__PURE__ */ new WeakMap();
+	const targetAllowed = async (target, recursive, signal) => {
+		const mapped = ctx.fs.processPathFromHostPath(dirname(dirname(agentHomePath(knowledge.config.home, "private-root"))));
+		if (mapped === void 0) return true;
+		const root = await ctx.fs.resolve(mapped, signal === void 0 ? {} : { signal });
+		return !ctx.fs.contains(root, target) && !(recursive && ctx.fs.contains(target, root));
+	};
+	ctx.on("fs/write-intent", async (target, _actor, next) => {
+		if (!await targetAllowed(target, false)) throw new Error(denial);
+		return next();
+	});
+	ctx.on("fs/edit-intent", async (target, _actor, next) => {
+		if (!await targetAllowed(target, false)) throw new Error(denial);
+		return next();
+	});
+	ctx.on("tools/pre-execute", async (execution, next) => {
+		const decision = await next();
+		if (decision.kind === "deny" || decision.kind === "cancel" || !fileTools.has(execution.name)) return decision;
+		const args = execution.arguments;
+		if (typeof args !== "object" || args === null || Array.isArray(args)) return {
+			kind: "deny",
+			reason: denial
+		};
+		const fields = args;
+		const search = execution.name === "grep" || execution.name === "glob";
+		const key = "file_path" in fields ? "file_path" : "path" in fields || search ? "path" : void 0;
+		if (key === void 0 || fields[key] !== void 0 && typeof fields[key] !== "string") return {
+			kind: "deny",
+			reason: denial
+		};
+		const cwd = execution.agent === void 0 ? process.cwd() : await ctx.workingDirectory.ensure(execution.agent, execution.signal);
+		const target = await ctx.fs.resolve(typeof fields[key] === "string" ? fields[key] : cwd, {
+			cwd,
+			signal: execution.signal
+		});
+		const info = await ctx.fs.stat(target, execution.signal);
+		if (!await targetAllowed(target, search || info?.type === "directory", execution.signal)) return {
+			kind: "deny",
+			reason: denial
+		};
+		const path = ctx.fs.processPath(target);
+		if (ctx.fs.processPathFromHostPath(resolve(path)) === path) try {
+			const stat = await fs.lstat(path);
+			if ((stat.isFile() && stat.nlink > 1 || search && stat.isDirectory()) && await privateAlias(path, search && stat.isDirectory(), execution.signal)) return {
+				kind: "deny",
+				reason: denial
+			};
+		} catch (error) {
+			if (!hasCode(error, "ENOENT")) throw error;
+		}
+		validated.set(execution, {
+			fingerprint: fingerprint(execution),
+			cwd
+		});
+		return decision;
+	});
+	ctx.tools.guard((execution) => {
+		if (!fileTools.has(execution.name)) return;
+		const approved = validated.get(execution);
+		const cwd = execution.agent === void 0 ? process.cwd() : ctx.workingDirectory.get(execution.agent.session);
+		return approved?.fingerprint !== fingerprint(execution) || approved.cwd !== cwd ? denial : void 0;
+	});
+}
+//#endregion
+//#region src/dsh-adapter/project-upstream.ts
+async function recentProjectSelection(ctx, current) {
+	if (current.cwd === void 0 || isSubagent(current)) return void 0;
+	try {
+		const persistence = ctx.get("sessionPersistence");
+		const headers = /* @__PURE__ */ new Map();
+		if (persistence !== void 0) for (const snapshot of await persistence.list()) headers.set(snapshot.header.id, snapshot.header);
+		for (const session of ctx.sessions.list()) headers.set(session.id, session.header);
+		const project = await canonicalProjectPath(current.cwd);
+		const paths = /* @__PURE__ */ new Map();
+		const candidates = [...headers.values()].filter((header) => header.id !== current.id && header.createdAt <= current.createdAt && header.cwd !== void 0 && !isSubagent(header));
+		candidates.sort((left, right) => right.createdAt - left.createdAt || right.id.localeCompare(left.id));
+		for (const header of candidates) {
+			if (header.cwd === void 0) continue;
+			let path = paths.get(header.cwd);
+			if (path === void 0) {
+				path = await canonicalProjectPath(header.cwd);
+				paths.set(header.cwd, path);
+			}
+			if (path !== project) continue;
+			const live = ctx.sessions.get(header.id);
+			if (live !== void 0) {
+				const selection = sessionSelection(ctx, live.header);
+				if (selection === void 0) continue;
+				return selection;
+			}
+			if (persistence === void 0) continue;
+			const handle = await persistence.open(header.id, "read");
+			try {
+				const { events } = await handle.read();
+				restoreSessionBinding(handle.header, events);
+				return sessionSelection(ctx, handle.header);
+			} finally {
+				await handle.close();
+			}
+		}
+	} catch {
+		ctx.logger.warn("Could not read the recent project selection; the global default will be used.");
+	}
+}
+//#endregion
+//#region src/dsh-adapter/runtime-pool.ts
+var RuntimePool = class {
+	owner;
+	base;
+	runtimes = /* @__PURE__ */ new Map();
+	ready = /* @__PURE__ */ new Map();
+	workers = /* @__PURE__ */ new Map();
+	preferredWorkers = /* @__PURE__ */ new Map();
+	retiredWorkers = /* @__PURE__ */ new Set();
+	starting = Promise.resolve();
+	instructions = /* @__PURE__ */ new Map();
+	render;
+	syncs = /* @__PURE__ */ new Map();
+	syncTasks = /* @__PURE__ */ new Map();
+	baselines = /* @__PURE__ */ new Set();
+	baselineRenderers = /* @__PURE__ */ new Map();
+	admissions = /* @__PURE__ */ new Map();
+	resumed = /* @__PURE__ */ new Set();
+	attached = /* @__PURE__ */ new Map();
+	unboundTools = /* @__PURE__ */ new Map();
+	components = /* @__PURE__ */ new Map();
+	pending = Promise.resolve();
+	closed = false;
+	get preparing() {
+		return this.runtimes.size !== this.ready.size || [...this.syncs.values()].some((state) => state.phase === "syncing");
+	}
+	host;
+	get ctx() {
+		return this.host ?? this.owner;
+	}
+	constructor(owner, base) {
+		this.owner = owner;
+		this.base = base;
+		owner.inject([
+			"agents",
+			"sessions",
+			"systemPrompt",
+			"llm",
+			"tools"
+		], async (child) => {
+			this.host = child;
+			await this.install(child);
+		});
+	}
+	component(name) {
+		const token = Symbol(name);
+		const owners = this.components.get(name) ?? /* @__PURE__ */ new Set();
+		owners.add(token);
+		this.components.set(name, owners);
+		this.schedule(async () => {
+			const values = await Promise.allSettled([...this.runtimes.values()]);
+			for (const value of values) if (value.status === "fulfilled") await value.value.setComponent(name, true);
+		});
+		return async () => {
+			owners.delete(token);
+			if (owners.size > 0) return;
+			await this.pending;
+			for (const runtime of this.ready.values()) await runtime.setComponent(name, false);
+		};
+	}
+	supportsJob(key, kind) {
+		const config = this.config(key, true);
+		if (config === void 0) return false;
+		const component = kind === "recap" || kind === "finalize" ? "formation" : kind;
+		return this.enabled(component) && (kind !== "dream" || config.dream.enabled);
+	}
+	enabled(name) {
+		return (this.components.get(name)?.size ?? 0) > 0;
+	}
+	choices() {
+		return Object.entries(upstreamsOf(this.base.config)).map(([key, item]) => ({
+			key,
+			name: item.name || key,
+			agentId: item.agentId,
+			enabled: item.enabled,
+			mode: item.routerEndpoint ? "team" : "solo"
+		}));
+	}
+	config(key, includeDisabled = false) {
+		const profiles = upstreamsOf(this.base.config);
+		const mapped = profiles[key] === void 0 ? Object.keys(profiles).find((name) => profiles[name]?.legacyKey === key) : key;
+		return mapped === void 0 ? void 0 : resolveUpstream(this.base.config, mapped, includeDisabled);
+	}
+	forSession(header) {
+		const config = this.config(this.key(header));
+		const running = runningConfiguration(header);
+		return config !== void 0 && running !== void 0 && identityOf(running) === identityOf(config) ? running : config;
+	}
+	runtimeId(key, config) {
+		return key + "@" + createHash("sha256").update(JSON.stringify([
+			config.home,
+			config.agentId,
+			config.team,
+			config.llm
+		])).digest("hex");
+	}
+	prefer(header) {
+		if (isSubagent(header) || !this.allowed(header)) return;
+		const config = this.forSession(header);
+		if (config !== void 0) this.preferredWorkers.set(identityOf(config), this.runtimeId(this.key(header), config));
+	}
+	readyFor(header) {
+		const config = this.forSession(header);
+		return config === void 0 ? void 0 : this.ready.get(this.runtimeId(this.key(header), config));
+	}
+	backgroundSelection(config) {
+		const identity = identityOf(config);
+		const key = this.choices().find((choice) => {
+			const current = this.config(choice.key);
+			return current !== void 0 && identityOf(current) === identity;
+		})?.key;
+		return key === void 0 ? void 0 : {
+			schemaVersion: 1,
+			key,
+			identity,
+			prepared: true
+		};
+	}
+	selected(header) {
+		return sessionSelection(this.ctx, header);
+	}
+	defaultFor() {
+		return defaultUpstream(this.base.config);
+	}
+	sessionView(header, events) {
+		return Promise.resolve(this.view(header, events));
+	}
+	key(header) {
+		const key = this.selected(header)?.key ?? (this.base.config.upstreams === void 0 ? this.base.mode === "team" ? "legacy" : "personal" : this.defaultFor());
+		const profiles = upstreamsOf(this.base.config);
+		return profiles[key] === void 0 ? Object.keys(profiles).find((name) => profiles[name]?.legacyKey === key) ?? key : key;
+	}
+	isBase(key) {
+		return key === "" || this.base.config.upstreams === void 0 && key === (this.base.mode === "team" ? "legacy" : "personal");
+	}
+	allowed(header) {
+		const selected = this.selected(header);
+		if (selected === void 0) return this.base.config.upstreams === void 0 ? sessionAllowed(this.ctx, this.base.config, header) : Object.keys(this.base.config.upstreams).length === 0;
+		const config = this.config(selected.key);
+		return config !== void 0 && selected.identity === identityOf(config) && config.agentId !== "";
+	}
+	unbound(header, events) {
+		return !this.allowed(header) && sessionUnbound(this.ctx, header, events);
+	}
+	chatAllowed(header) {
+		return this.allowed(header) || this.unbound(header);
+	}
+	async knowledge(header) {
+		await this.pending;
+		if (!this.allowed(header)) throw new JobError("identity", this.unbound(header) ? unboundSession : "团队连接不可用或身份已改变，请检查连接，或新建会话。");
+		const key = this.key(header);
+		return this.isBase(key) ? this.base : (await this.ensure(key, header.cwd, this.forSession(header))).knowledge;
+	}
+	async service(header) {
+		await this.pending;
+		if (!this.allowed(header)) throw new JobError("identity", this.unbound(header) ? unboundSession : "当前会话的知识身份不可用。");
+		const key = this.key(header);
+		if (!this.isBase(key)) {
+			const runtime = await this.ensure(key, header.cwd, this.forSession(header));
+			return {
+				knowledge: runtime.knowledge,
+				formation: runtime.components.has("formation") ? runtime.formation : void 0,
+				inbox: runtime.components.has("inbox") ? runtime.inbox : void 0,
+				dream: runtime.components.has("dream") ? runtime.dream : void 0
+			};
+		}
+		return {
+			knowledge: this.base,
+			formation: this.ctx.get("acnFormation"),
+			inbox: this.ctx.get("acnInbox"),
+			dream: this.ctx.get("acnDream")
+		};
+	}
+	async activate(key) {
+		await this.pending;
+		const config = this.config(key);
+		if (config === void 0 || config.agentId === "") throw new JobError("connection", "知识身份不可用，请恢复连接后重试。");
+		this.preferredWorkers.set(identityOf(config), this.runtimeId(key, config));
+		return this.isBase(key) ? this.base : (await this.ensure(key)).knowledge;
+	}
+	async dreamService(key) {
+		await this.activate(key);
+		if (this.isBase(key)) return this.ctx.get("acnDream");
+		const runtime = await this.ensure(key);
+		return runtime.components.has("dream") ? runtime.dream : void 0;
+	}
+	registerBaseline(refresh, render) {
+		this.baselines.add(refresh);
+		this.baselineRenderers.set(refresh, render);
+		return () => {
+			this.baselines.delete(refresh);
+			this.baselineRenderers.delete(refresh);
+		};
+	}
+	hasUser(header) {
+		const session = this.ctx.sessions.get(header.id);
+		return session === void 0 || session.snapshotEvents().some((event) => event.type === "user/message" && event.data.source.kind === "user");
+	}
+	selectionLocked(header, events) {
+		const history = events ?? this.ctx.sessions.get(header.id)?.snapshotEvents();
+		return history === void 0 || header.isSeeded === true || header.parentSession !== void 0 || isSubagent(header) || this.unbound(header, history) && !sessionEligible(this.ctx, header, history) || sessionHasWork(history);
+	}
+	view(header, events) {
+		if (events !== void 0) restoreSessionBinding(header, events);
+		const state = this.syncs.get(header.id);
+		const available = this.allowed(header);
+		const unbound = this.unbound(header, events);
+		const key = unbound ? "" : this.key(header);
+		const active = unbound ? void 0 : this.forSession(header);
+		const current = this.config(key);
+		const configurationChanged = active !== void 0 && current !== void 0 && JSON.stringify(active.team) !== JSON.stringify(current.team);
+		let message = state?.message ?? "";
+		if (unbound) message = this.selectionLocked(header, events) ? unboundSession : "本会话尚未启用 ACN，可直接聊天，或在首条消息前选择工作配置。";
+		else if (!available) message = !this.selectionLocked(header, events) ? "请从 ACN 菜单选择可用的工作配置，初始化当前空白会话。" : "工作配置已停用、缺失或 Agent ID 已改变；请在设置中恢复同一配置及原 Agent ID，或使用新会话。";
+		else if (configurationChanged && message === "") message = "已保存新连接，当前会话仍使用启动时的配置。";
+		else if (message === "" && this.selected(header)?.prepared === false) message = "上次同步未完成，可继续本地工作或重试同步。";
+		return {
+			sessionId: header.id,
+			key,
+			name: this.choices().find((item) => item.key === key)?.name ?? "选择工作配置",
+			activeMode: active?.team.routerEndpoint ? "team" : "solo",
+			configurationChanged,
+			available,
+			locked: this.selectionLocked(header, events),
+			explicitSelection: this.selected(header) !== void 0,
+			needsPreparation: this.syncTasks.has(header.id),
+			phase: unbound ? "unbound" : !available ? "blocked" : this.syncTasks.has(header.id) ? "syncing" : state?.phase ?? (this.selected(header)?.prepared === false ? "failed" : "ready"),
+			message,
+			choices: this.choices(),
+			defaultConnection: this.defaultFor(),
+			showCompletion: this.base.config.showCompletion
+		};
+	}
+	async select(header, key) {
+		await this.pending;
+		if (this.selectionLocked(header)) throw new JobError("bound", "会话开始后不能切换知识归属，请新建会话。");
+		if (this.syncs.get(header.id)?.phase === "syncing") throw new JobError("busy", "收件同步仍在进行，可取消等待后重试。");
+		const config = this.config(key);
+		if (config === void 0 || config.agentId === "") throw new JobError("connection", "请先配置可用身份和团队连接。");
+		const attached = this.attached.get(header.id);
+		const previous = attached === void 0 ? void 0 : this.ready.get(attached);
+		if (previous !== void 0) await previous.catalog.flush(header.id);
+		if (this.selectionLocked(header)) throw new JobError("bound", "会话开始后不能切换知识归属，请新建会话。");
+		const session = this.ctx.sessions.get(header.id);
+		if (session === void 0) throw new JobError("session", "会话已关闭，请重新打开。");
+		if (previous !== void 0) {
+			previous.formation.disposed(header.id);
+			previous.catalog.clear(header.id);
+			this.attached.delete(header.id);
+		}
+		appendPluginRecord(session, "plugin:acn/team-selection", {
+			schemaVersion: 1,
+			key,
+			identity: identityOf(config),
+			prepared: config.team.routerEndpoint === ""
+		});
+		rememberConfiguration(header, config);
+		this.prefer(header);
+		this.instructions.delete(header.id);
+		if (!this.isBase(key)) await this.ensure(key, header.cwd, config);
+		if (config.team.routerEndpoint !== "") await this.sync(header);
+		else this.syncs.set(header.id, {
+			phase: "ready",
+			message: "单人模式已就绪，不连接团队服务。"
+		});
+		if (config.team.routerEndpoint === "" && this.syncs.get(header.id)?.phase !== "failed" && this.key(header) === key) if (this.isBase(key)) for (const refresh of this.baselines) await refresh(header.id);
+		else await this.attach(header, "clear");
+		return this.view(header);
+	}
+	async cancel(header) {
+		const preparing = this.syncTasks.get(header.id);
+		if (preparing === void 0) return;
+		const state = this.syncs.get(header.id);
+		state?.controller?.abort();
+		if (state !== void 0) state.message = "正在结束同步并准备本地知识，已持久化的收件保留。";
+		await preparing;
+	}
+	sync(header) {
+		if (this.syncTasks.has(header.id)) return Promise.reject(new JobError("busy", "收件同步仍在进行。"));
+		const task = this.synchronize(header);
+		this.syncTasks.set(header.id, task);
+		const finish = () => {
+			if (this.syncTasks.get(header.id) === task) this.syncTasks.delete(header.id);
+		};
+		task.then(finish, finish);
+		return task;
+	}
+	async synchronize(header) {
+		const hadUserAtStart = this.hasUser(header);
+		if (this.syncs.get(header.id)?.phase === "syncing") throw new JobError("busy", "收件同步仍在进行。");
+		const selectedKey = this.key(header);
+		if (this.base.config.upstreams === void 0 && selectedKey === "personal") throw new JobError("connection", "单人模式没有团队收件箱。");
+		const controller = new AbortController();
+		const state = {
+			phase: "syncing",
+			message: "正在同步团队收件并准备本地知识…",
+			controller
+		};
+		this.syncs.set(header.id, state);
+		try {
+			const services = await this.service(header);
+			if (services.inbox === void 0 || services.knowledge.jobs === null) throw new JobError("unavailable", "收件处理器不可用，请启用对应插件组件。");
+			const agent = this.ctx.agents.get(header.id);
+			if (!services.knowledge.config.llm.provider && agent !== void 0) {
+				let pending;
+				let last;
+				for (const event of agent.session.snapshotEvents()) {
+					if (event.type === "model/selection") pending = {
+						provider: event.data.provider,
+						model: event.data.model
+					};
+					if (event.type === "request/header") {
+						last = {
+							provider: event.data.header.config.provider,
+							model: event.data.header.config.model
+						};
+						if (pending?.provider === last.provider && pending.model === last.model) pending = void 0;
+					}
+				}
+				const route = pending ?? last ?? RouteSchema.safeParse({
+					provider: agent.options.provider,
+					model: agent.options.model
+				}).data;
+				if (route !== void 0) {
+					const context = services.knowledge.context();
+					await withFileLock(`${context.paths.lastRoute}.lock`, () => writeYamlAtomic(context.paths.lastRoute, route, RouteSchema, context.logger));
+				}
+			}
+			let routerFailed = false;
+			if (services.knowledge.team !== null) {
+				const team = services.knowledge.team;
+				try {
+					await team.request("router", () => team.router.overview(controller.signal));
+				} catch {
+					routerFailed = true;
+				}
+			}
+			const report = await services.inbox.request(controller.signal, header.id);
+			const deadline = Date.now() + services.knowledge.config.llm.timeoutMs;
+			for (;;) {
+				controller.signal.throwIfAborted();
+				const job = (await services.knowledge.jobs.queue.list()).find((item) => item.id === report.jobId);
+				if (job?.state === "failed") throw new JobError("inbox", job.lastError ?? "收件内化失败，请检查知识模型后重试。");
+				if (job?.state === "succeeded") break;
+				if (Date.now() >= deadline) throw new JobError("timeout", "收件处理仍在后台进行，请稍后重试同步并查看处理活动。");
+				await new Promise((resolve) => {
+					const finish = () => {
+						clearTimeout(timer);
+						controller.signal.removeEventListener("abort", finish);
+						resolve();
+					};
+					const timer = setTimeout(finish, 100);
+					controller.signal.addEventListener("abort", finish, { once: true });
+				});
+			}
+			controller.signal.throwIfAborted();
+			if (this.key(header) !== selectedKey) throw new JobError("superseded", "同步已被新的选择取代。");
+			controller.signal.throwIfAborted();
+			const session = this.ctx.sessions.get(header.id);
+			const selection = this.selected(header);
+			if (session !== void 0 && selection !== void 0 && this.key(header) === selectedKey) appendPluginRecord(session, "plugin:acn/team-selection", {
+				...selection,
+				prepared: true
+			});
+			state.phase = routerFailed || report.warnings.length > 0 ? "failed" : "ready";
+			state.message = [
+				routerFailed ? "Router 概览暂不可用。" : "",
+				report.warnings.length > 0 ? "Maintainer 收件或确认未完成。" : `收件同步完成：拉取 ${report.pulled} 条。`,
+				"本地收件已处理，可继续使用本地知识。"
+			].filter(Boolean).join(" ");
+		} catch (error) {
+			state.phase = "failed";
+			state.message = controller.signal.aborted ? "已取消同步等待，已持久化的收件保留，可继续使用本地知识。" : (error instanceof JobError ? error.message : "同步失败，请检查 Router、Maintainer 地址、团队鉴权密钥、知识模型和本地存储后重试。") + " 可继续使用本地知识。";
+		} finally {
+			delete state.controller;
+			const selectedConfig = this.forSession(header);
+			const missingAttachment = !this.isBase(this.key(header)) && selectedConfig !== void 0 && this.attached.get(header.id) !== this.runtimeId(this.key(header), selectedConfig);
+			if (this.allowed(header) && (!hadUserAtStart || missingAttachment)) if (this.isBase(this.key(header))) for (const refresh of this.baselines) await refresh(header.id, state.phase !== "failed");
+			else await this.attach(header, hadUserAtStart ? "resume" : "clear", false);
+		}
+	}
+	ensure(key, workspace, selected) {
+		const config = selected ?? this.config(key);
+		if (config === void 0 || this.closed) return Promise.reject(new JobError("connection", "团队连接不可用。"));
+		const runtimeId = this.runtimeId(key, config);
+		const previous = this.runtimes.get(runtimeId);
+		const ready = this.ready.get(runtimeId);
+		const ownsCurrent = this.preferredWorkers.get(identityOf(config)) === runtimeId;
+		if (previous !== void 0 && (!ownsCurrent || ready === void 0 || !this.retiredWorkers.has(ready))) return previous;
+		const creating = this.starting.then(async () => {
+			if (ready !== void 0) {
+				this.ready.delete(runtimeId);
+				await ready.close();
+				this.retiredWorkers.delete(ready);
+			}
+			return this.create(config, workspace, ownsCurrent);
+		});
+		this.starting = creating.then(() => {}, () => {});
+		this.runtimes.set(runtimeId, creating);
+		creating.then((runtime) => {
+			this.ready.set(runtimeId, runtime);
+		}, () => {});
+		creating.catch(() => {
+			if (this.runtimes.get(runtimeId) === creating) this.runtimes.delete(runtimeId);
+		});
+		return creating;
+	}
+	async create(config, workspace, current = true) {
+		const knowledge = new AcnKnowledge(config, this.ctx.logger, teamCredentials(this.ctx));
+		await knowledge.initialize();
+		if (workspace !== void 0) await writeYamlAtomic(knowledge.context().paths.dreamWorkspace, workspace, z.string(), knowledge.logger);
+		const render = await loadPromptRenderer();
+		this.render = render;
+		const backend = structuredBackend(this.ctx);
+		const catalog = new KnowledgeSessions(knowledge);
+		const replay = formationReplay(this.ctx, config);
+		const formation = new AcnFormation(knowledge, backend, render, {}, knowledge.jobs ?? void 0, async (route) => {
+			try {
+				await this.ctx.llm.prepareCall(route, AbortSignal.timeout(15e3));
+				return true;
+			} catch {
+				return false;
+			}
+		}, replay);
+		const inbox = new AcnInbox(knowledge, backend, render);
+		const dream = new AcnDream(knowledge, backend, render, () => this.pending, {
+			workspace: () => readYamlOr(knowledge.context().paths.dreamWorkspace, z.string(), () => process.cwd()),
+			run: autonomousDreamRunner(this.ctx)
+		});
+		const uploads = new UploadScheduler(knowledge);
+		const runtime = {
+			knowledge,
+			formation,
+			inbox,
+			dream,
+			catalog,
+			uploads,
+			components: /* @__PURE__ */ new Set(),
+			setComponent: async (component, enabled) => {
+				if (runtime.components.has(component) === enabled) return;
+				if (enabled) {
+					if (component === "formation") {
+						runtime.formation = new AcnFormation(knowledge, backend, render, {}, knowledge.jobs ?? void 0, void 0, replay);
+						await runtime.formation.start();
+					}
+					if (component === "inbox") {
+						runtime.inbox = new AcnInbox(knowledge, backend, render);
+						await runtime.inbox.start();
+					}
+					if (component === "dream") {
+						runtime.dream = new AcnDream(knowledge, backend, render, () => this.pending, {
+							workspace: () => readYamlOr(knowledge.context().paths.dreamWorkspace, z.string(), () => process.cwd()),
+							run: autonomousDreamRunner(this.ctx)
+						});
+						await runtime.dream.start();
+					}
+					runtime.components.add(component);
+					for (const agent of this.ctx.agents.list()) if (this.allowed(agent.session.header) && this.readyFor(agent.session.header) === runtime) await this.attach(agent.session.header, "resume", false);
+				} else {
+					runtime.components.delete(component);
+					if (component === "formation") await runtime.formation.close();
+					if (component === "inbox") await runtime.inbox.close();
+					if (component === "dream") await runtime.dream.close();
+					if (component === "prompt") await runtime.catalog.flush();
+				}
+			},
+			close: async () => {
+				await runtime.formation.close();
+				await runtime.inbox.close();
+				await runtime.dream.close();
+				await catalog.flush();
+				await uploads.close();
+				await knowledge.jobs?.close();
+				await knowledge.team?.close();
+			}
+		};
+		try {
+			const identity = identityOf(config);
+			const previous = this.workers.get(identity);
+			if (previous !== void 0) if (current) {
+				await previous.uploads.close();
+				await previous.knowledge.jobs?.close();
+				this.retiredWorkers.add(previous);
+			} else {
+				await knowledge.jobs?.close();
+				await uploads.close();
+				this.retiredWorkers.add(runtime);
+			}
+			if (current || previous === void 0) this.workers.set(identity, runtime);
+			await this.ctx.inject(["workspaceRegistry"], (child) => connectArchives(child, {
+				beginArchive: (id, upper) => runtime.components.has("formation") ? runtime.formation.beginArchive(id, upper) : Promise.resolve(null),
+				cancelArchive: (id) => runtime.formation.cancelArchive(id),
+				archived: (id, upper) => runtime.formation.archived(id, upper),
+				reconcileArchives: (ids) => runtime.formation.reconcileArchives(ids)
+			}, formationOwnership(child, config)));
+			for (const name of [
+				"prompt",
+				"formation",
+				"inbox",
+				"dream"
+			]) if (this.enabled(name)) {
+				runtime.components.add(name);
+				if (name === "formation") await formation.start();
+				if (name === "inbox") await inbox.start();
+				if (name === "dream") await dream.start();
+			} else {
+				if (name === "formation") await formation.close();
+				if (name === "inbox") await inbox.close();
+				if (name === "dream") await dream.close();
+			}
+			await knowledge.jobs?.start();
+			uploads.start();
+			return runtime;
+		} catch (error) {
+			await runtime.close();
+			throw error;
+		}
+	}
+	async freezeInstructions(header, knowledge) {
+		if (this.base.config.upstreams === void 0 || this.instructions.has(header.id)) return;
+		const file = join(knowledge.context().paths.session(header.id), "upstream-instructions.yaml");
+		let text = await readYamlOr(file, z.string(), () => null);
+		if (text === null && header.parentSession !== void 0) text = await readYamlOr(join(knowledge.context().paths.session(header.parentSession), "upstream-instructions.yaml"), z.string(), () => null);
+		if (text === null) {
+			text = "";
+			if (!(this.ctx.sessions.get(header.id)?.snapshotEvents().some((event) => event.type === "request/header") ?? true)) try {
+				text = await fs.readFile(join(resolve(agentHomePath(this.base.config.home, "example"), "..", ".."), this.key(header), "ACN.md"), "utf8");
+			} catch (error) {
+				if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+			}
+			await writeYamlAtomic(file, text, z.string(), knowledge.logger);
+		}
+		this.instructions.set(header.id, text);
+	}
+	async bind(header) {
+		if (this.base.config.upstreams === void 0 || isEvidenceAgent(header)) return;
+		const session = this.ctx.sessions.get(header.id);
+		if (session === void 0) return;
+		let selection = this.selected(header);
+		if (selection === void 0 && header.parentSession !== void 0) {
+			const parent = this.ctx.sessions.get(header.parentSession);
+			if (parent !== void 0 && this.allowed(parent.header)) selection = this.selected(parent.header);
+		}
+		if (selection === void 0) {
+			restoreSessionBinding(header, session.snapshotEvents());
+			const key = this.choices().find((choice) => {
+				const config = this.config(choice.key);
+				return config !== void 0 && config.agentId !== "" && sessionAllowed(this.ctx, config, header);
+			})?.key;
+			const config = key === void 0 ? void 0 : this.config(key);
+			if (key !== void 0 && config !== void 0) selection = {
+				schemaVersion: 1,
+				key,
+				identity: identityOf(config),
+				prepared: true
+			};
+		}
+		if (selection === void 0 && session.firstLiveSeq === 0 && sessionEligible(this.ctx, header) && !sessionHasWork(session.snapshotEvents()) && !header.isSeeded && header.parentSession === void 0) {
+			const recent = await recentProjectSelection(this.ctx, header);
+			const previous = recent === void 0 ? void 0 : this.config(recent.key);
+			const key = recent !== void 0 && previous !== void 0 && recent.identity === identityOf(previous) ? recent.key : this.defaultFor();
+			const config = this.config(key);
+			if (config !== void 0) selection = {
+				schemaVersion: 1,
+				key,
+				identity: identityOf(config),
+				prepared: true
+			};
+		}
+		if (selection === void 0) return;
+		if (this.selected(header) === void 0) {
+			appendPluginRecord(session, "plugin:acn/team-selection", selection);
+			restoreSessionBinding(header, session.snapshotEvents());
+		}
+		const config = this.config(selection.key);
+		if (config !== void 0 && identityOf(config) === selection.identity && runningConfiguration(header) === void 0) rememberConfiguration(header, config);
+	}
+	async attach(header, source, synchronize = true, signal) {
+		signal?.throwIfAborted();
+		if (!this.allowed(header) || this.isBase(this.key(header)) || isEvidenceAgent(header)) return;
+		const ready = this.ensure(this.key(header), header.cwd, this.forSession(header));
+		const runtime = signal === void 0 ? await ready : await abortable(ready, signal);
+		if (synchronize && this.base.config.upstreams !== void 0 && (source === "startup" || source === "resume") && !isSubagent(header) && runtime.components.has("inbox") && runtime.knowledge.config.inbox.pullOnSessionStart) {
+			await this.sync(header);
+			if (!this.hasUser(header)) return;
+		}
+		await this.freezeInstructions(header, runtime.knowledge);
+		if (runtime.components.has("prompt")) await runtime.catalog.freeze(header.id, source, header.parentSession, this.syncs.get(header.id)?.phase !== "failed", signal);
+		if (!isSubagent(header)) {
+			if (runtime.components.has("formation")) {
+				runtime.formation.attach(header.id);
+				if (this.ctx.agents.get(header.id)?.status === "running") runtime.formation.running(header.id);
+			}
+			if (header.cwd !== void 0) await writeYamlAtomic(runtime.knowledge.context().paths.dreamWorkspace, header.cwd, z.string(), runtime.knowledge.logger);
+			if (runtime.components.has("dream")) runtime.dream.trigger();
+		}
+		this.attached.set(header.id, this.runtimeId(this.key(header), runtime.knowledge.config));
+	}
+	async prepareSession(header, signal) {
+		signal?.throwIfAborted();
+		const preparing = Promise.all([this.pending, this.syncTasks.get(header.id)]);
+		if (signal === void 0) await preparing;
+		else await abortable(preparing, signal);
+		signal?.throwIfAborted();
+		if (this.unbound(header)) {
+			const agent = this.ctx.agents.get(header.id);
+			const deny = ["claim", "consult_router"].filter((name) => this.ctx.tools.get(name) !== void 0);
+			const previous = this.unboundTools.get(header.id);
+			if (agent !== void 0 && previous?.names !== deny.join(",")) {
+				previous?.release();
+				this.unboundTools.delete(header.id);
+				if (deny.length > 0) this.unboundTools.set(header.id, {
+					names: deny.join(","),
+					release: agent.ctx.tools.restrict({ deny })
+				});
+			}
+			return;
+		}
+		if (!this.allowed(header)) throw new JobError("identity", "会话的知识归属不可用，请恢复原连接或新建会话。");
+		if (this.syncs.get(header.id)?.phase === "syncing") throw new JobError("sync", "收件同步仍在进行，可取消等待后继续本地工作。");
+		if (!this.isBase(this.key(header))) {
+			const ready = this.ensure(this.key(header), header.cwd, this.forSession(header));
+			const runtime = signal === void 0 ? await ready : await abortable(ready, signal);
+			if (this.attached.get(header.id) !== this.runtimeId(this.key(header), runtime.knowledge.config)) await this.attach(header, "resume", false, signal);
+			if (runtime.components.has("prompt") && runtime.catalog.catalog(header.id) === "") await runtime.catalog.freeze(header.id, "resume", header.parentSession, true, signal);
+		}
+	}
+	async install(ctx) {
+		const forAgent = (header, component) => {
+			const runtime = header === void 0 || !this.allowed(header) || this.isBase(this.key(header)) ? void 0 : this.readyFor(header);
+			return runtime?.components.has(component) ? runtime : void 0;
+		};
+		const contributions = [
+			{
+				name: "acn:upstream-instructions",
+				order: 730,
+				interpolate: false,
+				text: ({ agent }) => agent === void 0 || isEvidenceAgent(agent.session.header) || !this.allowed(agent.session.header) ? "" : this.instructions.get(agent.session.id) ?? ""
+			},
+			{
+				name: "acn:connection-knowledge",
+				order: 700,
+				interpolate: false,
+				text: ({ agent }) => {
+					const runtime = forAgent(agent?.session.header, "prompt");
+					return runtime === void 0 ? "" : this.render?.("knowledge.j2", {
+						agent_id: runtime.knowledge.agentId,
+						team: runtime.knowledge.mode === "team"
+					}) ?? "";
+				}
+			},
+			{
+				name: "acn:connection-catalog",
+				order: 710,
+				interpolate: false,
+				text: ({ agent }) => forAgent(agent?.session.header, "prompt")?.catalog.catalog(agent?.session.id ?? "") ?? ""
+			}
+		];
+		for (const section of contributions) ctx.systemPrompt.section(section);
+		ctx.on("system-prompt/assemble", async (_assembly, context, next) => {
+			const header = context.agent?.session.header;
+			if (header === void 0 || isEvidenceAgent(header)) return next();
+			if (this.unbound(header)) {
+				await this.prepareSession(header, context.signal);
+				const assembly = await next();
+				return {
+					...assembly,
+					tools: assembly.tools.filter((tool) => !["claim", "consult_router"].includes(tool.name))
+				};
+			}
+			if (!this.allowed(header)) return next();
+			await this.prepareSession(header, context.signal);
+			context.signal?.throwIfAborted();
+			const assembly = await next();
+			const baseSections = this.isBase(this.key(header)) ? Object.assign({}, ...[...this.baselineRenderers.values()].map((render) => render(header))) : {};
+			return {
+				...assembly,
+				sections: assembly.sections.map((section) => {
+					if (Object.hasOwn(baseSections, section.name)) return {
+						...section,
+						text: baseSections[section.name] ?? ""
+					};
+					const definition = contributions.find((item) => item.name === section.name);
+					return definition === void 0 ? section : {
+						...section,
+						text: typeof definition.text === "function" ? definition.text(context) : definition.text
+					};
+				})
+			};
+		});
+		ctx.on("agent/created", async ({ agent, source, signal }) => {
+			if (source === "startup") markSessionEligible(ctx, agent.session.header);
+			await this.bind(agent.session.header);
+			this.prefer(agent.session.header);
+			await this.attach(agent.session.header, source, true, signal);
+			if (source === "resume") this.resumed.add(agent.session.id);
+		});
+		ctx.on("agent/pre-step", async ({ agent, signal }, next) => {
+			if (isEvidenceAgent(agent.session.header)) return next();
+			await this.prepareSession(agent.session.header, signal);
+			if (this.unbound(agent.session.header)) return next();
+			if (this.resumed.delete(agent.session.id) && this.base.config.upstreams === void 0 && !isSubagent(agent.session.header) && !this.isBase(this.key(agent.session.header))) {
+				const runtime = await this.ensure(this.key(agent.session.header), agent.session.header.cwd, this.forSession(agent.session.header));
+				if (runtime.components.has("inbox") && runtime.knowledge.mode === "team" && runtime.knowledge.config.inbox.pullOnSessionStart) await runtime.inbox.enqueue(true, agent.session.id);
+			}
+			const decision = await next();
+			if (decision.kind === "reject" || this.isBase(this.key(agent.session.header))) return decision;
+			const runtime = await this.ensure(this.key(agent.session.header), agent.session.header.cwd, this.forSession(agent.session.header));
+			const notice = runtime.components.has("prompt") ? await runtime.catalog.prepare(agent.session.id, signal) : null;
+			signal.throwIfAborted();
+			if (notice === null) return decision;
+			const message = createUserMessage({
+				content: [{
+					type: "text",
+					text: notice.text
+				}],
+				source: { kind: "acn-claim-changes" }
+			});
+			this.admissions.set(message.id, {
+				id: agent.session.id,
+				runtime,
+				notice
+			});
+			return {
+				...decision,
+				messages: [...decision.messages, message]
+			};
+		});
+		ctx.on("session/event", (session, event) => {
+			const admission = event.type === "user/message" ? this.admissions.get(event.data.id) : void 0;
+			if (admission?.id === session.id && event.type === "user/message") {
+				this.admissions.delete(event.data.id);
+				admission.runtime.catalog.admitted(session.id, admission.notice);
+			}
+			if (!this.allowed(session.header) || this.isBase(this.key(session.header)) || isSubagent(session.header)) return;
+			const runtime = this.readyFor(session.header);
+			if (runtime === void 0) return;
+			const projection = projectEvent(event);
+			const until = compactionEnd(event);
+			if (runtime.components.has("formation") && (Object.keys(projection).length > 0 || until !== void 0)) runtime.formation.capture(session.id, projection, until);
+			if (projection.route !== void 0) this.schedule(() => withFileLock(`${runtime.knowledge.context().paths.lastRoute}.lock`, () => writeYamlAtomic(runtime.knowledge.context().paths.lastRoute, projection.route, RouteSchema, runtime.knowledge.logger)));
+		});
+		ctx.on("agent/status", ({ agent, status }) => {
+			if (!this.allowed(agent.session.header) || this.isBase(this.key(agent.session.header)) || isSubagent(agent.session.header)) return;
+			const runtime = this.readyFor(agent.session.header);
+			if (runtime === void 0) return;
+			if (status === "running") runtime.formation.running(agent.session.id);
+			else runtime.formation.idle(agent.session.id);
+		});
+		ctx.on("agent/disposed", ({ agent }) => {
+			this.unboundTools.get(agent.session.id)?.release();
+			this.unboundTools.delete(agent.session.id);
+			const key = this.attached.get(agent.session.id);
+			if (key === void 0) return;
+			const runtime = this.ready.get(key);
+			if (runtime === void 0) return;
+			runtime.formation.disposed(agent.session.id);
+			this.schedule(() => runtime.catalog.forget(agent.session.id));
+			this.attached.delete(agent.session.id);
+			this.instructions.delete(agent.session.id);
+			forgetConfiguration(agent.session.header);
+		});
+		const existing = ctx.agents.list();
+		for (const agent of existing) await this.bind(agent.session.header);
+		existing.sort((left, right) => configurationActivation(right.session.header) - configurationActivation(left.session.header));
+		for (const agent of existing) {
+			const config = this.forSession(agent.session.header);
+			if (config !== void 0 && !this.preferredWorkers.has(identityOf(config))) this.prefer(agent.session.header);
+		}
+		for (const agent of existing) {
+			await this.attach(agent.session.header, "resume", false);
+			this.resumed.add(agent.session.id);
+		}
+	}
+	schedule(action) {
+		if (this.closed) return;
+		this.pending = this.pending.then(action).then(() => {}).catch(() => {
+			this.ctx.logger.warn("Could not persist a connection runtime event.");
+		});
+	}
+	async close() {
+		this.closed = true;
+		for (const entry of this.unboundTools.values()) entry.release();
+		this.unboundTools.clear();
+		for (const state of this.syncs.values()) state.controller?.abort();
+		await this.pending;
+		await Promise.allSettled([...this.syncTasks.values()]);
+		const runtimes = await Promise.allSettled([...this.runtimes.values()]);
+		for (const result of runtimes) if (result.status === "fulfilled") await result.value.close();
+	}
+};
+//#endregion
+//#region src/plugins/knowledge.ts
+const name = "acn-knowledge";
+const inject = [];
+const number = (value) => Schema.number().default(value);
+const boolean = (value) => Schema.boolean().default(value);
+const Config = Schema.object({
+	agentId: Schema.string().default(""),
+	home: Schema.string().default("~/.acn-dsh"),
+	sessionEpoch: number(0),
+	connections: Schema.array(Schema.object({
+		id: Schema.string(),
+		name: Schema.string(),
+		enabled: boolean(true),
+		agentId: Schema.string(),
+		routerEndpoint: Schema.string(),
+		maintainerEndpoint: Schema.string(),
+		keyEnv: Schema.string().default(""),
+		timeoutMs: number(15e3)
+	})).default([]),
+	upstream: Schema.string().default(""),
+	upstreams: Schema.any(),
+	defaultConnection: Schema.string().default(""),
+	legacyEnabled: boolean(true),
+	showCompletion: boolean(true),
+	team: Schema.object({
+		routerEndpoint: Schema.string().default(""),
+		maintainerEndpoint: Schema.string().default(""),
+		keyEnv: Schema.string().default(""),
+		timeoutMs: number(15e3),
+		routerTimeoutMs: number(5e4),
+		retryCount: number(3),
+		retryBaseDelayMs: number(500),
+		retryMaxDelayMs: number(8e3)
+	}),
+	llm: Schema.object({
+		provider: Schema.string().default(""),
+		model: Schema.string().default(""),
+		maxOutputTokens: number(32768),
+		timeoutMs: number(6e5),
+		structuredRetries: number(5)
+	}),
+	catalog: Schema.object({
+		maxClaims: number(20),
+		maxChars: number(24e3)
+	}),
+	formation: Schema.object({
+		recapOnCompaction: boolean(true),
+		idleRecap: boolean(true),
+		recapMinTurns: number(10),
+		recapMinTokens: number(1e5),
+		recapBatchIdleMinutes: number(5),
+		recapTailIdleMinutes: number(60),
+		recapScanSeconds: number(30),
+		finalizeIdleMinutes: number(0),
+		finalizeOnDispose: boolean(false)
+	}),
+	inbox: Schema.object({
+		pullOnSessionStart: boolean(true),
+		processingStaleAfterSecs: number(600)
+	}),
+	dream: Schema.object({
+		enabled: boolean(true),
+		minIntervalHours: number(24),
+		minChangedClaims: number(5),
+		checkIntervalHours: number(4),
+		evidenceCalibration: boolean(false),
+		maxModelSteps: number(24),
+		maxWrapUpSteps: number(3),
+		evidenceMaxCalls: number(32),
+		evidenceMaxSteps: number(24),
+		evidenceMaxBytes: number(1048576),
+		evidenceMaxChars: number(16e3),
+		evidenceMaxFiles: number(256)
+	})
+});
+async function apply(ctx, input = {}) {
+	const config = resolveConfig(input);
+	const knowledge = new AcnKnowledge(config.upstreams === void 0 ? config : {
+		...config,
+		agentId: ""
+	}, ctx.logger, teamCredentials(ctx));
+	await knowledge.initialize();
+	ctx.provide("acnKnowledge", knowledge);
+	const pool = new RuntimePool(ctx, knowledge);
+	ctx.provide("acnRuntime", pool);
+	ctx.effect(() => () => pool.close());
+	if (knowledge.configured || config.upstreams !== void 0 || config.connections.length > 0) ctx.inject([
+		"fs",
+		"tools",
+		"workingDirectory"
+	], (child) => {
+		protectKnowledgePaths(child, knowledge);
+	});
+	const uploads = knowledge.configured && knowledge.active ? new UploadScheduler(knowledge) : null;
+	ctx.effect(() => {
+		const abort = new AbortController();
+		if (knowledge.active && knowledge.team !== null) knowledge.team.health(abort.signal).catch(() => {
+			ctx.logger.warn("Team health check could not complete.");
+		});
+		uploads?.start();
+		return async () => {
+			abort.abort();
+			await uploads?.close();
+			await knowledge.jobs?.close();
+			await knowledge.team?.close();
+		};
+	});
+	ctx.inject([
+		"agents",
+		"sessions",
+		"tools"
+	], (child) => {
+		child.on("session/event", (session, event) => {
+			observeSelection(session.header, event);
+		});
+		child.on("agent/pre-step", async ({ agent }, next) => {
+			if (!pool.chatAllowed(agent.session.header)) throw new Error(sessionChanged);
+			return next();
+		});
+		child.tools.guard((execution) => ["claim", "consult_router"].includes(execution.name) && execution.agent !== void 0 && !pool.allowed(execution.agent.session.header) ? pool.unbound(execution.agent.session.header) ? unboundSession : sessionChanged : void 0);
+		child.on("agent/created", ({ agent }) => {
+			if (config.upstreams === void 0) {
+				bindSession(child, knowledge.config, agent.session.header);
+				if (runningConfiguration(agent.session.header) === void 0 && sessionAllowed(child, knowledge.config, agent.session.header)) rememberConfiguration(agent.session.header, knowledge.config);
+			}
+			uploads?.kick();
+		});
+		if (config.upstreams === void 0) for (const agent of child.agents.list()) bindSession(child, knowledge.config, agent.session.header);
+	});
+	if (knowledge.active) await knowledge.jobs?.start();
+	ctx.logger.info("ACN knowledge plugin activated.");
+}
+var knowledge_default = {
+	name,
+	Config,
+	inject,
+	apply
+};
+//#endregion
+export { Config, apply, knowledge_default as default, inject, name };